1120 lines
31 KiB
Python
1120 lines
31 KiB
Python
# -*- 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
# $Id$
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
"""
|
|
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
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
|
|
import gen.lib
|
|
import Relationship
|
|
|
|
#-------------------------------------------------------------------------
|
|
|
|
# level is used for generation level:
|
|
# at %th generation
|
|
|
|
_LEVEL_NAME = [
|
|
u"",
|
|
u"primer",
|
|
u"segon",
|
|
u"tercer",
|
|
u"quart",
|
|
u"cinquè",
|
|
u"sisè",
|
|
U"setè",
|
|
u"vuitè",
|
|
u"novè",
|
|
u"desè",
|
|
u"onzè",
|
|
u"dotzè",
|
|
u"tretzè",
|
|
u"catorzè",
|
|
u"quinzè",
|
|
u"setzè",
|
|
u"dissetè",
|
|
u"divuitè",
|
|
u"dinovè",
|
|
u"vintè",
|
|
u"vint-i-unè",
|
|
u"vint-i-dosè",
|
|
u"vint-i-tresè",
|
|
u"vint-i-quatrè",
|
|
u"vint-i-cinquè",
|
|
u"vint-i-sisè",
|
|
u"vint-i-setè",
|
|
u"vint-i-vuitè",
|
|
u"vint-i-novè",
|
|
u"trentè",
|
|
]
|
|
|
|
_LEVEL_NAME_F = [
|
|
u"",
|
|
u"primera",
|
|
u"segona",
|
|
u"tercera",
|
|
u"quarta",
|
|
u"cinquena",
|
|
u"sisena",
|
|
u"setena",
|
|
u"vuitena",
|
|
u"novena",
|
|
u"desena",
|
|
u"onzena",
|
|
u"dotzena",
|
|
u"tretzena",
|
|
u"catorzena",
|
|
u"quinzena",
|
|
u"setzena",
|
|
u"dissetena",
|
|
u"divuitena",
|
|
u"dinovena",
|
|
u"vintena",
|
|
u"vint-i-unena",
|
|
u"vint-i-dosena",
|
|
u"vint-i-tresena",
|
|
u"vint-i-quatrena",
|
|
u"vint-i-cinquena",
|
|
u"vint-i-sisena",
|
|
u"vint-i-setena",
|
|
u"vint-i-vuitena",
|
|
u"vint-i-novena",
|
|
u"trentena",
|
|
]
|
|
|
|
_LEVEL_NAME_P = [
|
|
u"",
|
|
u"", # si són els primers no es posa mai
|
|
u"segons",
|
|
u"tercers",
|
|
u"quarts",
|
|
u"cinquens",
|
|
u"sisens",
|
|
u"setens",
|
|
u"vuitens",
|
|
u"novens",
|
|
u"desens",
|
|
u"onzens",
|
|
u"dotzens",
|
|
u"tretzens",
|
|
u"catorzens",
|
|
u"quinzens",
|
|
u"setzens",
|
|
u"dissetens",
|
|
u"divuitens",
|
|
u"dinovens",
|
|
u"vintens",
|
|
u"vint-i-unens",
|
|
u"vint-i-dosens",
|
|
u"vint-i-tresens",
|
|
u"vint-i-quatrens",
|
|
u"vint-i-cinquens",
|
|
u"vint-i-sisens",
|
|
u"vint-i-setens",
|
|
u"vint-i-vuitens",
|
|
u"vint-i-novens",
|
|
u"trentens",
|
|
]
|
|
|
|
# small lists, use generation level if > [5]
|
|
# the %s is for the inlaw string
|
|
|
|
_FATHER_LEVEL = [u"", u"el pare%s", u"l'avi%s",
|
|
u"el besavi%s", u"el rebesavi%s", u"el quadravi%s"]
|
|
|
|
_MOTHER_LEVEL = [u"", u"la mare%s", u"l'àvia%s",
|
|
u"la besàvia%s", u"la rebesàvia%s", u"la quadràvia%s"]
|
|
|
|
_MOTHER_LEVEL_STP = [u"", u"la madrastra%s", u"l'aviastra%s",
|
|
u"la besaviastra%s", u"la rebesaviastra%s",
|
|
u"la quadraviastra%s"]
|
|
|
|
_FATHER_LEVEL_UNK = [u"", u"un dels pares%s", u"un dels avis%s",
|
|
u"un dels besavis%s", u"un dels rebesavis%s",
|
|
u"un dels quadravis%s"]
|
|
|
|
_FATHER_LEVEL_STP = [u"", u"el padrastre%s", u"l'aviastre%s",
|
|
u"el besaviastre%s", u"el rebesaviastre%s",
|
|
u"el quadraviastre%s"]
|
|
|
|
_FATHER_LEVEL_STPUNK = [u"", u"un dels padrastres%s", u"un dels aviastres%s",
|
|
u"un dels besaviastres%s", u"un dels rebesaviastres%s",
|
|
u"un dels quadraviastres%s"]
|
|
|
|
_SON_LEVEL = [u"", u"el fill%s", u"el nét%s",
|
|
u"el besnét%s", u"el rebesnét%s", u"el quadrinét%s"]
|
|
|
|
_DAUGHTER_LEVEL = [u"", u"la filla%s", u"la néta%s",
|
|
u"la besnéta%s", u"la rebesnéta%s", u"la quadrinéta%s"]
|
|
|
|
_SON_LEVEL_UNK = [u"", u"un dels fills%s", u"un dels néts%s",
|
|
u"un dels besnéts%s", u"un dels rebesnéts%s",
|
|
u"un dels quadrinéts%s"]
|
|
|
|
_SON_LEVEL_STP = [u"", u"el fillastre%s", u"el netastre%s",
|
|
u"el besnetastre%s", u"el rebesnetastre%s",
|
|
u"el quadrinetastre%s"]
|
|
|
|
_SON_LEVEL_STPUNK = [u"", u"un dels fillastres%s", u"un dels netastres%s",
|
|
u"un dels besnetastres%s", u"un dels rebesnetastres%s",
|
|
u"un dels quadrinetastres%s"]
|
|
|
|
_DAUGHTER_LEVEL_STP = [u"", u"la fillastra%s", u"la netastra%s",
|
|
u"la besnetastra%s", u"la rebesnetastra%s",
|
|
u"la quadrinetastra%s"]
|
|
|
|
_BROTHER_LEVEL = [u"", u"el germà%s", u"l'oncle%s", u"el besoncle%s",
|
|
u"el rebesoncle%s", u"el quadrioncle%s"]
|
|
|
|
_SISTER_LEVEL = [u"", u"la germana%s", u"la tia%s", u"la bestia%s",
|
|
u"la rebestia%s", u"la quadritia%s"]
|
|
|
|
_BROTHER_LEVEL_UNK = [u"", u"un dels germans%s", u"un dels oncles%s",
|
|
u"un dels besoncles%s", u"un dels rebesoncles%s",
|
|
u"un dels quadrioncles%s"]
|
|
|
|
_BROTHER_LEVEL_STP = [u"", u"el germanastre%s", u"l'onclastre%s",
|
|
u"el besonclastre%s", u"el rebesonclastre%s",
|
|
u"el quadrionclastre%s"]
|
|
|
|
_BROTHER_LEVEL_STPUNK = [u"", u"un dels germanastres%s",
|
|
u"un dels onclastres%s", u"un dels besonclastres%s",
|
|
u"un dels rebesonclastres%s",
|
|
u"un dels quadrionclastres%s"]
|
|
|
|
_SISTER_LEVEL_STP = [u"", u"la germanastra%s", u"la tiastra%s",
|
|
u"la bestiastra%s", u"la rebestiastra%s",
|
|
u"la quadritiastra%s"]
|
|
|
|
_NEPHEW_LEVEL = [u"", u"el nebot%s", u"el besnebot%s",
|
|
u"el rebesnebot%s", u"el quadrinebot%s"]
|
|
|
|
_NIECE_LEVEL = [u"", u"la neboda%s", u"la besneboda%s",
|
|
u"la rebesneboda%s", u"la quadrineboda%s"]
|
|
|
|
_NEPHEW_LEVEL_UNK = [u"", u"un dels nebots%s", u"un dels besnebots%s",
|
|
u"un dels rebesnebots%s", u"un dels quadrinebots%s"]
|
|
|
|
_NEPHEW_LEVEL_STP = [u"", u"el nebodastre%s", u"el besnebodastre%s",
|
|
u"el rebesnebodastre%s", u"el quadrinebodastre%s"]
|
|
|
|
_NEPHEW_LEVEL_STPUNK = [u"", u"un dels nebodastres%s",
|
|
u"un dels besnebodastres%s",
|
|
u"un dels rebesnebodastres%s",
|
|
u"un dels quadrinebodastres%s"]
|
|
|
|
_NIECE_LEVEL_STP = [u"", u"la nebodastra%s", u"la besnebodastra%s",
|
|
u"la rebesnebodastra%s", u"la quadrinebodastra%s"]
|
|
|
|
# kinship report
|
|
|
|
_PARENTS_LEVEL = [u"", u"Els pares", u"Els avis",
|
|
u"Els besavis", u"Els rebesavis", u"Els quadravis"]
|
|
|
|
_CHILDREN_LEVEL = [u"", u"Els fills", u"Els néts",
|
|
u"Els besnéts",
|
|
u"Els rebesnéts", u"Els quadrinéts"]
|
|
|
|
_SIBLINGS_LEVEL = [u"", u"Els germans i les germanes",
|
|
u"Els oncles i les ties",
|
|
u"Els besoncles i les besties",
|
|
u"Els rebesoncles i les rebesties",
|
|
u"Els quadrioncles i les quadrities"]
|
|
|
|
_NEPHEWS_NIECES_LEVEL = [u"", u"Els nebots i les nebodes",
|
|
u"Els besnebots i les besnebodes",
|
|
u"Els rebesnebots i les rebesnebodes",
|
|
u"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 = u"cosí"
|
|
else:
|
|
nom = u"cosinastre"
|
|
|
|
if level == 1:
|
|
return u"el %s germà%s" % (nom, inlaw)
|
|
elif level < len(_LEVEL_NAME):
|
|
return u"el %s %s%s" % (nom, _LEVEL_NAME[level], inlaw)
|
|
else:
|
|
return u"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 = u"cosina"
|
|
else:
|
|
nom = u"cosinastra"
|
|
|
|
if level == 1:
|
|
return u"la %s germana%s" % (nom, inlaw)
|
|
elif level < len(_LEVEL_NAME):
|
|
return u"la %s %s%s" % (nom, _LEVEL_NAME_F[level], inlaw)
|
|
else:
|
|
return u"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 = u"cosins"
|
|
else:
|
|
nom = u"cosinastres"
|
|
|
|
if level == 1:
|
|
return u"un dels %s germans%s" % (nom, inlaw)
|
|
elif level < len(_LEVEL_NAME):
|
|
return u"un dels %s %s%s" % (nom, _LEVEL_NAME_P[level], inlaw)
|
|
else:
|
|
return u"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 u"l'%s %s%s" % \
|
|
(nom, _LEVEL_NAME[level-1], inlaw)
|
|
else:
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 = u"àvia"
|
|
else:
|
|
taula = _MOTHER_LEVEL_STP
|
|
nom = u"aviastra"
|
|
|
|
if level < len(taula) :
|
|
return taula[level] % inlaw
|
|
|
|
# limitation gen = 30
|
|
|
|
elif level <= len(_LEVEL_NAME_F):
|
|
|
|
return u"l'%s %s%s" % \
|
|
(nom, _LEVEL_NAME_F[level-1], inlaw)
|
|
else:
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"un dels %s %s%s" % \
|
|
(nom, _LEVEL_NAME_P[level-1], inlaw)
|
|
else:
|
|
|
|
# use numerical generation
|
|
return u"un dels %s %dens%s" % (nom, (level -1), inlaw)
|
|
|
|
def _get_son(level, inlaw="", step=""):
|
|
"""
|
|
descendant, gender = male
|
|
"""
|
|
if step == "":
|
|
taula = _SON_LEVEL
|
|
nom = u"nét"
|
|
else:
|
|
taula = _SON_LEVEL_STP
|
|
nom = "netastre"
|
|
|
|
if level < len(taula):
|
|
return taula[level] % inlaw
|
|
|
|
elif level <= len(_LEVEL_NAME):
|
|
|
|
return u"el %s %s%s" % \
|
|
(nom, _LEVEL_NAME[level-1], inlaw)
|
|
else:
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"els gendres i les joves"
|
|
elif level < len(_CHILDREN_LEVEL):
|
|
return _CHILDREN_LEVEL[level] + inlaw
|
|
elif level < len(_LEVEL_NAME_P) - 1:
|
|
return u"els néts" + _LEVEL_NAME_P[level - 1] + inlaw
|
|
else:
|
|
return u"els néts %dens" % (level - 1) + inlaw
|
|
|
|
def _get_daughter(level, inlaw="", step=""):
|
|
"""
|
|
descendant, gender = female
|
|
"""
|
|
if step == "":
|
|
taula = _DAUGHTER_LEVEL
|
|
nom = u"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 u"la %s %s%s" % \
|
|
(nom, _LEVEL_NAME_F[level-1], inlaw)
|
|
else:
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 = u"néts"
|
|
else:
|
|
taula = _SON_LEVEL_STPUNK
|
|
nom = "netastres"
|
|
|
|
if level < len(taula):
|
|
return taula[level] % inlaw
|
|
|
|
elif level <= len(_LEVEL_NAME_P):
|
|
|
|
return u"un dels %s %s%s" % \
|
|
(nom, _LEVEL_NAME_P[level-1], inlaw)
|
|
else:
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"un dels %s %s%s" % \
|
|
(nom, _LEVEL_NAME_P[level-1], inlaw)
|
|
else :
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"l'%s %s%s" % \
|
|
(nom, _LEVEL_NAME[level-1], inlaw)
|
|
else :
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"la %s %s%s" % \
|
|
(nom, _LEVEL_NAME_F[level-1], inlaw)
|
|
else :
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"els cunyats i les cunyades"
|
|
elif level < len(_SIBLINGS_LEVEL) :
|
|
return u"%s%s" % \
|
|
(_SIBLINGS_LEVEL[level], inlaw)
|
|
elif level <= len(_LEVEL_NAME_P) :
|
|
return u"els oncles i les ties %s%s" % \
|
|
(_LEVEL_NAME_P[level-1], inlaw)
|
|
else:
|
|
# use numerical generation
|
|
return u"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 = u"els cosins germans"+inlaw
|
|
elif level <= len(_LEVEL_NAME_P):
|
|
|
|
rel_str = u"els cosins %s%s" % (_LEVEL_NAME_P[level - 1], inlaw)
|
|
else:
|
|
# security
|
|
rel_str = u"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 u"el %s %s%s" % \
|
|
(nom, _LEVEL_NAME[level], inlaw)
|
|
else :
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"un dels %s %s%s" % \
|
|
(nom, _LEVEL_NAME_P[level], inlaw)
|
|
else :
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"la %s %s%s" % \
|
|
(nom, _LEVEL_NAME_F[level], inlaw)
|
|
else :
|
|
|
|
# use numerical generation
|
|
|
|
return u"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 u"%s%s" % (_NEPHEWS_NIECES_LEVEL[level-1], inlaw)
|
|
elif level <= len(_LEVEL_NAME_P) :
|
|
|
|
return u"els nebots i les nebodes %s%s" % \
|
|
(_LEVEL_NAME_P[level-1], inlaw)
|
|
else:
|
|
# use numerical generation
|
|
|
|
return u"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 u"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+u" 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 u"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+u" valencians "+ stramplada+inlaw
|
|
|
|
def _get_nebot_valencia(levela, levelb, inlaw="", step=""):
|
|
"""
|
|
removed cousins, younger generations
|
|
"""
|
|
if levelb <= levela:
|
|
return u"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+u" 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 u"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+u" 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 u"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+u" 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 u"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+u" valenciana "+ stramplada+inlaw
|
|
|
|
class RelationshipCalculator(Relationship.RelationshipCalculator):
|
|
"""
|
|
RelationshipCalculator Class
|
|
"""
|
|
|
|
INLAW = u' polític'
|
|
|
|
def __init__(self):
|
|
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 = u"parents llunyans"
|
|
#atgen = u" de la %sena generació"
|
|
#bygen = u" per la %sena generació"
|
|
#cmt = u" (germans o germanes d'un avantpassat" + atgen % Ga + ")"
|
|
|
|
if in_law_a or in_law_b:
|
|
inlaw = self.INLAW
|
|
else:
|
|
inlaw = u""
|
|
|
|
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 = u"els avis " + _LEVEL_NAME_P[Ga - 1]
|
|
else:
|
|
rel_str = u"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 = u""
|
|
|
|
rel_str = u"un parent llunyà%s" % inlaw
|
|
#bygen = u" per la %sena generació"
|
|
if Ga == 0:
|
|
|
|
# b is descendant of a
|
|
|
|
if Gb == 0:
|
|
rel_str = u"la mateixa persona"
|
|
elif gender_b == gen.lib.Person.MALE:
|
|
|
|
# spouse of daughter
|
|
|
|
if inlaw and Gb == 1 and not step:
|
|
rel_str = u"el gendre"
|
|
else:
|
|
rel_str = _get_son(Gb, inlaw, step)
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
|
|
# spouse of son
|
|
|
|
if inlaw and Gb == 1 and not step:
|
|
rel_str = u"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 == gen.lib.Person.MALE:
|
|
|
|
# father of spouse (family of spouse)
|
|
if Ga == 1 and inlaw and not step:
|
|
rel_str = u"el sogre"
|
|
|
|
else:
|
|
rel_str = _get_father(Ga, inlaw, step)
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
|
|
# mother of spouse (family of spouse)
|
|
if Ga == 1 and inlaw and not step:
|
|
rel_str = u"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 == gen.lib.Person.MALE:
|
|
rel_str = "el cunyat"
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = "la cunyada"
|
|
else: # gender_b == gen.lib.Person.UNKNOWN:
|
|
rel_str = "un cunyat"
|
|
|
|
elif gender_b == gen.lib.Person.MALE :
|
|
rel_str = _get_uncle(Ga, inlaw, step)
|
|
elif gender_b == gen.lib.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 == gen.lib.Person.MALE:
|
|
rel_str = _get_nephew(Gb - 1, inlaw, step)
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = _get_niece(Gb - 1, inlaw, step)
|
|
elif gender_b == gen.lib.Person.UNKNOWN:
|
|
rel_str = _get_nephew_unk(Gb - 1, inlaw, step)
|
|
else:
|
|
# This should never get executed
|
|
rel_str = u"un nebot%s llunyà (%dena generació)" % (inlaw, Gb)
|
|
elif Ga == Gb:
|
|
|
|
# a and b cousins in the same generation
|
|
|
|
if gender_b == gen.lib.Person.MALE:
|
|
rel_str = _get_cosi(Ga - 1, inlaw, step)
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = _get_cosina(Ga - 1, inlaw, step)
|
|
elif gender_b == gen.lib.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 == gen.lib.Person.MALE:
|
|
rel_str = _get_oncle_valencia(Ga, Gb, inlaw, step)
|
|
elif gender_b == gen.lib.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 == gen.lib.Person.MALE:
|
|
rel_str = _get_nebot_valencia(Ga, Gb, inlaw, step)
|
|
elif gender_b == gen.lib.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 = u""
|
|
|
|
if sib_type == self.NORM_SIB:
|
|
if not inlaw:
|
|
if gender_b == gen.lib.Person.MALE:
|
|
rel_str = u"el germà"
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = u"la germana"
|
|
else:
|
|
rel_str = u"el germà o germana"
|
|
else:
|
|
if gender_b == gen.lib.Person.MALE:
|
|
rel_str = u"el cunyat"
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = u"la cunyada"
|
|
else:
|
|
rel_str = u"el cunyat o la cunyada"
|
|
elif sib_type == self.UNKNOWN_SIB:
|
|
if not inlaw:
|
|
if gender_b == gen.lib.Person.MALE:
|
|
rel_str = u"el germà"
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = u"la germana"
|
|
else:
|
|
rel_str = u"el germà o germana"
|
|
else:
|
|
if gender_b == gen.lib.Person.MALE:
|
|
rel_str = u"el cunyat"
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = u"la cunyada"
|
|
else:
|
|
rel_str = u"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 == gen.lib.Person.MALE:
|
|
rel_str = u"el germanastre"
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = u"la germanastra"
|
|
else:
|
|
rel_str = u"el germanastre o la germanastra"
|
|
else:
|
|
if gender_b == gen.lib.Person.MALE:
|
|
rel_str = u"el cunyat"
|
|
elif gender_b == gen.lib.Person.FEMALE:
|
|
rel_str = u"la cunyada"
|
|
else:
|
|
rel_str = u"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 Relationship import test
|
|
RC = RelationshipCalculator()
|
|
test(RC, True)
|