I have tried a number of genealogy softwares. None of them out there support the East African style of names.
I have been tinkering with Gramps if it can be adapted to it as well. But, seems it is beyond my capacity.
Here is the thing: the names in East Africa (in Eriterea, Ethiopia and Somalia) do not use surnames/lastnames/family names. There is no common shared family name. Everyone goes by his given name, and his/her father’s (and grand father’s) name will be concatenated to make full names.
The system is bit similar to the Norwegian system; but, not exactly. There is no suffix added in patronyms and the system includes rules for an additional generation.
Here is an example.
Her grand father’s name is John
Her father’s name is James
Her name is Mary
Her official full name will be: Mary James John (this name will be used in official docuements), but most often, in most practical cases, her full name will be Mary James.
Now, what I want is a software that can automatically deduce the additional names from the name of her father (and, if possible: grandfather).
When I tell it that her father’s given name is James, it will display her name as [Mary James].
Gramps already has a feature to guess sur names from Father’s surname. What I want is to have a feature to guess from the father’s own given name.
Except that it will probably take me months (if not years) to understand the codes. I will at least keep the hope that sb or myself will get it down, in contrast to the closed codes where I have no hope at all.
I too looked at your problem. The only thing I came up with is what a person’s name configuration could/should be which Gramps does easily handle. Getting Gramps to automatically fill in the fields is the real issue.
yah, that is the challenge.
The idea was to avoid redundancies:
IN the current system, I need to write each name three times:
John, for example, will be written 3 times:
first as the Surname to Mary
Then, as surname to James
Then, as a given name to John.
A systematic programming would have eliminated the redundancy.
Norwegian middle names can also be deducted from the first name, by the way.
In the above example, the middle name for Mary will: James-dotter. Once you have the gender and the father’s name, you can deduce the middle name. If Mary were a male descendant, the dotter part will change to sen.
I am just familiar with these two cultures because I lived in Norway and Ethiopia. I am sure there are many other naming conventions out there that use similar systematic method.
I looked in the Feature Requests and there are a wide variety of Surname Guessing expansion requests. (Examples: 0003913 Czech, 0008771 Portuguese, 0010996 multiple surname inheritance, 0011729 Given name guessing, 0006979 Lithuanian, 0000614 local recasting) But none seem to point to which section of code handles the rules. None of those examples have advanced past the ‘acknowledged’ stage.
There are expansions that that would be nice for the default guessing scheme. For instance, having the “Name Origin” automatically added would be nice. (I keep forgetting whether American surnames should be patrilineal or patronymic.) I’d like to see something more structured for exposing couverture explicitly during research but using cultural norms in reports.
There are more implications that often need consideration too. Name guessing goes in both directions. Adding a parent to a known person can guess a portion of the eponym’s name: given or surname. Adding a child to a known parent can imply a surname. Plus, could Gramps automatically guess both the common (Given Paternal-namesake Grandpaternal-namesake) & legal/short (Given Paternal-namesake) forms?
But the first step is to find the name-guessing related code. From there, we can explore how easily it can be extended, both in functionality & in the GUI settings.
Well, in this case, finding the code was easy, but alas, it didn’t lead to the result that I hoped for. My strategy was to search for the string ‘Icelandic style’, because that’s one of the options for Surname guessing, and I expected that this string would be processed somewhere. I could also have started with the ‘Surname guessing’ string, because that would lead me to a variable that stores the setting, and that variable is also processed somewhere. This is a strategy that I often use when I’m new to a project.
The strategy worked in so far, that I found some code that reads the config variable, but to my regret, the code that should process the Icelandic style isn’t there. The only options that we have code for are North and Latin American.
def north_american(self):
"""
Child inherits name from father
"""
name = Name()
#the editor requires a surname
name.add_surname(Surname())
name.set_primary_surname(0)
father_handle = self.family.get_father_handle()
if father_handle:
father = self.dbstate.db.get_person_from_handle(father_handle)
preset_name(father, name)
return name
def no_name(self):
name = Name()
#the editor requires a surname
name.add_surname(Surname())
name.set_primary_surname(0)
return name
def latin_american(self):
"""
Child inherits name from father and mother
"""
name = Name()
#the editor requires a surname
name.add_surname(Surname())
name.set_primary_surname(0)
if self.family:
father_handle = self.family.get_father_handle()
father = (self.dbstate.db.get_person_from_handle(father_handle) if
father_handle else None)
mother_handle = self.family.get_mother_handle()
mother = (self.dbstate.db.get_person_from_handle(mother_handle) if
mother_handle else None)
if not father and not mother:
return name
if not father:
preset_name(mother, name)
return name
if not mother:
preset_name(father, name)
return name
#we take first surname, and keep that
mothername = Name()
preset_name(mother, mothername)
preset_name(father, name)
mothersurname = mothername.get_surname_list()[0]
mothersurname.set_primary(False)
name.set_surname_list([name.get_surname_list()[0], mothersurname])
return name
else:
return name
I know that, but that’s not the issue that I mentioned. That is, that we have 4 options, and the code only supports 3. There is no if or procedure for option number 4, icelandic_style.
Ethiopians and Eritreans have no concept of family name and surname. If one is to refer to a person, it’s with a single name and they will always use the person’s given name. Ethiopians and Eritreans use a naming pattern very similar to the Arab naming pattern, but with one exception: no suffix or prefix. The full name of a person is usually two but officially registered with three names. The person’s given name comes first, followed by the person’s father’s given name and (optionally, for official purposes) the grandfather’s name at last. For example, a person named Lemlem Mengesha Abraha has Lemlem as her given name, Mengesha (from her father’s name) Abraha (grandfather’s name). The grandfather’s name is usually only added in official documents and not used in everyday life. The father’s name is not considered a middle name but a last name, without it being a family or surname. The same is true for women; they do not take their husband’s last name. They go independently by their given name, followed by their father’s name, and then their grandfather’s name, even after marriage. In both Ethiopia and Eritrea, a person is always addressed by his first name; for example Mrs. Lemlem or Dr. Lemlem.
since including her grand fathers’s name would complicate the system, let’s ignore John for simplicity sake.
Mary is her given name; and James is her father’s given name. James is going to be used as her last name.
Her last name will be copied from her father’s given name.
The user (I) will write only a single name (the given name) for an individual X. The last name of that individual X will be inherited from the given name of X’s father.
The system is pretty much similar to the Surname guessing. But, in this case, rather than inheriting the surname of the parent/father to the child, it inherits the given name of the parent to the child.
You can call it: LastName guessing: copies the given name of the father to the last name of the child.
def north_american(self):
"""
Child inherits name from father
"""
name = Name()
#the editor requires a surname
name.add_surname(Surname())
name.set_primary_surname(0)
father_handle = self.family.get_father_handle()
if father_handle:
father = self.dbstate.db.get_person_from_handle(father_handle)
preset_name(father, name)
return name
def no_name(self):
name = Name()
#the editor requires a surname
name.add_surname(Surname())
name.set_primary_surname(0)
return name
What does this code do?
At least the comment (the red text) make it sound like it is a code to copy a name from a father to a child.
You’re close. What it actually does is retrieve the father’s primary surname, if available, and return that through the name variable. You can check this on GitHub, where you can click on every procedure, to see what it does. And in this case, that means that you need to click on preset_name.
When you do that, you will see that preset_name goes for the surname, so it’s not good for your purpose.
Note that this code is only invoked when you add a child in the family editor window. When you add one from the relationship view, like I mostly do, another path is taken, which will always use the father’s surname, regardless of what you set in preferences.
This bug was registered and confirmed two years ago:
