# -*- coding: utf-8 -*- # # Gramps - a GTK+/GNOME based genealogy program # # Copyright (C) 2003-2007 Donald N. Allingham # Copyright (C) 2008-2010 Brian G. Matherly # Copyright (C) 2007-2010 Jerome Rapinat # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # #------------------------------------------------------------------------- """ Catalan-specific classes for relationships. By Joan Creus Based on rel_fr.py Relationship names taken from: http://www.scgenealogia.org/pdf/Denominacions%20dels%20Parentius.pdf The only invented name is "cosinastre". Also, "besnetastre" and the like are not explicitly in the dictionary, but "netastre" is. """ #------------------------------------------------------------------------- # # Gramps modules # #------------------------------------------------------------------------- from gramps.gen.lib import Person import gramps.gen.relationship #------------------------------------------------------------------------- # level is used for generation level: # at %th generation _LEVEL_NAME = [ "", "primer", "segon", "tercer", "quart", "cinquè", "sisè", "setè", "vuitè", "novè", "desè", "onzè", "dotzè", "tretzè", "catorzè", "quinzè", "setzè", "dissetè", "divuitè", "dinovè", "vintè", "vint-i-unè", "vint-i-dosè", "vint-i-tresè", "vint-i-quatrè", "vint-i-cinquè", "vint-i-sisè", "vint-i-setè", "vint-i-vuitè", "vint-i-novè", "trentè", ] _LEVEL_NAME_F = [ "", "primera", "segona", "tercera", "quarta", "cinquena", "sisena", "setena", "vuitena", "novena", "desena", "onzena", "dotzena", "tretzena", "catorzena", "quinzena", "setzena", "dissetena", "divuitena", "dinovena", "vintena", "vint-i-unena", "vint-i-dosena", "vint-i-tresena", "vint-i-quatrena", "vint-i-cinquena", "vint-i-sisena", "vint-i-setena", "vint-i-vuitena", "vint-i-novena", "trentena", ] _LEVEL_NAME_P = [ "", "", # si són els primers no es posa mai "segons", "tercers", "quarts", "cinquens", "sisens", "setens", "vuitens", "novens", "desens", "onzens", "dotzens", "tretzens", "catorzens", "quinzens", "setzens", "dissetens", "divuitens", "dinovens", "vintens", "vint-i-unens", "vint-i-dosens", "vint-i-tresens", "vint-i-quatrens", "vint-i-cinquens", "vint-i-sisens", "vint-i-setens", "vint-i-vuitens", "vint-i-novens", "trentens", ] # small lists, use generation level if > [5] # the %s is for the inlaw string _FATHER_LEVEL = ["", "el pare%s", "l'avi%s", "el besavi%s", "el rebesavi%s", "el quadravi%s"] _MOTHER_LEVEL = ["", "la mare%s", "l'àvia%s", "la besàvia%s", "la rebesàvia%s", "la quadràvia%s"] _MOTHER_LEVEL_STP = ["", "la madrastra%s", "l'aviastra%s", "la besaviastra%s", "la rebesaviastra%s", "la quadraviastra%s"] _FATHER_LEVEL_UNK = ["", "un dels pares%s", "un dels avis%s", "un dels besavis%s", "un dels rebesavis%s", "un dels quadravis%s"] _FATHER_LEVEL_STP = ["", "el padrastre%s", "l'aviastre%s", "el besaviastre%s", "el rebesaviastre%s", "el quadraviastre%s"] _FATHER_LEVEL_STPUNK = ["", "un dels padrastres%s", "un dels aviastres%s", "un dels besaviastres%s", "un dels rebesaviastres%s", "un dels quadraviastres%s"] _SON_LEVEL = ["", "el fill%s", "el nét%s", "el besnét%s", "el rebesnét%s", "el quadrinét%s"] _DAUGHTER_LEVEL = ["", "la filla%s", "la néta%s", "la besnéta%s", "la rebesnéta%s", "la quadrinéta%s"] _SON_LEVEL_UNK = ["", "un dels fills%s", "un dels néts%s", "un dels besnéts%s", "un dels rebesnéts%s", "un dels quadrinéts%s"] _SON_LEVEL_STP = ["", "el fillastre%s", "el netastre%s", "el besnetastre%s", "el rebesnetastre%s", "el quadrinetastre%s"] _SON_LEVEL_STPUNK = ["", "un dels fillastres%s", "un dels netastres%s", "un dels besnetastres%s", "un dels rebesnetastres%s", "un dels quadrinetastres%s"] _DAUGHTER_LEVEL_STP = ["", "la fillastra%s", "la netastra%s", "la besnetastra%s", "la rebesnetastra%s", "la quadrinetastra%s"] _BROTHER_LEVEL = ["", "el germà%s", "l'oncle%s", "el besoncle%s", "el rebesoncle%s", "el quadrioncle%s"] _SISTER_LEVEL = ["", "la germana%s", "la tia%s", "la bestia%s", "la rebestia%s", "la quadritia%s"] _BROTHER_LEVEL_UNK = ["", "un dels germans%s", "un dels oncles%s", "un dels besoncles%s", "un dels rebesoncles%s", "un dels quadrioncles%s"] _BROTHER_LEVEL_STP = ["", "el germanastre%s", "l'onclastre%s", "el besonclastre%s", "el rebesonclastre%s", "el quadrionclastre%s"] _BROTHER_LEVEL_STPUNK = ["", "un dels germanastres%s", "un dels onclastres%s", "un dels besonclastres%s", "un dels rebesonclastres%s", "un dels quadrionclastres%s"] _SISTER_LEVEL_STP = ["", "la germanastra%s", "la tiastra%s", "la bestiastra%s", "la rebestiastra%s", "la quadritiastra%s"] _NEPHEW_LEVEL = ["", "el nebot%s", "el besnebot%s", "el rebesnebot%s", "el quadrinebot%s"] _NIECE_LEVEL = ["", "la neboda%s", "la besneboda%s", "la rebesneboda%s", "la quadrineboda%s"] _NEPHEW_LEVEL_UNK = ["", "un dels nebots%s", "un dels besnebots%s", "un dels rebesnebots%s", "un dels quadrinebots%s"] _NEPHEW_LEVEL_STP = ["", "el nebodastre%s", "el besnebodastre%s", "el rebesnebodastre%s", "el quadrinebodastre%s"] _NEPHEW_LEVEL_STPUNK = ["", "un dels nebodastres%s", "un dels besnebodastres%s", "un dels rebesnebodastres%s", "un dels quadrinebodastres%s"] _NIECE_LEVEL_STP = ["", "la nebodastra%s", "la besnebodastra%s", "la rebesnebodastra%s", "la quadrinebodastra%s"] # kinship report _PARENTS_LEVEL = ["", "Els pares", "Els avis", "Els besavis", "Els rebesavis", "Els quadravis"] _CHILDREN_LEVEL = ["", "Els fills", "Els néts", "Els besnéts", "Els rebesnéts", "Els quadrinéts"] _SIBLINGS_LEVEL = ["", "Els germans i les germanes", "Els oncles i les ties", "Els besoncles i les besties", "Els rebesoncles i les rebesties", "Els quadrioncles i les quadrities"] _NEPHEWS_NIECES_LEVEL = ["", "Els nebots i les nebodes", "Els besnebots i les besnebodes", "Els rebesnebots i les rebesnebodes", "Els quadrinebots i les quadrinebodes"] #------------------------------------------------------------------------- # # # #------------------------------------------------------------------------- # from active person to common ancestor Ga=[level] def _get_cosi(level, inlaw="", step=""): """ cousins = same level, gender = male """ if step == "": nom = "cosí" else: nom = "cosinastre" if level == 1: return "el %s germà%s" % (nom, inlaw) elif level < len(_LEVEL_NAME): return "el %s %s%s" % (nom, _LEVEL_NAME[level], inlaw) else: return "el %s %dè%s" % (nom, level, inlaw) def _get_cosina(level, inlaw="", step=""): """ cousins = same level, gender = female """ if (inlaw != ""): # polític -> política inlaw += "a" if step == "": nom = "cosina" else: nom = "cosinastra" if level == 1: return "la %s germana%s" % (nom, inlaw) elif level < len(_LEVEL_NAME): return "la %s %s%s" % (nom, _LEVEL_NAME_F[level], inlaw) else: return "la %s %dena%s" % (nom, level, inlaw) def _get_cosi_unknown(level, inlaw="", step=""): """ cousins = same level, gender = unknown """ if (inlaw != ""): # polític -> polítics inlaw += "s" if step == "": nom = "cosins" else: nom = "cosinastres" if level == 1: return "un dels %s germans%s" % (nom, inlaw) elif level < len(_LEVEL_NAME): return "un dels %s %s%s" % (nom, _LEVEL_NAME_P[level], inlaw) else: return "un dels %s %dens%s" % (nom, level, inlaw) def _get_father(level, inlaw="", step=""): """ ancestor, gender = male """ if step == "": taula = _FATHER_LEVEL nom = "avi" else: taula = _FATHER_LEVEL_STP nom = "aviastre" if level < len(taula): return taula[level] % inlaw elif level <= len(_LEVEL_NAME): return "l'%s %s%s" % \ (nom, _LEVEL_NAME[level-1], inlaw) else: # use numerical generation return "l'%s %dè%s" % (nom, (level -1), inlaw) def _get_mother(level, inlaw="", step=""): """ ancestor, gender = female """ if (inlaw != ""): inlaw += "a" if step == "": taula = _MOTHER_LEVEL nom = "àvia" else: taula = _MOTHER_LEVEL_STP nom = "aviastra" if level < len(taula) : return taula[level] % inlaw # limitation gen = 30 elif level <= len(_LEVEL_NAME_F): return "l'%s %s%s" % \ (nom, _LEVEL_NAME_F[level-1], inlaw) else: # use numerical generation return "l'àvia %dena%s" % ((level -1), inlaw) def _get_parent_unknown(level, inlaw="", step=""): """ unknown parent """ if (inlaw != ""): inlaw += "s" if step == "": taula = _FATHER_LEVEL_UNK nom = "avis" else: taula = _FATHER_LEVEL_STPUNK nom = "aviastres" if level < len(taula): return taula[level] % inlaw elif level <= len(_LEVEL_NAME_P): return "un dels %s %s%s" % \ (nom, _LEVEL_NAME_P[level-1], inlaw) else: # use numerical generation return "un dels %s %dens%s" % (nom, (level -1), inlaw) def _get_son(level, inlaw="", step=""): """ descendant, gender = male """ if step == "": taula = _SON_LEVEL nom = "nét" else: taula = _SON_LEVEL_STP nom = "netastre" if level < len(taula): return taula[level] % inlaw elif level <= len(_LEVEL_NAME): return "el %s %s%s" % \ (nom, _LEVEL_NAME[level-1], inlaw) else: # use numerical generation return "el %s %dè%s" % (nom, (level -1), inlaw) def _get_sons(level, inlaw=""): """ descendants for kinship report """ if (inlaw != ""): # polític -> polítics inlaw += "s" if inlaw != "" and level == 1 : return "els gendres i les joves" elif level < len(_CHILDREN_LEVEL): return _CHILDREN_LEVEL[level] + inlaw elif level < len(_LEVEL_NAME_P) - 1: return "els néts" + _LEVEL_NAME_P[level - 1] + inlaw else: return "els néts %dens" % (level - 1) + inlaw def _get_daughter(level, inlaw="", step=""): """ descendant, gender = female """ if step == "": taula = _DAUGHTER_LEVEL nom = "néta" else: taula = _DAUGHTER_LEVEL_STP nom = "netastra" if (inlaw != ""): inlaw += "a" if level < len(taula): return taula[level] % inlaw elif level <= len(_LEVEL_NAME_F): return "la %s %s%s" % \ (nom, _LEVEL_NAME_F[level-1], inlaw) else: # use numerical generation return "la %s %dena%s" % (nom, (level -1), inlaw) def _get_child_unknown(level, inlaw="", step=""): """ descendant, gender = unknown """ if (inlaw != ""): inlaw += "s" if step == "": taula = _SON_LEVEL_UNK nom = "néts" else: taula = _SON_LEVEL_STPUNK nom = "netastres" if level < len(taula): return taula[level] % inlaw elif level <= len(_LEVEL_NAME_P): return "un dels %s %s%s" % \ (nom, _LEVEL_NAME_P[level-1], inlaw) else: # use numerical generation return "un dels %s %dens%s" % (nom, (level -1), inlaw) def _get_sibling_unknown(level, inlaw="", step=""): """ sibling of an ancestor, gender = unknown """ if (inlaw != ""): inlaw += "s" if step == "": taula = _BROTHER_LEVEL_UNK nom = "oncles" else: taula = _BROTHER_LEVEL_STPUNK nom = "onclastres" if level < len(taula): return (taula[level] % inlaw) elif level <= len(_LEVEL_NAME_P): # limitation gen = 30 return "un dels %s %s%s" % \ (nom, _LEVEL_NAME_P[level-1], inlaw) else : # use numerical generation return "un dels %s %dens%s" % \ (nom, (level - 1), inlaw) def _get_uncle(level, inlaw="", step=""): """ sibling of an ancestor, gender = male """ if step == "": taula = _BROTHER_LEVEL nom = "oncle" else: taula = _BROTHER_LEVEL_STP nom = "onclastre" if level < len(taula): return (taula[level] % inlaw) elif level <= len(_LEVEL_NAME): # limitation gen = 30 return "l'%s %s%s" % \ (nom, _LEVEL_NAME[level-1], inlaw) else : # use numerical generation return "l'%s %dè%s" % \ (nom, (level - 1), inlaw) def _get_aunt(level, inlaw="", step=""): """ sibling of an ancestor, gender = female """ if step == "": taula = _SISTER_LEVEL nom = "tia" else: taula = _SISTER_LEVEL_STP nom = "tiastra" if (inlaw != ""): inlaw += "a" if level < len(taula): return (taula[level] % inlaw) elif level <= len(_LEVEL_NAME_F): return "la %s %s%s" % \ (nom, _LEVEL_NAME_F[level-1], inlaw) else : # use numerical generation return "la %s %dena%s" % \ (nom, (level - 1), inlaw) def _get_uncles(level, inlaw=""): """ siblings for kinship report """ if (inlaw != ""): inlaw += "s" if inlaw != "" and level == 1 : return "els cunyats i les cunyades" elif level < len(_SIBLINGS_LEVEL) : return "%s%s" % \ (_SIBLINGS_LEVEL[level], inlaw) elif level <= len(_LEVEL_NAME_P) : return "els oncles i les ties %s%s" % \ (_LEVEL_NAME_P[level-1], inlaw) else: # use numerical generation return "els oncles i les ties %dens%s" % \ ((level-1), inlaw) def _get_cosins(level, inlaw=""): """ same generation level for kinship report """ if (inlaw != ""): inlaw += "s" if level == 2: rel_str = "els cosins germans"+inlaw elif level <= len(_LEVEL_NAME_P): rel_str = "els cosins %s%s" % (_LEVEL_NAME_P[level - 1], inlaw) else: # security rel_str = "els cosins %dens%s" % ((level - 1), inlaw) return rel_str def _get_nephew(level, inlaw="", step=""): """ cousin of a descendant, gender = male """ if step == "": taula = _NEPHEW_LEVEL nom = "nebot" else: taula = _NEPHEW_LEVEL_STP nom = "nebodastre" if level < len(taula): return (taula[level] % inlaw) elif level < len(_LEVEL_NAME): return "el %s %s%s" % \ (nom, _LEVEL_NAME[level], inlaw) else : # use numerical generation return "el %s %dè%s" % (nom, level, inlaw) def _get_nephew_unk(level, inlaw="", step=""): """ cousin of a descendant, gender = unknown """ if (inlaw != ""): inlaw += "s" if step == "": taula = _NEPHEW_LEVEL_UNK nom = "nebots" else: taula = _NEPHEW_LEVEL_STPUNK nom = "nebodastres" if level < len(taula): return (taula[level] % inlaw) elif level < len(_LEVEL_NAME): return "un dels %s %s%s" % \ (nom, _LEVEL_NAME_P[level], inlaw) else : # use numerical generation return "un dels %s %dens%s" % (nom, level, inlaw) def _get_niece(level, inlaw="", step=""): """ cousin of a descendant, gender = female """ if (inlaw != ""): inlaw += "a" if step == "": taula = _NIECE_LEVEL nom = "neboda" else: taula = _NIECE_LEVEL_STP nom = "nebodastra" if level < len(taula): return (taula[level] % inlaw) elif level < len(_LEVEL_NAME_F): return "la %s %s%s" % \ (nom, _LEVEL_NAME_F[level], inlaw) else : # use numerical generation return "la %s %dena%s" % (nom, level, inlaw) def _get_nephews(level, inlaw=""): """ cousin of a descendant, gender = male """ if (inlaw != ""): inlaw += "s" if level <= len(_NEPHEWS_NIECES_LEVEL) : # limitation gen = 30 return "%s%s" % (_NEPHEWS_NIECES_LEVEL[level-1], inlaw) elif level <= len(_LEVEL_NAME_P) : return "els nebots i les nebodes %s%s" % \ (_LEVEL_NAME_P[level-1], inlaw) else: # use numerical generation return "els nebots i les nebodes %dens%s" % \ ((level-1), inlaw) def _get_oncle_valencia(levela, levelb, inlaw="", step=""): """ removed cousins, older generations """ if levela <= levelb: return "error a _get_oncle_valencia" val_level = levela-levelb amplada = levelb-1 retorn = _get_uncle(val_level+1, "", step) if amplada == 1: stramplada = "" else: stramplada = _LEVEL_NAME[amplada] return retorn+" valencià "+ stramplada+inlaw def _get_oncles_valencians(levela, levelb, inlaw=""): """ removed cousins, older generations for kinship report """ if (inlaw != ""): inlaw += "s" if levela <= levelb: return "error a _get_oncles_valencians" val_level = levela-levelb amplada = levelb-1 retorn = _get_uncles(val_level+1, "") if amplada == 1: stramplada = "" else: stramplada = _LEVEL_NAME_P[amplada] return retorn+" valencians "+ stramplada+inlaw def _get_nebot_valencia(levela, levelb, inlaw="", step=""): """ removed cousins, younger generations """ if levelb <= levela: return "error a _get_nebot_valencia" val_level = levelb-levela amplada = levela - 1 retorn = _get_nephew(val_level, "", step) if amplada == 1: stramplada = "" else: stramplada = _LEVEL_NAME[amplada] return retorn+" valencià "+ stramplada+inlaw def _get_nebots_valencians(levela, levelb, inlaw=""): """ removed cousins, younger generations, for kinship report gender = male """ if (inlaw != ""): inlaw += "s" if levelb <= levela: return "error a _get_nebots_valencians" val_level = levelb-levela amplada = levela - 1 retorn = _get_nephews(val_level+1, "") if amplada == 1: stramplada = "" else: stramplada = _LEVEL_NAME_P[amplada] return retorn+" valencians "+ stramplada+inlaw def _get_tia_valenciana(levela, levelb, inlaw="", step=""): """ removed cousins, older generations gender = female """ if (inlaw != ""): inlaw += "a" if levela <= levelb: return "error a _get_tia_valenciana" val_level = levela-levelb amplada = levelb-1 retorn = _get_aunt(val_level+1, "", step) if amplada == 1: stramplada = "" else: stramplada = _LEVEL_NAME_F[amplada] return retorn+" valenciana "+ stramplada+inlaw def _get_neboda_valenciana(levela, levelb, inlaw="", step=""): """ removed cousins, younger generations gender = female """ if (inlaw != ""): inlaw += "a" if levelb <= levela: return "error a _get_neboda_valenciana" val_level = levelb-levela amplada = levela - 1 retorn = _get_niece(val_level, "", step) if amplada == 1: stramplada = "" else: stramplada = _LEVEL_NAME_F[amplada] return retorn+" valenciana "+ stramplada+inlaw class RelationshipCalculator(gramps.gen.relationship.RelationshipCalculator): """ RelationshipCalculator Class """ INLAW = ' polític' def __init__(self): gramps.gen.relationship.RelationshipCalculator.__init__(self) # kinship report def get_plural_relationship_string(self, Ga, Gb, reltocommon_a='', reltocommon_b='', only_birth=True, in_law_a=False, in_law_b=False): """ see relationship.py """ rel_str = "parents llunyans" #atgen = " de la %sena generació" #bygen = " per la %sena generació" #cmt = " (germans o germanes d'un avantpassat" + atgen % Ga + ")" if in_law_a or in_law_b: inlaw = self.INLAW else: inlaw = "" if Ga == 0: # These are descendants rel_str = _get_sons(Gb, inlaw) elif Gb == 0: # These are parents/grand parents if Ga < len(_PARENTS_LEVEL): rel_str = _PARENTS_LEVEL[Ga] elif Ga < len(_LEVEL_NAME_P) -1: rel_str = "els avis " + _LEVEL_NAME_P[Ga - 1] else: rel_str = "els avis %dens" % (Ga - 1) elif Gb == 1: # These are siblings/aunts/uncles rel_str = _get_uncles(Ga, inlaw) elif Ga == 1: # These are nieces/nephews rel_str = _get_nephews(Gb, inlaw) elif Ga > 1: if Ga == Gb: # These are cousins in the same generation rel_str = _get_cosins(Ga, inlaw) elif Ga > Gb: # These are cousins in different generations with the second # person being in a higher generation from the common ancestor # than the first person. rel_str = _get_oncles_valencians(Ga, Gb, inlaw) elif Gb > Ga: # These are cousins in different generations with the second # person being in a higher generation from the common ancestor # than the first person. rel_str = _get_nebots_valencians(Ga, Gb, inlaw) else: rel_str = "Error in get_plural_relationship_string()" return rel_str # quick report (missing on RelCalc tool - Status Bar) def get_single_relationship_string( self, Ga, Gb, gender_a, gender_b, reltocommon_a, reltocommon_b, only_birth=True, in_law_a=False, in_law_b=False, ): """ see relationship.py """ if only_birth: step = "" else: step = self.STEP if in_law_a or in_law_b: inlaw = self.INLAW else: inlaw = "" rel_str = "un parent llunyà%s" % inlaw #bygen = " per la %sena generació" if Ga == 0: # b is descendant of a if Gb == 0: rel_str = "la mateixa persona" elif gender_b == Person.MALE: # spouse of daughter if inlaw and Gb == 1 and not step: rel_str = "el gendre" else: rel_str = _get_son(Gb, inlaw, step) elif gender_b == Person.FEMALE: # spouse of son if inlaw and Gb == 1 and not step: rel_str = "la jove" else: rel_str = _get_daughter(Gb, inlaw, step) else: rel_str = _get_child_unknown(Gb, inlaw, step) elif Gb == 0: # b is parents/grand parent of a if gender_b == Person.MALE: # father of spouse (family of spouse) if Ga == 1 and inlaw and not step: rel_str = "el sogre" else: rel_str = _get_father(Ga, inlaw, step) elif gender_b == Person.FEMALE: # mother of spouse (family of spouse) if Ga == 1 and inlaw and not step: rel_str = "la sogra" else: rel_str = _get_mother(Ga, inlaw, step) else: rel_str = _get_parent_unknown(Ga, inlaw, step) elif Gb == 1: # b is sibling/aunt/uncle of a if inlaw and Ga == 1 and not step: if gender_b == Person.MALE: rel_str = "el cunyat" elif gender_b == Person.FEMALE: rel_str = "la cunyada" else: # gender_b == Person.UNKNOWN: rel_str = "un cunyat" elif gender_b == Person.MALE : rel_str = _get_uncle(Ga, inlaw, step) elif gender_b == Person.FEMALE : rel_str = _get_aunt(Ga, inlaw, step) else: rel_str = _get_sibling_unknown(Ga, inlaw, step) elif Ga == 1: # b is niece/nephew of a if gender_b == Person.MALE: rel_str = _get_nephew(Gb - 1, inlaw, step) elif gender_b == Person.FEMALE: rel_str = _get_niece(Gb - 1, inlaw, step) elif gender_b == Person.UNKNOWN: rel_str = _get_nephew_unk(Gb - 1, inlaw, step) else: # This should never get executed rel_str = "un nebot%s llunyà (%dena generació)" % (inlaw, Gb) elif Ga == Gb: # a and b cousins in the same generation if gender_b == Person.MALE: rel_str = _get_cosi(Ga - 1, inlaw, step) elif gender_b == Person.FEMALE: rel_str = _get_cosina(Ga - 1, inlaw, step) elif gender_b == Person.UNKNOWN: rel_str = _get_cosi_unknown(Ga-1, inlaw, step) else: rel_str = "error in get_single_relationship_string()" elif Ga > 1 and Ga > Gb: # These are cousins in different generations with the second person # being in a higher generation from the common ancestor than the # first person. if gender_b == Person.MALE: rel_str = _get_oncle_valencia(Ga, Gb, inlaw, step) elif gender_b == Person.FEMALE: rel_str = _get_tia_valenciana(Ga, Gb, inlaw, step) else: rel_str = _get_oncle_valencia(Ga, Gb, inlaw, step) elif Gb > 1 and Gb > Ga: # These are cousins in different generations with the second person # being in a lower generation from the common ancestor than the # first person. if gender_b == Person.MALE: rel_str = _get_nebot_valencia(Ga, Gb, inlaw, step) elif gender_b == Person.FEMALE: rel_str = _get_neboda_valenciana(Ga, Gb, inlaw, step) else: rel_str = _get_nebot_valencia(Ga, Gb, inlaw, step) return rel_str # RelCalc tool - Status Bar def get_sibling_relationship_string(self, sib_type, gender_a, gender_b, in_law_a=False, in_law_b=False): """ voir relationship.py """ if in_law_a or in_law_b: inlaw = self.INLAW else: inlaw = "" if sib_type == self.NORM_SIB: if not inlaw: if gender_b == Person.MALE: rel_str = "el germà" elif gender_b == Person.FEMALE: rel_str = "la germana" else: rel_str = "el germà o germana" else: if gender_b == Person.MALE: rel_str = "el cunyat" elif gender_b == Person.FEMALE: rel_str = "la cunyada" else: rel_str = "el cunyat o la cunyada" elif sib_type == self.UNKNOWN_SIB: if not inlaw: if gender_b == Person.MALE: rel_str = "el germà" elif gender_b == Person.FEMALE: rel_str = "la germana" else: rel_str = "el germà o germana" else: if gender_b == Person.MALE: rel_str = "el cunyat" elif gender_b == Person.FEMALE: rel_str = "la cunyada" else: rel_str = "el cunyat o la cunyada" elif sib_type == self.HALF_SIB_MOTHER \ or sib_type == self.HALF_SIB_FATHER \ or sib_type == self.STEP_SIB: if not inlaw: if gender_b == Person.MALE: rel_str = "el germanastre" elif gender_b == Person.FEMALE: rel_str = "la germanastra" else: rel_str = "el germanastre o la germanastra" else: if gender_b == Person.MALE: rel_str = "el cunyat" elif gender_b == Person.FEMALE: rel_str = "la cunyada" else: rel_str = "el cunyat o la cunyada" return rel_str if __name__ == "__main__": # Test function. Call it as follows from the command line (so as to find # imported modules): # export PYTHONPATH=/path/to/gramps/src # python src/plugins/rel/rel_ca.py # (Above not needed here) #"" # TRANSLATORS, copy this if statement at the bottom of your # rel_xx.py module, and test your work with: # python src/plugins/rel/rel_xx.py #"" from gramps.gen.relationship import test RC = RelationshipCalculator() test(RC, True)