Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2007-11-10 Benny Malengier <benny.malengier@gramps-project.org>

Browse Source 
* src/plugins/all_relations.py: collapse inlaws
	* src/plugins/Ancestors.py: use new calling grandparent string
	* src/plugins/rel_nl.py: change to new API
	* src/plugins/rel_it.py: change comment
	* src/plugins/rel_pl.py: use old filter
	* src/Relationship.py: improvements, protected methods

2007-11-08 Benny Malengier <benny.malengier@gramps-project.org>


svn: r9325
This commit is contained in:
Benny Malengier
2007-11-10 14:54:29 +00:00
parent 6e329879a4
commit 635ff9e829
7 changed files with 859 additions and 527 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
ChangeLog
View File

@@ -1,4 +1,12 @@
2007-11-07 Benny Malengier <benny.malengier@gramps-project.org> 2007-11-10 Benny Malengier <benny.malengier@gramps-project.org>
* src/plugins/all_relations.py: collapse inlaws
* src/plugins/Ancestors.py: use new calling grandparent string
* src/plugins/rel_nl.py: change to new API
* src/plugins/rel_it.py: change comment
* src/plugins/rel_pl.py: use old filter
* src/Relationship.py: improvements, protected methods
2007-11-08 Benny Malengier <benny.malengier@gramps-project.org>
* TODO: update * TODO: update
* src/DisplayTabs/_EventEmbedList.py: catch managed window crash * src/DisplayTabs/_EventEmbedList.py: catch managed window crash

667
src/Relationship.py
View File

@@ -55,111 +55,205 @@ _removed_level = [ "", " once removed", " twice removed",
" eighteen times removed", " eighteen times removed",
" nineteen times removed", " twenty times removed" ] " nineteen times removed", " twenty times removed" ]
_parents_level = [ "", "parents", "grandparents", "great grandparents", "second great grandparents", _parents_level = [ "", "parents", "grandparents", "great grandparents",
"third great grandparents", "fourth great grandparents", "second great grandparents",
"fifth great grandparents", "sixth great grandparents", "third great grandparents",
"seventh great grandparents", "eighth great grandparents", "fourth great grandparents",
"ninth great grandparents", "tenth great grandparents", "fifth great grandparents",
"eleventh great grandparents", "twelfth great grandparents", "sixth great grandparents",
"thirteenth great grandparents", "fourteenth great grandparents", "seventh great grandparents",
"fifteenth great grandparents", "sixteenth great grandparents", "eighth great grandparents",
"seventeenth great grandparents", "eighteenth great grandparents", "ninth great grandparents",
"nineteenth great grandparents", "twentieth great grandparents", ] "tenth great grandparents",
"eleventh great grandparents",
"twelfth great grandparents",
"thirteenth great grandparents",
"fourteenth great grandparents",
"fifteenth great grandparents",
"sixteenth great grandparents",
"seventeenth great grandparents",
"eighteenth great grandparents",
"nineteenth great grandparents",
"twentieth great grandparents", ]
_father_level = [ "", "%sfather%s", "%sgrandfather%s", "great %sgrandfather%s", _father_level = [ "", "%(step)sfather%(inlaw)s", "%(step)sgrandfather%(inlaw)s",
"second great %sgrandfather%s", "great %(step)sgrandfather%(inlaw)s",
"third great %sgrandfather%s", "fourth great %sgrandfather%s", "second great %(step)sgrandfather%(inlaw)s",
"fifth great %sgrandfather%s", "sixth great %sgrandfather%s", "third great %(step)sgrandfather%(inlaw)s",
"seventh great %sgrandfather%s", "eighth great %sgrandfather%s", "fourth great %(step)sgrandfather%(inlaw)s",
"ninth great %sgrandfather%s", "tenth great %sgrandfather%s", "fifth great %(step)sgrandfather%(inlaw)s",
"eleventh great %sgrandfather%s", "twelfth great %sgrandfather%s", "sixth great %(step)sgrandfather%(inlaw)s",
"thirteenth great %sgrandfather%s", "fourteenth great %sgrandfather%s", "seventh great %(step)sgrandfather%(inlaw)s",
"fifteenth great %sgrandfather%s", "sixteenth great %sgrandfather%s", "eighth great %(step)sgrandfather%(inlaw)s",
"seventeenth great %sgrandfather%s", "eighteenth great %sgrandfather%s", "ninth great %(step)sgrandfather%(inlaw)s",
"nineteenth great %sgrandfather%s", "twentieth great %sgrandfather%s", ] "tenth great %(step)sgrandfather%(inlaw)s",
"eleventh great %(step)sgrandfather%(inlaw)s",
"twelfth great %(step)sgrandfather%(inlaw)s",
"thirteenth great %(step)sgrandfather%(inlaw)s",
"fourteenth great %(step)sgrandfather%(inlaw)s",
"fifteenth great %(step)sgrandfather%(inlaw)s",
"sixteenth great %(step)sgrandfather%(inlaw)s",
"seventeenth great %(step)sgrandfather%(inlaw)s",
"eighteenth great %(step)sgrandfather%(inlaw)s",
"nineteenth great %(step)sgrandfather%(inlaw)s",
"twentieth great %(step)sgrandfather%(inlaw)s", ]
_mother_level = [ "", "%smother%s", "%sgrandmother%s", "great %sgrandmother%s", _mother_level = [ "", "%(step)smother%(inlaw)s",
"second great %sgrandmother%s", "%(step)sgrandmother%(inlaw)s",
"third great %sgrandmother%s", "fourth great %sgrandmother%s", "great %(step)sgrandmother%(inlaw)s",
"fifth great %sgrandmother%s", "sixth great %sgrandmother%s", "second great %(step)sgrandmother%(inlaw)s",
"seventh great %sgrandmother%s", "eighth great %sgrandmother%s", "third great %(step)sgrandmother%(inlaw)s",
"ninth great %sgrandmother%s", "tenth great %sgrandmother%s", "fourth great %(step)sgrandmother%(inlaw)s",
"eleventh great %sgrandmother%s", "twelfth great %sgrandmother%s", "fifth great %(step)sgrandmother%(inlaw)s",
"thirteenth great %sgrandmother%s", "fourteenth great %sgrandmother%s", "sixth great %(step)sgrandmother%(inlaw)s",
"fifteenth great %sgrandmother%s", "sixteenth great %sgrandmother%s", "seventh great %(step)sgrandmother%(inlaw)s",
"seventeenth great %sgrandmother%s", "eighteenth great %sgrandmother%s", "eighth great %(step)sgrandmother%(inlaw)s",
"nineteenth great %sgrandmother%s", "twentieth great %sgrandmother%s", ] "ninth great %(step)sgrandmother%(inlaw)s",
"tenth great %(step)sgrandmother%(inlaw)s",
"eleventh great %(step)sgrandmother%(inlaw)s",
"twelfth great %(step)sgrandmother%(inlaw)s",
"thirteenth great %(step)sgrandmother%(inlaw)s",
"fourteenth great %(step)sgrandmother%(inlaw)s",
"fifteenth great %(step)sgrandmother%(inlaw)s",
"sixteenth great %(step)sgrandmother%(inlaw)s",
"seventeenth great %(step)sgrandmother%(inlaw)s",
"eighteenth great %(step)sgrandmother%(inlaw)s",
"nineteenth great %(step)sgrandmother%(inlaw)s",
"twentieth great %(step)sgrandmother%(inlaw)s", ]
_son_level = [ "", "%sson", "%sgrandson", "great %sgrandson", "second great %sgrandson", _son_level = [ "", "%(step)sson", "%(step)sgrandson",
"third great %sgrandson", "fourth great %sgrandson", "great %(step)sgrandson",
"fifth great %sgrandson", "sixth great %sgrandson", "second great %(step)sgrandson",
"seventh great %sgrandson", "eighth great %sgrandson", "third great %(step)sgrandson",
"ninth great %sgrandson", "tenth great %sgrandson", "fourth great %(step)sgrandson",
"eleventh great %sgrandson", "twelfth great %sgrandson", "fifth great %(step)sgrandson",
"thirteenth great %sgrandson", "fourteenth great %sgrandson", "sixth great %(step)sgrandson",
"fifteenth great %sgrandson", "sixteenth great %sgrandson", "seventh great %(step)sgrandson",
"seventeenth great %sgrandson", "eighteenth great %sgrandson", "eighth great %(step)sgrandson",
"nineteenth great %sgrandson", "twentieth great %sgrandson", ] "ninth great %(step)sgrandson",
"tenth great %(step)sgrandson",
"eleventh great %(step)sgrandson",
"twelfth great %(step)sgrandson",
"thirteenth great %(step)sgrandson",
"fourteenth great %(step)sgrandson",
"fifteenth great %(step)sgrandson",
"sixteenth great %(step)sgrandson",
"seventeenth great %(step)sgrandson",
"eighteenth great %(step)sgrandson",
"nineteenth great %(step)sgrandson",
"twentieth great %(step)sgrandson", ]
_daughter_level = [ "", "%sdaughter", "%sgranddaughter", "great %sgranddaughter", _daughter_level = [ "", "%(step)sdaughter", "%(step)sgranddaughter",
"second great %sgranddaughter", "great %(step)sgranddaughter",
"third great %sgranddaughter", "fourth great %sgranddaughter", "second great %(step)sgranddaughter",
"fifth great %sgranddaughter", "sixth great %sgranddaughter", "third great %(step)sgranddaughter",
"seventh great %sgranddaughter", "eighth great %sgranddaughter", "fourth great %(step)sgranddaughter",
"ninth great %sgranddaughter", "tenth great %sgranddaughter", "fifth great %(step)sgranddaughter",
"eleventh great %sgranddaughter", "twelfth great %sgranddaughter", "sixth great %(step)sgranddaughter",
"thirteenth great %sgranddaughter", "fourteenth great %sgranddaughter", "seventh great %(step)sgranddaughter",
"fifteenth great %sgranddaughter", "sixteenth great %sgranddaughter", "eighth great %(step)sgranddaughter",
"seventeenth great %sgranddaughter", "eighteenth great %sgranddaughter", "ninth great %(step)sgranddaughter",
"nineteenth great %sgranddaughter", "twentieth great %sgranddaughter", ] "tenth great %(step)sgranddaughter",
"eleventh great %(step)sgranddaughter",
"twelfth great %(step)sgranddaughter",
"thirteenth great %(step)sgranddaughter",
"fourteenth great %(step)sgranddaughter",
"fifteenth great %(step)sgranddaughter",
"sixteenth great %(step)sgranddaughter",
"seventeenth great %(step)sgranddaughter",
"eighteenth great %(step)sgranddaughter",
"nineteenth great %(step)sgranddaughter",
"twentieth great %(step)sgranddaughter", ]
_sister_level = [ "", "%ssister%s", "%saunt%s", "%sgrandaunt%s", _sister_level = [ "", "%(step)ssister%(inlaw)s", "%(step)saunt%(inlaw)s",
"great %sgrandaunt%s", "second great %sgrandaunt%s", "%(step)sgrandaunt%(inlaw)s",
"third great %sgrandaunt%s", "fourth great %sgrandaunt%s", "great %(step)sgrandaunt%(inlaw)s",
"fifth great %sgrandaunt%s", "sixth great %sgrandaunt%s", "second great %(step)sgrandaunt%(inlaw)s",
"seventh great %sgrandaunt%s", "eighth great %sgrandaunt%s", "third great %(step)sgrandaunt%(inlaw)s",
"ninth great %sgrandaunt%s", "tenth great %sgrandaunt%s", "fourth great %(step)sgrandaunt%(inlaw)s",
"eleventh great %sgrandaunt%s", "twelfth great %sgrandaunt%s", "fifth great %(step)sgrandaunt%(inlaw)s",
"thirteenth great %sgrandaunt%s", "fourteenth great %sgrandaunt%s", "sixth great %(step)sgrandaunt%(inlaw)s",
"fifteenth great %sgrandaunt%s", "sixteenth great %sgrandaunt%s", "seventh great %(step)sgrandaunt%(inlaw)s",
"seventeenth great %sgrandaunt%s", "eighteenth great %sgrandaunt%s", "eighth great %(step)sgrandaunt%(inlaw)s",
"nineteenth great %sgrandaunt%s", "twentieth great %sgrandaunt%s", ] "ninth great %(step)sgrandaunt%(inlaw)s",
"tenth great %(step)sgrandaunt%(inlaw)s",
"eleventh great %(step)sgrandaunt%(inlaw)s",
"twelfth great %(step)sgrandaunt%(inlaw)s",
"thirteenth great %(step)sgrandaunt%(inlaw)s",
"fourteenth great %(step)sgrandaunt%(inlaw)s",
"fifteenth great %(step)sgrandaunt%(inlaw)s",
"sixteenth great %(step)sgrandaunt%(inlaw)s",
"seventeenth great %(step)sgrandaunt%(inlaw)s",
"eighteenth great %(step)sgrandaunt%(inlaw)s",
"nineteenth great %(step)sgrandaunt%(inlaw)s",
"twentieth great %(step)sgrandaunt%(inlaw)s", ]
_brother_level = [ "", "%sbrother%s", "%suncle%s", "%sgranduncle%s", _brother_level = [ "", "%(step)sbrother%(inlaw)s", "%(step)suncle%(inlaw)s",
"great %sgranduncle%s", "second great %sgranduncle%s", "%(step)sgranduncle%(inlaw)s",
"third great %sgranduncle%s", "fourth great %sgranduncle%s", "great %(step)sgranduncle%(inlaw)s",
"fifth great %sgranduncle%s", "sixth great %sgranduncle%s", "second great %(step)sgranduncle%(inlaw)s",
"seventh great %sgranduncle%s", "eighth great %sgranduncle%s", "third great %(step)sgranduncle%(inlaw)s",
"ninth great %sgranduncle%s", "tenth great %sgranduncle%s", "fourth great %(step)sgranduncle%(inlaw)s",
"eleventh great %sgranduncle%s", "twelfth great %sgranduncle%s", "fifth great %(step)sgranduncle%(inlaw)s",
"thirteenth great %sgranduncle%s", "fourteenth great %sgranduncle%s", "sixth great %(step)sgranduncle%(inlaw)s",
"fifteenth great %sgranduncle%s", "sixteenth great %sgranduncle%s", "seventh great %(step)sgranduncle%(inlaw)s",
"seventeenth great %sgranduncle%s", "eighteenth great %sgranduncle%s", "eighth great %(step)sgranduncle%(inlaw)s",
"nineteenth great %sgranduncle%s", "twentieth great %sgranduncle%s", ] "ninth great %(step)sgranduncle%(inlaw)s",
"tenth great %(step)sgranduncle%(inlaw)s",
"eleventh great %(step)sgranduncle%(inlaw)s",
"twelfth great %(step)sgranduncle%(inlaw)s",
"thirteenth great %(step)sgranduncle%(inlaw)s",
"fourteenth great %(step)sgranduncle%(inlaw)s",
"fifteenth great %(step)sgranduncle%(inlaw)s",
"sixteenth great %(step)sgranduncle%(inlaw)s",
"seventeenth great %(step)sgranduncle%(inlaw)s",
"eighteenth great %(step)sgranduncle%(inlaw)s",
"nineteenth great %(step)sgranduncle%(inlaw)s",
"twentieth great %(step)sgranduncle%(inlaw)s", ]
_nephew_level = [ "", "%snephew%s", "%sgrandnephew%s", "great %sgrandnephew%s", _nephew_level = [ "", "%(step)snephew%(inlaw)s", "%(step)sgrandnephew%(inlaw)s",
"second great %sgrandnephew%s", "great %(step)sgrandnephew%(inlaw)s",
"third great %sgrandnephew%s", "fourth great %sgrandnephew%s", "second great %(step)sgrandnephew%(inlaw)s",
"fifth great %sgrandnephew%s", "sixth great %sgrandnephew%s", "third great %(step)sgrandnephew%(inlaw)s",
"seventh great %sgrandnephew%s", "eighth great %sgrandnephew%s", "fourth great %(step)sgrandnephew%(inlaw)s",
"ninth great %sgrandnephew%s", "tenth great %sgrandnephew%s", "fifth great %(step)sgrandnephew%(inlaw)s",
"eleventh great %sgrandnephew%s", "twelfth great %sgrandnephew%s", "sixth great %(step)sgrandnephew%(inlaw)s",
"thirteenth great %sgrandnephew%s", "fourteenth great %sgrandnephew%s", "seventh great %(step)sgrandnephew%(inlaw)s",
"fifteenth great %sgrandnephew%s", "sixteenth great %sgrandnephew%s", "eighth great %(step)sgrandnephew%(inlaw)s",
"seventeenth great %sgrandnephew%s", "eighteenth great %sgrandnephew%s", "ninth great %(step)sgrandnephew%(inlaw)s",
"nineteenth great %sgrandnephew%s", "twentieth great %sgrandnephew%s", ] "tenth great %(step)sgrandnephew%(inlaw)s",
"eleventh great %(step)sgrandnephew%(inlaw)s",
"twelfth great %(step)sgrandnephew%(inlaw)s",
"thirteenth great %(step)sgrandnephew%(inlaw)s",
"fourteenth great %(step)sgrandnephew%(inlaw)s",
"fifteenth great %(step)sgrandnephew%(inlaw)s",
"sixteenth great %(step)sgrandnephew%(inlaw)s",
"seventeenth great %(step)sgrandnephew%(inlaw)s",
"eighteenth great %(step)sgrandnephew%(inlaw)s",
"nineteenth great %(step)sgrandnephew%(inlaw)s",
"twentieth great %(step)sgrandnephew%(inlaw)s", ]
_niece_level = [ "", "%sniece%s", "%sgrandniece%s", "great %sgrandniece%s", _niece_level = [ "", "%(step)sniece%(inlaw)s", "%(step)sgrandniece%(inlaw)s",
"second great %sgrandniece%s", "great %(step)sgrandniece%(inlaw)s",
"third great %sgrandniece%s", "fourth great %sgrandniece%s", "second great %(step)sgrandniece%(inlaw)s",
"fifth great %sgrandniece%s", "sixth great %sgrandniece%s", "third great %(step)sgrandniece%(inlaw)s",
"seventh great %sgrandniece%s", "eighth great %sgrandniece%s", "fourth great %(step)sgrandniece%(inlaw)s",
"ninth great %sgrandniece%s", "tenth great %sgrandniece%s", "fifth great %(step)sgrandniece%(inlaw)s",
"eleventh great %sgrandniece%s", "twelfth great %sgrandniece%s", "sixth great %(step)sgrandniece%(inlaw)s",
"thirteenth great %sgrandniece%s", "fourteenth great %sgrandniece%s", "seventh great %(step)sgrandniece%(inlaw)s",
"fifteenth great %sgrandniece%s", "sixteenth great %sgrandniece%s", "eighth great %(step)sgrandniece%(inlaw)s",
"seventeenth great %sgrandniece%s", "eighteenth great %sgrandniece%s", "ninth great %(step)sgrandniece%(inlaw)s",
"nineteenth great %sgrandniece%s", "twentieth great %sgrandniece%s", ] "tenth great %(step)sgrandniece%(inlaw)s",
"eleventh great %(step)sgrandniece%(inlaw)s",
"twelfth great %(step)sgrandniece%(inlaw)s",
"thirteenth great %(step)sgrandniece%(inlaw)s",
"fourteenth great %(step)sgrandniece%(inlaw)s",
"fifteenth great %(step)sgrandniece%(inlaw)s",
"sixteenth great %(step)sgrandniece%(inlaw)s",
"seventeenth great %(step)sgrandniece%(inlaw)s",
"eighteenth great %(step)sgrandniece%(inlaw)s",
"nineteenth great %(step)sgrandniece%(inlaw)s",
"twentieth great %(step)sgrandniece%(inlaw)s", ]
_children_level = [ "", _children_level = [ "",
"children", "grandchildren", "children", "grandchildren",
@@ -189,18 +283,29 @@ _siblings_level = [ "",
"twentieth great granduncles/aunts", ] "twentieth great granduncles/aunts", ]
_sibling_level = [ "", _sibling_level = [ "",
"%ssibling%s", "%suncle/aunt%s", "%(step)ssibling%(inlaw)s",
"%sgranduncle/aunt%s", "great %sgranduncle/aunt%s", "%(step)suncle/aunt%(inlaw)s",
"second great %sgranduncle/aunt%s", "third great %sgranduncle/aunt%s", "%(step)sgranduncle/aunt%(inlaw)s",
"fourth great %sgranduncle/aunt%s", "fifth great %sgranduncle/aunt%s", "great %(step)sgranduncle/aunt%(inlaw)s",
"sixth great %sgranduncle/aunt%s", "seventh great %sgranduncle/aunt%s", "second great %(step)sgranduncle/aunt%(inlaw)s",
"eighth great %sgranduncle/aunt%s", "ninth great %sgranduncle/aunt%s", "third great %(step)sgranduncle/aunt%(inlaw)s",
"tenth great %sgranduncle/aunt%s", "eleventh great %sgranduncle/aunt%s", "fourth great %(step)sgranduncle/aunt%(inlaw)s",
"twelfth great %sgranduncle/aunt%s", "thirteenth great %sgranduncle/aunt%s", "fifth great %(step)sgranduncle/aunt%(inlaw)s",
"fourteenth great %sgranduncle/aunt%s", "fifteenth great %sgranduncle/aunt%s", "sixth great %(step)sgranduncle/aunt%(inlaw)s",
"sixteenth great %sgranduncle/aunt%s", "seventeenth great %sgranduncle/aunt%s", "seventh great %(step)sgranduncle/aunt%(inlaw)s",
"eighteenth great %sgranduncle/aunt%s", "nineteenth great %sgranduncle/aunt%s", "eighth great %(step)sgranduncle/aunt%(inlaw)s",
"twentieth great %sgranduncle/aunt%s", ] "ninth great %(step)sgranduncle/aunt%(inlaw)s",
"tenth great %(step)sgranduncle/aunt%(inlaw)s",
"eleventh great %(step)sgranduncle/aunt%(inlaw)s",
"twelfth great %(step)sgranduncle/aunt%(inlaw)s",
"thirteenth great %(step)sgranduncle/aunt%(inlaw)s",
"fourteenth great %(step)sgranduncle/aunt%(inlaw)s",
"fifteenth great %(step)sgranduncle/aunt%(inlaw)s",
"sixteenth great %(step)sgranduncle/aunt%(inlaw)s",
"seventeenth great %(step)sgranduncle/aunt%(inlaw)s",
"eighteenth great %(step)sgranduncle/aunt%(inlaw)s",
"nineteenth great %(step)sgranduncle/aunt%(inlaw)s",
"twentieth great %(step)sgranduncle/aunt%(inlaw)s", ]
_nephews_nieces_level = [ "", _nephews_nieces_level = [ "",
"siblings", "siblings",
@@ -258,9 +363,10 @@ class RelationshipCalculator:
#sibling strings #sibling strings
STEP= 'step' STEP= 'step'
INLAW='-in-law'
HALF = 'half-' HALF = 'half-'
INLAW='-in-law'
#partner types #partner types
PARTNER_MARRIED = 1 PARTNER_MARRIED = 1
PARTNER_UNMARRIED = 2 PARTNER_UNMARRIED = 2
@@ -280,62 +386,129 @@ class RelationshipCalculator:
else: else:
return _parents_level[level] return _parents_level[level]
def get_father(self, level, step='', inlaw=''): DIST_FATHER = "distant %(step)sancestor%(inlaw)s (%(level)d generations)"
def _get_father(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level>len(_father_level)-1: if level>len(_father_level)-1:
return "distant %sancestor%s (%d generations)" % (step, inlaw, return self.DIST_FATHER % {'step': step, 'inlaw': inlaw,
level) 'level': level}
else: else:
return _father_level[level] % (step, inlaw) return _father_level[level] % {'step': step, 'inlaw': inlaw}
def get_son(self, level, step=''): DIST_SON = "distant %(step)sdescendant (%(level)d generations)"
def _get_son(self, level, step=''):
"""Internal english method to create relation string
"""
if level>len(_son_level)-1: if level>len(_son_level)-1:
return "distant %sdescendant (%d generations)" % (step, level) return self.DIST_SON % {'step': step, 'level': level}
else: else:
return _son_level[level] % step return _son_level[level] % {'step': step}
def get_mother(self, level, step='', inlaw=''): DIST_MOTHER = "distant %(step)sancestor%(inlaw)s (%(level)d generations)"
def _get_mother(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level>len(_mother_level)-1: if level>len(_mother_level)-1:
return "distant %sancestor%s (%d generations)" % (step, inlaw, return self.DIST_MOTHER % {'step': step, 'inlaw': inlaw,
level) 'level': level}
else: else:
return _mother_level[level] % (step, inlaw) return _mother_level[level] % {'step': step, 'inlaw': inlaw}
def get_daughter(self, level, step=''): DIST_DAUGHTER = "distant %(step)sdescendant (%(level)d generations)"
def _get_daughter(self, level, step=''):
"""Internal english method to create relation string
"""
if level>len(_daughter_level)-1: if level>len(_daughter_level)-1:
return "distant %sdescendant (%d generations)" % (step, level) return self.DIST_DAUGHTER % {'step': step, 'level': level}
else: else:
return _daughter_level[level] % step return _daughter_level[level] % {'step': step}
def get_parent_unknown(self, level, step='', inlaw=''): def _get_parent_unknown(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level < len(_level_name): if level < len(_level_name):
return _level_name[level] + ' ' + '%sancestor%s' % (step, inlaw) return _level_name[level] + ' ' + '%sancestor%s' % (step, inlaw)
else: else:
return "distant %sancestor%s (%d generations)" % (step, inlaw, return "distant %sancestor%s (%d generations)" % (step, inlaw,
level) level)
def get_child_unknown(self, level, step=''): DIST_CHILD = "distant %(step)sdescendant (%(level)d generations)"
def _get_child_unknown(self, level, step=''):
"""Internal english method to create relation string
"""
if level < len(_level_name): if level < len(_level_name):
return _level_name[level] + ' ' + '%sdescendant' % step return _level_name[level] + ' ' + '%sdescendant' % step
else: else:
return "distant %sdescendant (%d generations)" % (step, level) return self.DIST_CHILD % {'step': step, 'level': level}
def get_aunt(self, level, step='', inlaw=''): DIST_AUNT = "distant %(step)saunt%(inlaw)s"
def _get_aunt(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level>len(_sister_level)-1: if level>len(_sister_level)-1:
return "distant %saunt%s" % (step, inlaw) return self.DIST_AUNT % {'step': step, 'inlaw': inlaw}
else: else:
return _sister_level[level] % (step, inlaw) return _sister_level[level] % {'step': step, 'inlaw': inlaw}
def get_uncle(self, level, step='', inlaw=''): DIST_UNCLE = "distant %(step)suncle%(inlaw)s"
def _get_uncle(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level>len(_brother_level)-1: if level>len(_brother_level)-1:
return "distant %suncle%s" % (step, inlaw) return self.DIST_UNCLE % {'step': step, 'inlaw': inlaw}
else: else:
return _brother_level[level] % (step, inlaw) return _brother_level[level] % {'step': step, 'inlaw': inlaw}
def get_sibling(self, level, step='', inlaw=''): DIST_NEPHEW = "distant %(step)snephew%(inlaw)s"
if level < len(_sibling_level):
return _sibling_level[level] % (step, inlaw) def _get_nephew(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level>len(_nephew_level)-1:
return self.DIST_NEPHEW % {'step': step, 'inlaw': inlaw}
else: else:
return "distant %suncle%s/%saunt%s " % (step, inlaw, step, inlaw) return _nephew_level[level] % {'step': step, 'inlaw': inlaw}
DIST_NIECE = "distant %(step)sniece%(inlaw)s"
def _get_niece(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level>len(_niece_level)-1:
return self.DIST_NIECE % {'step': step, 'inlaw': inlaw}
else:
return _niece_level[level] % {'step': step, 'inlaw': inlaw}
def _get_cousin(self, level, removed, dir = '', step='', inlaw=''):
"""Internal english method to create relation string
"""
if removed == 0 and level < len(_level_name):
return "%s %scousin%s" % (_level_name[level],
step, inlaw)
elif removed > len(_removed_level)-1 or level>len(_level_name)-1:
return "distant %srelative%s" % (step, inlaw)
else:
return "%s %scousin%s%s%s" % (_level_name[level],
step, inlaw,
_removed_level[removed], dir)
DIST_SIB = "distant %(step)suncle/aunt%(inlaw)s"
def _get_sibling(self, level, step='', inlaw=''):
"""Internal english method to create relation string
"""
if level < len(_sibling_level):
return _sibling_level[level] % {'step': step, 'inlaw': inlaw}
else:
return self.DIST_SIB % {'step': step, 'inlaw': inlaw}
def get_sibling_type(self, db, orig, other): def get_sibling_type(self, db, orig, other):
""" Translation free determination of type of orig and other as siblings """ Translation free determination of type of orig and other as siblings
@@ -379,29 +552,6 @@ class RelationshipCalculator:
break break
return (birthmother, birthfather) return (birthmother, birthfather)
def get_nephew(self, level, step='', inlaw=''):
if level>len(_nephew_level)-1:
return "distant %snephew%s" % (step, inlaw)
else:
return _nephew_level[level] % (step, inlaw)
def get_niece(self, level, step='', inlaw=''):
if level>len(_niece_level)-1:
return "distant %sniece%s" % (step, inlaw)
else:
return _niece_level[level] % (step, inlaw)
def get_cousin(self, level, removed, dir = '', step='', inlaw=''):
if removed == 0 and level < len(_level_name):
return "%s %scousin%s" % (_level_name[level],
step, inlaw)
elif removed > len(_removed_level)-1 or level>len(_level_name)-1:
return "distant %srelative%s" % (step, inlaw)
else:
return "%s %scousin%s%s%s" % (_level_name[level],
step, inlaw,
_removed_level[removed], dir)
def get_spouse_type(self, db, orig, other, all_rel = False): def get_spouse_type(self, db, orig, other, all_rel = False):
""" Translation free determination if orig and other are partners. """ Translation free determination if orig and other are partners.
The procedure returns partner types, these can be passed to The procedure returns partner types, these can be passed to
@@ -464,59 +614,9 @@ class RelationshipCalculator:
else: else:
return None return None
def get_relationship_distance_old(self, db, orig_person, other_person): def __apply_filter_old(self, db, person, rel_str, plist, pmap, depth=1):
""" DEPRECATED -- DO NOT USE
""" """
** DEPRECATED -- USE NEW **
NOTE: CHANGED ORDER OF RETURN, now first is rel to orig, second to other
(as it should, but wasn't !! )
Returns a tuple (firstRel, secondRel, common):
firstRel Number of generations from the orig_person to their
closest common ancestors, as eg 'ffmm'
secondRel Number of generations from the other_person to that
firstRel closest common ancestors, as eg 'ffmm'
common list of all these common ancestors (so same generation
difference with firstRel), no specific order !!
in the Rel, f is father, m is mother
"""
print "get_relationship_distance_old is deprecated, use new instead!"
firstRel = -1
secondRel = -1
common = []
firstMap = {}
firstList = []
secondMap = {}
secondList = []
rank = 9999999
try:
self.__apply_filter(db, orig_person, '', firstList, firstMap)
self.__apply_filter(db, other_person, '', secondList, secondMap)
except RuntimeError:
return (firstRel, secondRel, _("Relationship loop detected"))
for person_handle in firstList:
if person_handle in secondList:
new_rank = len(firstMap[person_handle])
if new_rank < rank:
rank = new_rank
common = [ person_handle ]
elif new_rank == rank:
common.append(person_handle)
if common:
person_handle = common[0]
firstRel = firstMap[person_handle]
secondRel = secondMap[person_handle]
return (firstRel,secondRel,common)
def __apply_filter(self, db, person, rel_str, plist, pmap, depth=1):
if person == None or depth > MAX_DEPTH: if person == None or depth > MAX_DEPTH:
return return
depth += 1 depth += 1
@@ -530,12 +630,12 @@ class RelationshipCalculator:
fhandle = family.father_handle fhandle = family.father_handle
if fhandle: if fhandle:
father = db.get_person_from_handle(fhandle) father = db.get_person_from_handle(fhandle)
self.__apply_filter(db, father, rel_str+'f', plist, pmap, self.__apply_filter_old(db, father, rel_str+'f', plist, pmap,
depth) depth)
mhandle = family.mother_handle mhandle = family.mother_handle
if mhandle: if mhandle:
mother = db.get_person_from_handle(mhandle) mother = db.get_person_from_handle(mhandle)
self.__apply_filter(db, mother, rel_str+'m', plist, pmap, self.__apply_filter_old(db, mother, rel_str+'m', plist, pmap,
depth) depth)
except: except:
return return
@@ -671,8 +771,8 @@ class RelationshipCalculator:
rank = 9999999 rank = 9999999
try: try:
self.__apply_filter_new(db, orig_person, '', [], firstMap) self.__apply_filter(db, orig_person, '', [], firstMap)
self.__apply_filter_new(db, other_person, '', [], secondMap, self.__apply_filter(db, other_person, '', [], secondMap,
stoprecursemap = firstMap, stoprecursemap = firstMap,
store_all=False) store_all=False)
## print firstMap ## print firstMap
@@ -755,7 +855,7 @@ class RelationshipCalculator:
else : else :
return [(-1,None,'',[],'',[])], self.__msg return [(-1,None,'',[],'',[])], self.__msg
def __apply_filter_new(self, db, person, rel_str, rel_fam, pmap, def __apply_filter(self, db, person, rel_str, rel_fam, pmap,
depth=1, stoprecursemap=None, store_all=True): depth=1, stoprecursemap=None, store_all=True):
'''We recursively add parents of person in pmap with correct rel_str, '''We recursively add parents of person in pmap with correct rel_str,
if store_all. If store_all false, only store parents if in the if store_all. If store_all false, only store parents if in the
@@ -877,7 +977,7 @@ class RelationshipCalculator:
for handle in parentstodo.keys(): for handle in parentstodo.keys():
data = parentstodo[handle] data = parentstodo[handle]
self.__apply_filter_new(db, data[0], self.__apply_filter(db, data[0],
data[1], data[2], data[1], data[2],
pmap, depth, stoprecursemap, store_all) pmap, depth, stoprecursemap, store_all)
@@ -1021,33 +1121,50 @@ class RelationshipCalculator:
self.REL_FATHER_NOTBIRTH, self.REL_MOTHER_NOTBIRTH]) self.REL_FATHER_NOTBIRTH, self.REL_MOTHER_NOTBIRTH])
return only_birth return only_birth
def get_one_relationship(self, db, orig_person, other_person): def get_one_relationship(self, db, orig_person, other_person,
extra_info=False):
""" """
returns a string representing the most relevant relationship between returns a string representing the most relevant relationship between
the two people the two people. If extra_info = True, extra information is returned:
(relation_string, distance_common_orig, distance_common_other)
""" """
stop = False
if orig_person == None: if orig_person == None:
return _("undefined") rel_str = _("undefined")
stop = True
if orig_person.get_handle() == other_person.get_handle(): if not stop and orig_person.get_handle() == other_person.get_handle():
return '' rel_str = ''
stop = True
is_spouse = self.is_spouse(db, orig_person, other_person) if not stop:
if is_spouse: is_spouse = self.is_spouse(db, orig_person, other_person)
return is_spouse if is_spouse:
rel_str = is_spouse
stop = True
if stop:
if extra_info:
return (rel_str, -1, -1)
else:
return rel_str
data, msg = self.get_relationship_distance_new( data, msg = self.get_relationship_distance_new(
db, orig_person, other_person, db, orig_person, other_person,
all_dist=True, all_dist=True,
all_families=True, only_birth=False) all_families=True, only_birth=False)
if data[0][0] == -1: if data[0][0] == -1:
return '' if extra_info:
return ('', -1, -1)
else:
return ''
data = self.collapse_relations(data) data = self.collapse_relations(data)
#most relevant relationship is a birth family relation of lowest rank #most relevant relationship is a birth family relation of lowest rank
databest = [data[0]] databest = [data[0]]
rankbest = data[0][0] rankbest = data[0][0]
for rel in data : for rel in data :
#data is sorted on rank
if rel[0] == rankbest: if rel[0] == rankbest:
databest.append(rel) databest.append(rel)
rel = databest[0] rel = databest[0]
@@ -1056,12 +1173,13 @@ class RelationshipCalculator:
if len(databest) == 1: if len(databest) == 1:
birth = self.only_birth(rel[2]) and self.only_birth(rel[4]) birth = self.only_birth(rel[2]) and self.only_birth(rel[4])
if dist_orig == 1 and dist_other == 1: if dist_orig == 1 and dist_other == 1:
return self.get_sibling_relationship_string( rel_str = self.get_sibling_relationship_string(
self.get_sibling_type( self.get_sibling_type(
db, orig_person, other_person), db, orig_person, other_person),
orig_person.get_gender(), orig_person.get_gender(),
other_person.get_gender()) other_person.get_gender())
return self.get_single_relationship_string(dist_orig, else:
rel_str = self.get_single_relationship_string(dist_orig,
dist_other, dist_other,
orig_person.get_gender(), orig_person.get_gender(),
other_person.get_gender(), other_person.get_gender(),
@@ -1109,12 +1227,13 @@ class RelationshipCalculator:
dist_other= len(rel[4]) dist_other= len(rel[4])
birth = self.only_birth(rel[2]) and self.only_birth(rel[4]) birth = self.only_birth(rel[2]) and self.only_birth(rel[4])
if dist_orig == 1 and dist_other == 1: if dist_orig == 1 and dist_other == 1:
return self.get_sibling_relationship_string( rel_str = self.get_sibling_relationship_string(
self.get_sibling_type( self.get_sibling_type(
db, orig_person, other_person), db, orig_person, other_person),
orig_person.get_gender(), orig_person.get_gender(),
other_person.get_gender()) other_person.get_gender())
return self.get_single_relationship_string(dist_orig, else:
rel_str = self.get_single_relationship_string(dist_orig,
dist_other, dist_other,
orig_person.get_gender(), orig_person.get_gender(),
other_person.get_gender(), other_person.get_gender(),
@@ -1122,6 +1241,10 @@ class RelationshipCalculator:
only_birth=birth, only_birth=birth,
in_law_a=False, in_law_a=False,
in_law_b=False) in_law_b=False)
if extra_info:
return (rel_str, dist_orig, dist_other)
else:
return rel_str
def get_relationship(self, db, orig_person, other_person): def get_relationship(self, db, orig_person, other_person):
""" """
@@ -1170,33 +1293,17 @@ class RelationshipCalculator:
else: else:
return (rel_str, common) return (rel_str, common)
def get_grandparents_string(self,db,orig_person,other_person): def get_grandparents_string(self, db, orig_person, other_person):
""" """
returns a string representing the relationshp between the two people, returns a string representing the relationship between the two people
along with a list of common ancestors (typically father,mother) if the other_person is a grandparent in general terms and in plural
""" """
if orig_person == None: (rel_str, dist_orig, dist_other) = self.get_one_relationship(db,
return ("undefined",[]) orig_person, other_person,
extra_info = True)
if orig_person == other_person: if dist_other == 0:
return ('', []) return self.get_parents(dist_orig)
(firstRel,secondRel,common) = \
self.get_relationship_distance(db,orig_person,other_person)
if type(common) == types.StringType or \
type(common) == types.UnicodeType:
return (common,[])
elif common:
person_handle = common[0]
else:
return ("",[])
if len(firstRel) == 0:
if len(secondRel) == 0:
return ('',common)
else:
return (self.get_parents(len(secondRel)),common)
else: else:
return None return None
@@ -1374,59 +1481,59 @@ class RelationshipCalculator:
elif Gb == 1 and inlaw: elif Gb == 1 and inlaw:
#inlaw children only exist up to first level: #inlaw children only exist up to first level:
if gender_b == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
rel_str = self.get_son(Gb, step)+inlaw rel_str = self._get_son(Gb, step)+inlaw
elif gender_b == gen.lib.Person.FEMALE: elif gender_b == gen.lib.Person.FEMALE:
rel_str = self.get_daughter(Gb, step)+inlaw rel_str = self._get_daughter(Gb, step)+inlaw
else: else:
rel_str = self.get_child_unknown(Gb, step)+inlaw rel_str = self._get_child_unknown(Gb, step)+inlaw
elif gender_b == gen.lib.Person.MALE: elif gender_b == gen.lib.Person.MALE:
rel_str = self.get_son(Gb, step) rel_str = self._get_son(Gb, step)
elif gender_b == gen.lib.Person.FEMALE: elif gender_b == gen.lib.Person.FEMALE:
rel_str = self.get_daughter(Gb, step) rel_str = self._get_daughter(Gb, step)
else: else:
rel_str = self.get_child_unknown(Gb, step) rel_str = self._get_child_unknown(Gb, step)
elif Gb == 0: elif Gb == 0:
# b is parents/grand parent of a # b is parents/grand parent of a
if gender_b == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
rel_str = self.get_father(Ga, step, inlaw) rel_str = self._get_father(Ga, step, inlaw)
elif gender_b == gen.lib.Person.FEMALE: elif gender_b == gen.lib.Person.FEMALE:
rel_str = self.get_mother(Ga, step, inlaw) rel_str = self._get_mother(Ga, step, inlaw)
else: else:
rel_str = self.get_parent_unknown(Ga, step, inlaw) rel_str = self._get_parent_unknown(Ga, step, inlaw)
elif Gb == 1: elif Gb == 1:
# b is sibling/aunt/uncle of a # b is sibling/aunt/uncle of a
if gender_b == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
rel_str = self.get_uncle(Ga, step, inlaw) rel_str = self._get_uncle(Ga, step, inlaw)
elif gender_b == gen.lib.Person.FEMALE: elif gender_b == gen.lib.Person.FEMALE:
rel_str = self.get_aunt(Ga, step, inlaw) rel_str = self._get_aunt(Ga, step, inlaw)
else: else:
rel_str = self.get_sibling(Ga, step, inlaw) rel_str = self._get_sibling(Ga, step, inlaw)
elif Ga == 1: elif Ga == 1:
# b is niece/nephew of a # b is niece/nephew of a
if gender_b == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
rel_str = self.get_nephew(Gb-1, step, inlaw) rel_str = self._get_nephew(Gb-1, step, inlaw)
elif gender_b == gen.lib.Person.FEMALE: elif gender_b == gen.lib.Person.FEMALE:
rel_str = self.get_niece(Gb-1, step, inlaw) rel_str = self._get_niece(Gb-1, step, inlaw)
elif Gb < len(_niece_level) and Gb < len(_nephew_level): elif Gb < len(_niece_level) and Gb < len(_nephew_level):
rel_str = "%s or %s" % (self.get_nephew(Gb-1, step, inlaw), rel_str = "%s or %s" % (self._get_nephew(Gb-1, step, inlaw),
self.get_niece(Gb-1, step, inlaw)) self._get_niece(Gb-1, step, inlaw))
else: else:
rel_str = "distant %snephews/nieces%s" % (step, inlaw) rel_str = "distant %snephews/nieces%s" % (step, inlaw)
elif Ga == Gb: elif Ga == Gb:
# a and b cousins in the same generation # a and b cousins in the same generation
rel_str = self.get_cousin(Ga-1, 0, dir = '', step=step, rel_str = self._get_cousin(Ga-1, 0, dir = '', step=step,
inlaw=inlaw) inlaw=inlaw)
elif Ga > Gb: elif Ga > Gb:
# These are cousins in different generations with the second person # These are cousins in different generations with the second person
# being in a higher generation from the common ancestor than the # being in a higher generation from the common ancestor than the
# first person. # first person.
rel_str = self.get_cousin(Gb-1, Ga-Gb, dir = ' (up)', rel_str = self._get_cousin(Gb-1, Ga-Gb, dir = ' (up)',
step=step, inlaw=inlaw) step=step, inlaw=inlaw)
elif Gb > Ga: elif Gb > Ga:
# These are cousins in different generations with the second person # These are cousins in different generations with the second person
# being in a lower generation from the common ancestor than the # being in a lower generation from the common ancestor than the
# first person. # first person.
rel_str = self.get_cousin(Ga-1, Gb-Ga, dir = ' (down)', rel_str = self._get_cousin(Ga-1, Gb-Ga, dir = ' (down)',
step=step, inlaw=inlaw) step=step, inlaw=inlaw)
return rel_str return rel_str
@@ -1454,11 +1561,11 @@ class RelationshipCalculator:
inlaw = '' inlaw = ''
if gender_b == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
rel_str = self.get_uncle(1, typestr, inlaw) rel_str = self._get_uncle(1, typestr, inlaw)
elif gender_b == gen.lib.Person.FEMALE: elif gender_b == gen.lib.Person.FEMALE:
rel_str = self.get_aunt(1, typestr, inlaw) rel_str = self._get_aunt(1, typestr, inlaw)
else: else:
rel_str = self.get_sibling(1, typestr, inlaw) rel_str = self._get_sibling(1, typestr, inlaw)
return rel_str return rel_str
def get_partner_relationship_string(self, spouse_type, gender_a, gender_b): def get_partner_relationship_string(self, spouse_type, gender_a, gender_b):
@@ -1830,7 +1937,7 @@ def _test(rc, onlybirth, inlawa, inlawb, printrelstr):
rel = (FMT + ' |info: male, Ga=%2d, Gb=%2d') % ( rel = (FMT + ' |info: male, Ga=%2d, Gb=%2d') % (
rc.get_single_relationship_string(j, i, rc.get_single_relationship_string(j, i,
gen.lib.Person.MALE, gen.lib.Person.MALE,
gen.lib.Person.FEMALE, gen.lib.Person.MALE,
relstra, relstrb, relstra, relstrb,
only_birth=onlybirth, only_birth=onlybirth,
in_law_a=inlawa, in_law_b=inlawb), j, i ) in_law_a=inlawa, in_law_b=inlawb), j, i )
@@ -1862,7 +1969,7 @@ def _test(rc, onlybirth, inlawa, inlawb, printrelstr):
rel = (FMT + ' |info: male, Ga=%2d, Gb=%2d') % ( rel = (FMT + ' |info: male, Ga=%2d, Gb=%2d') % (
rc.get_single_relationship_string(i, j, rc.get_single_relationship_string(i, j,
gen.lib.Person.MALE, gen.lib.Person.MALE,
gen.lib.Person.FEMALE, gen.lib.Person.MALE,
relstra, relstrb, relstra, relstrb,
only_birth=onlybirth, only_birth=onlybirth,
in_law_a=inlawa, in_law_b=inlawb), i, j) in_law_a=inlawa, in_law_b=inlawb), i, j)

10
src/plugins/Ancestors.py
View File

@@ -253,8 +253,9 @@ class ComprehensiveAncestorsReport (Report):
if self.gp: if self.gp:
break break
relstring = self.relationship.get_grandparents_string (self.start_person, relstring = self.relationship.get_grandparents_string(
self.database.get_person_from_handle(self.gp))[0] self.start_person,
self.database.get_person_from_handle(self.gp))
heading = _("%(name)s's maternal %(grandparents)s") % \ heading = _("%(name)s's maternal %(grandparents)s") % \
{ 'name': self.first_name_or_nick (self.start_person), { 'name': self.first_name_or_nick (self.start_person),
'grandparents': relstring } 'grandparents': relstring }
@@ -278,8 +279,9 @@ class ComprehensiveAncestorsReport (Report):
if paternal_known: if paternal_known:
self.doc.start_paragraph ("AR-Heading") self.doc.start_paragraph ("AR-Heading")
relstring = self.relationship.get_grandparents_string (self.start_person, relstring = self.relationship.get_grandparents_string(
self.database.get_person_from_handle(self.gp))[0] self.start_person,
self.database.get_person_from_handle(self.gp))
if thisgen == 2: if thisgen == 2:
heading = _("%(name)s's %(parents)s") % \ heading = _("%(name)s's %(parents)s") % \
{ 'name': self.first_name_or_nick (self.start_person), { 'name': self.first_name_or_nick (self.start_person),

144
src/plugins/all_relations.py
View File

@@ -60,6 +60,7 @@ class AllRelReport():
self.sdb = SimpleAccess(database) self.sdb = SimpleAccess(database)
self.sdoc = SimpleDoc(document) self.sdoc = SimpleDoc(document)
self.rel_class = relationship_class() self.rel_class = relationship_class()
self.msg_list = []
def run(self): def run(self):
#get home_person #get home_person
@@ -79,13 +80,13 @@ class AllRelReport():
return return
#check if not a family too: #check if not a family too:
is_spouse = self.rel_class.is_spouse(self.database, self.person, is_spouse = self.rel_class.is_spouse(self.database, self.home_person,
self.home_person) self.person)
if is_spouse: if is_spouse:
rel_string = is_spouse rel_string = is_spouse
rstr = _("%(person)s is the %(relationship)s of %(active_person)s." rstr = _("%(person)s is the %(relationship)s of %(active_person)s."
) % {'person' : p2, 'relationship' : rel_string, ) % {'person' : p1, 'relationship' : rel_string,
'active_person' : p1 } 'active_person' : p2 }
self.sdoc.paragraph(_FMT_VOID % (rstr)) self.sdoc.paragraph(_FMT_VOID % (rstr))
self.sdoc.paragraph("") self.sdoc.paragraph("")
@@ -107,13 +108,15 @@ class AllRelReport():
#collapse common so parents of same fam in common are one line #collapse common so parents of same fam in common are one line
commonnew = self.rel_class.collapse_relations(common) commonnew = self.rel_class.collapse_relations(common)
self.print_details(commonnew, self.home_person, self.person, self.print_details_header(commonnew, self.home_person, self.person,
first=True) skip_list_text=None)
self.print_details(commonnew, self.home_person, self.person, self.print_details_path(commonnew, self.home_person, self.person)
first=False) self.print_details_path(commonnew, self.home_person, self.person,
first=False)
if not common or common[0][0]== -1 : if not common or common[0][0]== -1 :
self.remarks(self.msg_list) self.remarks(self.msg_list)
self.msg_list = []
#check inlaw relation next #check inlaw relation next
else: else:
#stop #stop
@@ -128,19 +131,23 @@ class AllRelReport():
#remove overlap: #remove overlap:
inlaws_home = [x for x in inlaws_home if x not in inlaws_pers] inlaws_home = [x for x in inlaws_home if x not in inlaws_pers]
inlawwritten = False inlawwritten = False
skiplist = []
commonnew = []
for inlawpers in inlaws_pers: for inlawpers in inlaws_pers:
for inlawhome in inlaws_home: for inlawhome in inlaws_home:
if (inlawpers, inlawhome) in handles_done : if (inlawpers, inlawhome) in handles_done :
continue continue
else: else:
handles_done.append((inlawpers, inlawhome)) handles_done.append((inlawpers, inlawhome))
common, self.msg_list = \ common, msg = \
self.rel_class.get_relationship_distance_new( self.rel_class.get_relationship_distance_new(
self.database, inlawpers, inlawhome, self.database, inlawpers, inlawhome,
all_families=True, all_families=True,
all_dist=True, all_dist=True,
only_birth=False, only_birth=False,
max_depth=20) max_depth=20)
if msg:
self.msg_list.append(msg)
if common and not common[0][0] == -1: if common and not common[0][0] == -1:
if not inlawwritten: if not inlawwritten:
rstr = _("%(person)s and %(active_person)s have " rstr = _("%(person)s and %(active_person)s have "
@@ -152,13 +159,29 @@ class AllRelReport():
inlawwritten = True inlawwritten = True
else: else:
continue continue
commonnew = self.rel_class.collapse_relations(common)
inlawb = not inlawpers.handle == self.person.handle inlawb = not inlawpers.handle == self.person.handle
inlawa = not inlawhome.handle == self.home_person.handle inlawa = not inlawhome.handle == self.home_person.handle
self.print_details(commonnew, inlawhome, inlawpers, commonnew.append((inlawa, inlawb, inlawhome, inlawpers,
first=True, inlawa = inlawa, inlawb = inlawb) self.rel_class.collapse_relations(common)))
self.print_details(commonnew, inlawhome, inlawpers, skip=[]
first=False, inlawa = inlawa, inlawb = inlawb) skip_text = []
count = 1
for inlawa, inlawb, inlawhome, inlawpers, commonrel in commonnew:
count = self.print_details_header(commonrel,
inlawhome, inlawpers,
inlawa = inlawa, inlawb = inlawb,
count=count,
skip_list=skip, skip_list_text = skip_text)
count = 1
for inlawa, inlawb, inlawhome, inlawpers, commonrel in commonnew:
self.print_details_path(commonrel, inlawhome, inlawpers,
inlawa = inlawa, inlawb = inlawb,
count = count, skip_list = skip)
count = self.print_details_path(commonrel, inlawhome, inlawpers,
inlawa = inlawa, inlawb = inlawb,
count = count, skip_list = skip,
first = False)
self.remarks(self.msg_list)
def get_inlaws(self, person): def get_inlaws(self, person):
inlaws = [] inlaws = []
@@ -184,10 +207,50 @@ class AllRelReport():
self.sdoc.title(_("Relationships of %s to %s") % (p1 ,p2)) self.sdoc.title(_("Relationships of %s to %s") % (p1 ,p2))
self.sdoc.paragraph("") self.sdoc.paragraph("")
def print_details(self, relations, pers1, pers2, def print_details_header(self, relations, pers1, pers2,
inlawa=False, inlawb=False, first=True): inlawa=False, inlawb=False, count=1,
skip_list=[], skip_list_text = []):
if not relations or relations[0][0] == -1: if not relations or relations[0][0] == -1:
return return count
sdoc = self.sdoc
rel_class = self.rel_class
for relation in relations:
birth = self.rel_class.only_birth(relation[2])\
and self.rel_class.only_birth(relation[4])
distorig = len(relation[4])
distother = len(relation[2])
if distorig == 1 and distother == 1 and not inlawa \
and not inlawb:
rel_str = self.rel_class.get_sibling_relationship_string(
self.rel_class.get_sibling_type(
self.database, pers1, pers2),
self.home_person.get_gender(),
self.person.get_gender())
else:
rel_str = self.rel_class.get_single_relationship_string(
distorig, distother,
self.home_person.get_gender(),
self.person.get_gender(),
relation[4], relation[2],
only_birth = birth,
in_law_a = inlawa, in_law_b = inlawb)
if not skip_list_text is None:
if rel_str in skip_list_text:
skip_list.append(count)
else:
skip_list_text.append(rel_str)
sdoc.paragraph(_FMT % (count-len(skip_list), rel_str))
else :
sdoc.paragraph(_FMT % (count, rel_str))
count += 1
return count
def print_details_path(self, relations, pers1, pers2,
inlawa=False, inlawb=False,
count = 1, skip_list = [], first=True):
if not relations or relations[0][0] == -1:
return count
sdoc = self.sdoc sdoc = self.sdoc
rel_class = self.rel_class rel_class = self.rel_class
@@ -198,40 +261,18 @@ class AllRelReport():
if first: if first:
pers = p1 pers = p1
inlaw = inlawb inlaw = inlawb
count = 1
for relation in relations:
birth = self.rel_class.only_birth(relation[2])\
and self.rel_class.only_birth(relation[4])
distorig = len(relation[4])
distother = len(relation[2])
if distorig == 1 and distother == 1 and not inlawa \
and not inlawb:
rel_str = self.rel_class.get_sibling_relationship_string(
self.rel_class.get_sibling_type(
self.database, pers1, pers2),
self.home_person.get_gender(),
self.person.get_gender())
else:
rel_str = self.rel_class.get_single_relationship_string(
distorig, distother,
self.home_person.get_gender(),
self.person.get_gender(),
relation[4], relation[2],
only_birth = birth,
in_law_a = inlawa, in_law_b = inlawb)
sdoc.paragraph(_FMT % (count, rel_str))
count += 1
self.remarks(self.msg_list)
sdoc.paragraph("") if count == 1:
sdoc.header1(_("Detailed path from %(person)s to common ancestor" sdoc.paragraph("")
) % {'person':pers}) sdoc.header1(_("Detailed path from %(person)s to common ancestor"
sdoc.paragraph("") ) % {'person':pers})
sdoc.header2(_FMT_DET1 % (_(' '), _('Name Common ancestor'))) sdoc.paragraph("")
sdoc.header2(_FMT_DET2 % (' ', _('Parent'), _('Birth'), _('Family'))) sdoc.header2(_FMT_DET1 % (_(' '), _('Name Common ancestor')))
sdoc.paragraph("") sdoc.header2(_FMT_DET2 % (' ', _('Parent'), _('Birth'), _('Family')))
count = 1 sdoc.paragraph("")
for relation in relations: for relation in relations:
if count in skip_list:
continue
counter = str(count) counter = str(count)
name = _('Unknown') name = _('Unknown')
if relation[1]: if relation[1]:
@@ -281,7 +322,8 @@ class AllRelReport():
counter='' counter=''
name = '' name = ''
count += 1 count += 1
return count
def remarks(self, msg_list): def remarks(self, msg_list):
if msg_list : if msg_list :
sdoc = self.sdoc sdoc = self.sdoc

4
src/plugins/rel_it.py
View File

@@ -211,8 +211,8 @@ register_relcalc(RelationshipCalculator,
if __name__ == "__main__": if __name__ == "__main__":
# Test function. Call it as follows from the command line (so as to find # Test function. Call it as follows from the command line (so as to find
# imported modules): # imported modules):
# export PYTHONPATH=/path/to/gramps/src python src/gen/lib/date.py # export PYTHONPATH=/path/to/gramps/src
# (Above not needed here) # python src/plugins/rel_it.py
"""TRANSLATORS, copy this if statement at the bottom of your """TRANSLATORS, copy this if statement at the bottom of your
rel_xx.py module, and test your work with: rel_xx.py module, and test your work with:

547
src/plugins/rel_nl.py
View File

@@ -103,109 +103,153 @@ _parents_level = [ "",
"edelstamoudouders" ] "edelstamoudouders" ]
_father_level = [ "", _father_level = [ "",
"vader", "%s%svader",
"grootvader", "%s%sgrootvader",
"overgrootvader", "%s%sovergrootvader",
"betovergrootvader", "%s%sbetovergrootvader",
"oudvader (generatie 5)", "%s%soudvader (generatie 5)",
"oudgrootvader (generatie 6)", "%s%soudgrootvader (generatie 6)",
"oudovergrootvader (generatie 7)", "%s%soudovergrootvader (generatie 7)",
"oudbetovergrootvader (generatie 8)", "%s%soudbetovergrootvader (generatie 8)",
"stamvader (generatie 9)", "%s%sstamvader (generatie 9)",
"stamgrootvader (generatie 10)", "%s%sstamgrootvader (generatie 10)",
"stamovergrootvader (generatie 11)", "%s%sstamovergrootvader (generatie 11)",
"stambetovergrootvader (generatie 12)", "%s%sstambetovergrootvader (generatie 12)",
"stamoudvader (generatie 13)", "%s%sstamoudvader (generatie 13)",
"stamoudgrootvader (generatie 14)", "%s%sstamoudgrootvader (generatie 14)",
"stamoudovergrootvader (generatie 15)", "%s%sstamoudovergrootvader (generatie 15)",
"stamoudbetovergrootvader (generatie 16)", "%s%sstamoudbetovergrootvader (generatie 16)",
"edelvader (generatie 17)", "%s%sedelvader (generatie 17)",
"edelgrootvader (generatie 18)", "%s%sedelgrootvader (generatie 18)",
"edelovergrootoudvader (generatie 19)", "%s%sedelovergrootoudvader (generatie 19)",
"edelbetovergrootvader (generatie 20)", "%s%sedelbetovergrootvader (generatie 20)",
"edeloudvader (generatie 21)", "%s%sedeloudvader (generatie 21)",
"edeloudgrootvader (generatie 22)", "%s%sedeloudgrootvader (generatie 22)",
"edeloudvergrootvader (generatie 23)", "%s%sedeloudvergrootvader (generatie 23)",
"edeloudbetovergrootvader (generatie 24)", "%s%sedeloudbetovergrootvader (generatie 24)",
"edelstamvader (generatie 25)", "%s%sedelstamvader (generatie 25)",
"edelstamgrootvader (generatie 26)", "%s%sedelstamgrootvader (generatie 26)",
"edelstamovergrootvader (generatie 27)", "%s%sedelstamovergrootvader (generatie 27)",
"edelstambetovergrootvader (generatie 28)", "%s%sedelstambetovergrootvader (generatie 28)",
"edelstamoudvader (generatie 29)" ] "%s%sedelstamoudvader (generatie 29)" ]
_mother_level = [ "", _mother_level = [ "",
"moeder ", "%s%smoeder",
"grootmoeder", "%s%sgrootmoeder",
"overgrootmoeder", "%s%sovergrootmoeder",
"betovergrootmoeder", "%s%sbetovergrootmoeder",
"oudmoeder (generatie 5)", "%s%soudmoeder (generatie 5)",
"oudgrootmoeder (generatie 6)", "%s%soudgrootmoeder (generatie 6)",
"oudovergrootmoeder (generatie 7)", "%s%soudovergrootmoeder (generatie 7)",
"oudbetovergrootmoeder (generatie 8)", "%s%soudbetovergrootmoeder (generatie 8)",
"stammoeder (generatie 9)", "%s%sstammoeder (generatie 9)",
"stamgrootmoeder (generatie 10)", "%s%sstamgrootmoeder (generatie 10)",
"stamovergrootmoeder (generatie 11)", "%s%sstamovergrootmoeder (generatie 11)",
"stambetovergrootmoeder (generatie 12)", "%s%sstambetovergrootmoeder (generatie 12)",
"stamoudmoeder (generatie 13)", "%s%sstamoudmoeder (generatie 13)",
"stamoudgrootmoeder (generatie 14)", "%s%sstamoudgrootmoeder (generatie 14)",
"stamoudovergrootmoeder (generatie 15)", "%s%sstamoudovergrootmoeder (generatie 15)",
"stamoudbetovergrootmoeder (generatie 16)", "%s%sstamoudbetovergrootmoeder (generatie 16)",
"edelmoeder (generatie 17)", "%s%sedelmoeder (generatie 17)",
"edelgrootmoeder (generatie 18)", "%s%sedelgrootmoeder (generatie 18)",
"edelovergrootoudmoeder (generatie 19)", "%s%sedelovergrootoudmoeder (generatie 19)",
"edelbetovergrootmoeder (generatie 20)", "%s%sedelbetovergrootmoeder (generatie 20)",
"edeloudmoeder (generatie 21)", "%s%sedeloudmoeder (generatie 21)",
"edeloudgrootmoeder (generatie 22)", "%s%sedeloudgrootmoeder (generatie 22)",
"edeloudvergrootmoeder (generatie 23)", "%s%sedeloudvergrootmoeder (generatie 23)",
"edeloudbetovergrootmoeder (generatie 24)", "%s%sedeloudbetovergrootmoeder (generatie 24)",
"edelstammoeder (generatie 25)", "%s%sedelstammoeder (generatie 25)",
"edelstamgrootmoeder (generatie 26)", "%s%sedelstamgrootmoeder (generatie 26)",
"edelstamovergrootmoeder (generatie 27)", "%s%sedelstamovergrootmoeder (generatie 27)",
"edelstambetovergrootmoeder (generatie 28)", "%s%sedelstambetovergrootmoeder (generatie 28)",
"edelstamoudmoeder (generatie 29)" ] "%s%sedelstamoudmoeder (generatie 29)" ]
_ouder_level = [ "",
"%s%souder ",
"%s%sgrootouder",
"%s%sovergrootouder",
"%s%sbetovergrootouder",
"%s%soudouder (generatie 5)",
"%s%soudgrootouder (generatie 6)",
"%s%soudovergrootouder (generatie 7)",
"%s%soudbetovergrootouder (generatie 8)",
"%s%sstamouder (generatie 9)",
"%s%sstamgrootouder (generatie 10)",
"%s%sstamovergrootouder (generatie 11)",
"%s%sstambetovergrootouder (generatie 12)",
"%s%sstamoudouder (generatie 13)",
"%s%sstamoudgrootouder (generatie 14)",
"%s%sstamoudovergrootouder (generatie 15)",
"%s%sstamoudbetovergrootouder (generatie 16)",
"%s%sedelouder (generatie 17)",
"%s%sedelgrootouder (generatie 18)",
"%s%sedelovergrootoudouder (generatie 19)",
"%s%sedelbetovergrootouder (generatie 20)",
"%s%sedeloudouder (generatie 21)",
"%s%sedeloudgrootouder (generatie 22)",
"%s%sedeloudvergrootouder (generatie 23)",
"%s%sedeloudbetovergrootouder (generatie 24)",
"%s%sedelstamouder (generatie 25)",
"%s%sedelstamgrootouder (generatie 26)",
"%s%sedelstamovergrootouder (generatie 27)",
"%s%sedelstambetovergrootouder (generatie 28)",
"%s%sedelstamoudouder (generatie 29)" ]
_son_level = [ "", _son_level = [ "",
"zoon", "%szoon",
"kleinzoon", "%skleinzoon",
"achterkleinzoon", "%sachterkleinzoon",
"achterachterkleinzoon", "%sachterachterkleinzoon",
"achterachterachterkleinzoon"] "%sachterachterachterkleinzoon"]
_daughter_level = [ "", _daughter_level = [ "",
"dochter", "%sdochter",
"kleindochter", "%skleindochter",
"achterkleindochter", "%sachterkleindochter",
"achterachterkleindochter", "%sachterachterkleindochter",
"achterachterachterkleindochter"] "%sachterachterachterkleindochter"]
_kind_level = [ "",
"%skind",
"%skleinkind",
"%sachterkleinkind",
"%sachterachterkleinkind",
"%sachterachterachterkleinkind"]
_nephew_level = [ "", _nephew_level = [ "",
"neef", "%s%sneef",
"achterneef", "%s%sachterneef",
"achterachterneef" ] "%s%sachterachterneef" ]
_niece_level = [ "", _niece_level = [ "",
"nicht", "%s%snicht",
"achternicht", "%s%sachternicht",
"achterachternicht"] "%s%sachterachternicht"]
_aunt_level = [ "", _aunt_level = [ "",
"tante", "%s%stante",
"groottante", "%s%sgroottante",
"overgroottante", "%s%sovergroottante",
"betovergroottante", "%s%sbetovergroottante",
"oudtante (generatie 5)"] "%s%soudtante"]
_uncle_level = [ "", _uncle_level = [ "",
"oom", "%s%soom",
"grootoom", "%s%sgrootoom",
"overgrootoom", "%s%sovergrootoom",
"betovergrootoom", "%s%sbetovergrootoom",
"oudoom (generatie 5)"] "%s%soudoom"]
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# #
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class RelationshipCalculator(Relationship.RelationshipCalculator): class RelationshipCalculator(Relationship.RelationshipCalculator):
#sibling strings
STEP= 'stief'
HALF = 'half'
INLAW='aangetrouwde '
def __init__(self): def __init__(self):
Relationship.RelationshipCalculator.__init__(self) Relationship.RelationshipCalculator.__init__(self)
@@ -214,168 +258,283 @@ class RelationshipCalculator(Relationship.RelationshipCalculator):
if level > len(_parents_level)-1: if level > len(_parents_level)-1:
return "verre voorouders (%d generaties)" % level return "verre voorouders (%d generaties)" % level
else: else:
return _parents_level[level] return _parents_level[level]
def get_father(self, level):
def _get_father(self, level, step='', inlaw=''):
"""Internal Dutch method to create relation string
"""
if level > len(_father_level)-1: if level > len(_father_level)-1:
return "verre voorvader (%d generaties)" % level return "verre %s%svoorvader (%d generaties)" % (inlaw, step, level)
else: else:
return _father_level[level] return _father_level[level] % (inlaw, step)
def get_son(self, level): def _get_son(self, level, step=''):
"""Internal Dutch method to create relation string
"""
if level < len(_son_level): if level < len(_son_level):
return _son_level[level] return _son_level[level] % step
else: else:
return "verre achterkleinzoon (%d generaties)" % level return "verre %sachterkleinzoon (%d generaties)" % (step, level)
def get_mother(self,level): def _get_mother(self,level, step='', inlaw=''):
"""Internal Dutch method to create relation string
"""
if level > len(_mother_level)-1: if level > len(_mother_level)-1:
return "verre voormoeder (%d generaties)" % level return "verre voormoeder (%d generaties)" % (inlaw, step, level)
else: else:
return _mother_level[level] return _mother_level[level] % (inlaw, step)
def get_daughter(self, level): def _get_daughter(self, level, step=''):
"""Internal Dutch method to create relation string
"""
if level > len(_daughter_level)-1: if level > len(_daughter_level)-1:
return "verre achterkleindochter (%d generaties)" % level return "verre %sachterkleindochter (%d generaties)" % (step, level)
else: else:
return _daughter_level[level] return _daughter_level[level] % step
def get_aunt(self, level, removed): def _get_parent_unknown(self, level, step='', inlaw=''):
"""Internal Dutch method to create relation string
"""
if level > len(_ouder_level)-1:
return "verre voorouder (%d generaties)" % (inlaw, step, level)
elif level == 1:
return _mother_level[level] % (inlaw, step) + ' of ' + \
_father_level[level] % (inlaw, step)
else:
return _ouder_level[level] % (inlaw, step)
def _get_child_unknown(self, level, step=''):
"""Internal Dutch method to create relation string
"""
if level > len(_kind_level)-1:
return "ver %sachterkleinkind (%d generaties)" % (step, level)
else:
return _kind_level[level] % step
def _get_aunt(self, level, removed, step='', inlaw=''):
"""Internal Dutch method to create relation string
"""
if removed == 1 and level < len(_aunt_level): if removed == 1 and level < len(_aunt_level):
return _aunt_level[level] return _aunt_level[level] % (inlaw, step)
elif level > len(_aunt_level)-1 or removed > len(_removed_level) -1: elif removed == 1:
return "verre tante (%d generaties, %d graden)" % (level, removed) return "verre %s%stante (%d generaties)" % (inlaw, step, level)
elif level > len(_aunt_level)-1 and removed > len(_removed_level) -1:
return "verre %s%stante (%d generaties, %d graden)" % (inlaw, step,
level, removed)
elif level > len(_aunt_level)-1: elif level > len(_aunt_level)-1:
return "verre tante van de%s graad (%d generaties)" \ return "verre %s%stante van de%s graad (%d generaties)" % (inlaw,
% (_removed_level[removed], level) step, _removed_level[removed], level)
else: else:
return _aunt_level[level] + _removed_level[removed] + " graad" return _aunt_level[level] % (inlaw, step) \
+ _removed_level[removed] + " graad"
def get_uncle(self, level, removed): def _get_uncle(self, level, removed, step='', inlaw=''):
"""Internal Dutch method to create relation string
"""
if removed == 1 and level < len(_uncle_level): if removed == 1 and level < len(_uncle_level):
return _uncle_level[level] return _uncle_level[level] % (inlaw, step)
elif level > len(_uncle_level)-1 or removed > len(_removed_level) -1: elif removed == 1:
return "verre oom (%d generaties, %d graden)" % (level, removed) return "verre %s%soom (%d generaties)" % (inlaw, step, level)
elif level > len(_uncle_level)-1 and removed > len(_removed_level) -1:
return "verre %s%soom (%d generaties, %d graden)" % (inlaw, step,
level, removed)
elif level > len(_uncle_level)-1: elif level > len(_uncle_level)-1:
return "verre oom van de%s graad (%d generaties)" \ return "verre %s%soom van de%s graad (%d generaties)" % (inlaw,
% (_removed_level[removed], level) step, _removed_level[removed], level)
else: else:
return _uncle_level[level] + _removed_level[removed] + " graad" return _uncle_level[level] % (inlaw, step) \
+ _removed_level[removed] + " graad"
def get_nephew(self, level, removed=1): def _get_sibling(self, level, step='', inlaw=''):
"""overwrite of English method to return unknown gender sibling
"""
assert(level == 1)
return self._get_male_cousin(0, step=step, inlaw=inlaw) + ' of ' \
+ self._get_female_cousin(0, step=step, inlaw=inlaw)
def _get_nephew(self, level, removed=1, step='', inlaw=''):
"""Internal Dutch method to create relation string
"""
if removed == 1 and level < len(_nephew_level): if removed == 1 and level < len(_nephew_level):
return _nephew_level[level] return _nephew_level[level] % (inlaw, step)
elif level > len(_nephew_level)-1 or removed > len(_removed_level) -1: elif removed == 1:
return "verre neef (%d generaties, %d graden)" % (level, removed) return "verre %s%sneef (%d generaties)" % (inlaw, step, level)
elif level > len(_nephew_level)-1 and removed > len(_removed_level) -1:
return "verre %s%sneef (%d generaties, %d graden)" % (inlaw, step,
level, removed)
elif level > len(_nephew_level)-1: elif level > len(_nephew_level)-1:
return "verre neef van de%s graad (%d generaties)" \ return "verre %s%sneef van de%s graad (%d generaties)" % (inlaw, step,
% (_removed_level[removed], level) _removed_level[removed], level)
else: else:
return _nephew_level[level] + _removed_level[removed] + " graad" return _nephew_level[level] % (inlaw, step) \
+ _removed_level[removed] + " graad"
def get_niece(self, level, removed=1): def _get_niece(self, level, removed=1, step='', inlaw=''):
"""Internal Dutch method to create relation string
"""
if removed == 1 and level < len(_niece_level): if removed == 1 and level < len(_niece_level):
return _niece_level[level] return _niece_level[level] % (inlaw, step)
if level > len(_niece_level)-1 or removed > len(_removed_level) -1: elif removed == 1:
return "verre nicht (%d generaties, %d graden)" % (level, removed) return "verre %s%snicht (%d generaties)" % (inlaw, step, level)
elif level > len(_niece_level)-1 and removed > len(_removed_level) -1:
return "verre %s%snicht (%d generaties, %d graden)" % (inlaw, step,
level, removed)
elif level > len(_niece_level)-1: elif level > len(_niece_level)-1:
return "verre nicht van de%s graad (%d generaties)" \ return "verre %s%snicht van de%s graad (%d generaties)"% (inlaw,
% (_removed_level[removed], level) step, _removed_level[removed], level)
else: else:
return _niece_level[level] + _removed_level[removed] + " graad" return _niece_level[level] % (inlaw, step) \
+ _removed_level[removed] + " graad"
def get_male_cousin(self,removed): def _get_male_cousin(self, removed, step='', inlaw=''):
"""Specific Dutch thing, the nieces/nephews on same level are called """Specific Dutch thing, the nieces/nephews on same level are called
going sideways in a branch as the nieces/newphews going downward going sideways in a branch as the nieces/newphews going downward
from your brother/sisters. This used to be called "kozijn" from your brother/sisters. This used to be called "kozijn"
""" """
removed = removed - 1 removed = removed - 1
if removed > len(_removed_level)-1: if removed > len(_removed_level)-1:
return "verre neef (kozijn, %d graden)" % removed return "verre %s%sneef (kozijn, %d graden)" % (inlaw, step,
removed)
elif removed == 0: elif removed == 0:
return "broer" return "%s%sbroer" % (inlaw, step)
else: else:
return "neef (kozijn)"+_removed_level[removed] + " graad" return "%s%sneef (kozijn)" % (inlaw, step) \
+_removed_level[removed] + " graad"
def get_female_cousin(self,removed): def _get_female_cousin(self, removed, step='', inlaw=''):
"""Specific Dutch thing, the nieces/nephews on same level are called """Specific Dutch thing, the nieces/nephews on same level are called
going sideways in a branch as the nieces/newphews going downward going sideways in a branch as the nieces/newphews going downward
from your brother/sisters. This used to be called "kozijn" from your brother/sisters. This used to be called "kozijn"
""" """
removed = removed - 1 removed = removed - 1
if removed > len(_removed_level)-1: if removed > len(_removed_level)-1:
return "verre nicht (kozijn, %d graden)" % removed return "verre %s%snicht (kozijn, %d graden)" % (inlaw, step,
removed)
elif removed == 0: elif removed == 0:
return "zus" return "%s%szus" % (inlaw, step)
else: else:
return "nicht (kozijn)"+ _removed_level[removed] + " graad" return "%s%snicht (kozijn)" % (inlaw, step) \
+ _removed_level[removed] + " graad"
def get_relationship(self, db, orig_person, other_person): 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):
""" """
Returns a string representing the relationshp between the two people, Returns a string representing the relationship between the two people,
along with a list of common ancestors (typically father,mother) see english method, eg b is father of a
Special cases: relation strings "", "undefined" and "spouse".
""" """
if orig_person == None: if only_birth:
return ("niet bepaald",[]) step = ''
if orig_person.get_handle() == other_person.get_handle():
return ('', [])
is_spouse = self.is_spouse(db, orig_person, other_person)
if is_spouse:
return (is_spouse,[])
#get_relationship_distance changed, first data is relation to
#orig person, apperently secondRel in this function
(secondRel,firstRel,common) = self.get_relationship_distance(db,
orig_person,other_person)
if (type(common) == types.StringType or
type(common) == types.UnicodeType):
return (common,[])
elif common:
person_handle = common[0]
else: else:
return ("",[]) step = self.STEP
firstRel = len(firstRel) if in_law_a or in_law_b :
secondRel = len(secondRel) inlaw = self.INLAW
else:
inlaw = ''
if firstRel == 0: rel_str = "verre %s%sfamilie" % (inlaw, step)
#other person is ancestor
if secondRel == 0: if Gb == 0:
return ('',common) #b is ancestor
elif other_person.get_gender() == gen.lib.Person.MALE: if Ga == 0:
return (self.get_father(secondRel), common) rel_str = 'zelfde persoon'
elif Ga == 1 and inlaw and not step:
if gender_b == gen.lib.Person.MALE:
rel_str = 'schoonvader'
elif gender_b == gen.lib.Person.FEMALE:
rel_str = 'schoonmoeder'
else:
rel_str = 'schoonouder'
elif gender_b == gen.lib.Person.MALE:
rel_str = self._get_father(Ga, step, inlaw)
elif gender_b == gen.lib.Person.FEMALE:
rel_str = self._get_mother(Ga, step, inlaw)
else: else:
return (self.get_mother(secondRel), common) rel_str = self._get_parent_unknown(Ga, step, inlaw)
elif secondRel == 0: elif Ga == 0:
#other person is descendant #a is descendant
if other_person.get_gender() == gen.lib.Person.MALE: if Gb == 1 and inlaw and not step:
return (self.get_son(firstRel), common) #inlaw children only exist up to first level:
if gender_b == gen.lib.Person.MALE:
rel_str = 'schoonzoon'
elif gender_b == gen.lib.Person.FEMALE:
rel_str = 'schoondochter'
else:
rel_str = 'schoonzoon of -dochter'
elif Gb == 1 and inlaw and step:
#inlaw stepchild
if gender_b == gen.lib.Person.MALE:
rel_str = 'aangetrouwde stiefzoon'
elif gender_b == gen.lib.Person.FEMALE:
rel_str = 'aangetrouwde stiefdochter'
else:
rel_str = 'aangetrouwde stiefzoon of dochter'
elif gender_b == gen.lib.Person.MALE:
rel_str = self._get_son(Gb, step)
elif gender_b == gen.lib.Person.FEMALE:
rel_str = self._get_daughter(Gb, step)
else: else:
return (self.get_daughter(firstRel), common) rel_str = self._get_child_unknown(Gb, step)
elif secondRel > firstRel: elif Ga > Gb:
#other person is higher in the branch, in english uncle/aunt or #b is higher in the branch, in english uncle/aunt or
#cousin up, in dutch always 'oom/tante' #cousin up, in dutch always 'oom/tante'
if other_person.get_gender() == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
return (self.get_uncle(secondRel - firstRel,firstRel), common) rel_str = self._get_uncle(Ga - Gb, Gb, step, inlaw)
else: else:
return (self.get_aunt(secondRel - firstRel, firstRel), common) rel_str = self._get_aunt(Ga - Gb, Gb, step, inlaw)
elif secondRel < firstRel: elif Ga < Gb:
#other person is lower in the branch, in english niece/nephew or #b is lower in the branch, in english niece/nephew or
#cousin down, in dutch always 'neef/nicht' #cousin down, in dutch always 'neef/nicht'
if other_person.get_gender() == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
return (self.get_nephew(firstRel - secondRel, secondRel), common) rel_str = self._get_nephew(Gb - Ga, Ga, step, inlaw)
else: else:
return (self.get_niece(firstRel - secondRel, secondRel), common) rel_str = self._get_niece(Gb - Ga, Ga, step, inlaw)
else: else:
# people on the same level secondRel == firstRel # people on the same level Ga == Gb
if other_person.get_gender() == gen.lib.Person.MALE: if gender_b == gen.lib.Person.MALE:
return (self.get_male_cousin(firstRel), common) rel_str = self._get_male_cousin(Ga, step, inlaw)
else: else:
return (self.get_female_cousin(firstRel), common) rel_str = self._get_female_cousin(Ga, step, inlaw)
return rel_str
def get_sibling_relationship_string(self, sib_type, gender_a, gender_b,
in_law_a=False, in_law_b=False):
""" Determine the string giving the relation between two siblings of
type sib_type.
Eg: b is the brother of a
Here 'brother' is the string we need to determine
This method gives more details about siblings than
get_single_relationship_string can do.
DIFFERENT HELPER FUNCTIONS THAN ENGLISH
"""
if sib_type == self.NORM_SIB or sib_type == self.UNKNOWN_SIB:
typestr = ''
elif sib_type == self.HALF_SIB:
typestr = self.HALF
elif sib_type == self.STEP_SIB:
typestr = self.STEP
if in_law_a or in_law_b :
inlaw = self.INLAW
else:
inlaw = ''
if inlaw and not typestr:
if gender_b == gen.lib.Person.MALE:
rel_str = 'schoonbroer'
elif gender_b == gen.lib.Person.FEMALE:
rel_str = 'schoonzus'
else:
rel_str = 'schoonzus/broer'
else:
if gender_b == gen.lib.Person.MALE:
rel_str = self._get_male_cousin(1, typestr, inlaw)
else:
rel_str = self._get_female_cousin(1, typestr, inlaw)
return rel_str
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
@@ -387,3 +546,17 @@ register_relcalc(RelationshipCalculator,
"nl_BE.UTF8","nl_NL@euro", "nl_NL.UTF8@euro","nl_BE@euro", "nl_BE.UTF8","nl_NL@euro", "nl_NL.UTF8@euro","nl_BE@euro",
"dutch","Dutch", "nl_NL.UTF-8", "nl_BE.UTF-8","nl_NL.utf-8", "dutch","Dutch", "nl_NL.UTF-8", "nl_BE.UTF-8","nl_NL.utf-8",
"nl_BE.utf-8","nl_NL.utf8", "nl_BE.UTF-8", "nl_BE.UTF8@euro"]) "nl_BE.utf-8","nl_NL.utf8", "nl_BE.UTF-8", "nl_BE.UTF8@euro"])
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_nl.py
"""TRANSLATORS, copy this if statement at the bottom of your
rel_xx.py module, and test your work with:
python src/plugins/rel_xx.py
"""
from Relationship import test
rc = RelationshipCalculator()
test(rc, True)

4
src/plugins/rel_pl.py
View File

@@ -469,8 +469,8 @@ class RelationshipCalculator(Relationship.RelationshipCalculator):
rank = 9999999 rank = 9999999
try: try:
self.__apply_filter(db,orig_person,'',firstList,firstMap) self.__apply_filter_old(db,orig_person,'',firstList,firstMap)
self.__apply_filter(db,other_person,'',secondList,secondMap) self.__apply_filter_old(db,other_person,'',secondList,secondMap)
except RuntimeError: except RuntimeError:
return (firstRel,secondRel,_("Relationship loop detected")) return (firstRel,secondRel,_("Relationship loop detected"))