#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2003-2005  Donald N. Allingham
#
# 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:Relationship.py 9912 2008-01-22 09:17:46Z acraphae $

#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------

import gen.lib
from TransUtils import sgettext as _

    
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------

_level_name = [ "", "first", "second", "third", "fourth", "fifth", "sixth",
                "seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth",
                "thirteenth", "fourteenth", "fifteenth", "sixteenth",
                "seventeenth", "eighteenth", "nineteenth", "twentieth" ]

_removed_level = [ "", " once removed", " twice removed", 
                   " three times removed",
                   " four times removed", " five times removed", 
                    " six times removed",
                   " seven times removed", " eight times removed", 
                   " nine times removed",
                   " ten times removed", " eleven times removed", 
                   " twelve times removed",
                   " thirteen times removed", " fourteen times removed", 
                   " fifteen times removed",
                   " sixteen times removed", " seventeen times removed", 
                   " eighteen times removed",
                   " nineteen times removed", " twenty times removed" ]

_parents_level = [ "", "parents", "grandparents", "great grandparents",
                   "second great grandparents",
                  "third great grandparents",
                  "fourth great grandparents",
                  "fifth great grandparents",
                  "sixth great grandparents",
                  "seventh great grandparents",
                  "eighth great grandparents",
                  "ninth 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 = [ "", "%(step)sfather%(inlaw)s", "%(step)sgrandfather%(inlaw)s", 
                 "great %(step)sgrandfather%(inlaw)s", 
                  "second great %(step)sgrandfather%(inlaw)s",
                  "third great %(step)sgrandfather%(inlaw)s",
                  "fourth great %(step)sgrandfather%(inlaw)s",
                  "fifth great %(step)sgrandfather%(inlaw)s",
                  "sixth great %(step)sgrandfather%(inlaw)s",
                  "seventh great %(step)sgrandfather%(inlaw)s",
                  "eighth great %(step)sgrandfather%(inlaw)s",
                  "ninth great %(step)sgrandfather%(inlaw)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 = [ "", "%(step)smother%(inlaw)s", 
                  "%(step)sgrandmother%(inlaw)s",
                  "great %(step)sgrandmother%(inlaw)s", 
                  "second great %(step)sgrandmother%(inlaw)s",
                  "third great %(step)sgrandmother%(inlaw)s",
                  "fourth great %(step)sgrandmother%(inlaw)s",
                  "fifth great %(step)sgrandmother%(inlaw)s",
                  "sixth great %(step)sgrandmother%(inlaw)s",
                  "seventh great %(step)sgrandmother%(inlaw)s",
                  "eighth great %(step)sgrandmother%(inlaw)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 = [ "", "%(step)sson%(inlaw)s", "%(step)sgrandson%(inlaw)s", 
                "great %(step)sgrandson%(inlaw)s", 
                "second great %(step)sgrandson%(inlaw)s",
                "third great %(step)sgrandson%(inlaw)s",
                "fourth great %(step)sgrandson%(inlaw)s",
                "fifth great %(step)sgrandson%(inlaw)s",
                "sixth great %(step)sgrandson%(inlaw)s",
                "seventh great %(step)sgrandson%(inlaw)s", 
                "eighth great %(step)sgrandson%(inlaw)s",
                "ninth great %(step)sgrandson%(inlaw)s", 
                "tenth great %(step)sgrandson%(inlaw)s",
                "eleventh great %(step)sgrandson%(inlaw)s",
                "twelfth great %(step)sgrandson%(inlaw)s",
                "thirteenth great %(step)sgrandson%(inlaw)s", 
                "fourteenth great %(step)sgrandson%(inlaw)s",
                "fifteenth great %(step)sgrandson%(inlaw)s", 
                "sixteenth great %(step)sgrandson%(inlaw)s",
                "seventeenth great %(step)sgrandson%(inlaw)s", 
                "eighteenth great %(step)sgrandson%(inlaw)s",
                "nineteenth great %(step)sgrandson%(inlaw)s", 
                "twentieth great %(step)sgrandson%(inlaw)s", ]

_daughter_level = [ "", "%(step)sdaughter%(inlaw)s", "%(step)sgranddaughter%(inlaw)s",
                    "great %(step)sgranddaughter%(inlaw)s",
                    "second great %(step)sgranddaughter%(inlaw)s",
                    "third great %(step)sgranddaughter%(inlaw)s",  
                    "fourth great %(step)sgranddaughter%(inlaw)s",
                    "fifth great %(step)sgranddaughter%(inlaw)s",  
                    "sixth great %(step)sgranddaughter%(inlaw)s",
                    "seventh great %(step)sgranddaughter%(inlaw)s", 
                    "eighth great %(step)sgranddaughter%(inlaw)s",
                    "ninth great %(step)sgranddaughter%(inlaw)s",
                    "tenth great %(step)sgranddaughter%(inlaw)s",
                    "eleventh great %(step)sgranddaughter%(inlaw)s",
                    "twelfth great %(step)sgranddaughter%(inlaw)s",
                    "thirteenth great %(step)sgranddaughter%(inlaw)s", 
                    "fourteenth great %(step)sgranddaughter%(inlaw)s",
                    "fifteenth great %(step)sgranddaughter%(inlaw)s", 
                    "sixteenth great %(step)sgranddaughter%(inlaw)s",
                    "seventeenth great %(step)sgranddaughter%(inlaw)s", 
                    "eighteenth great %(step)sgranddaughter%(inlaw)s",
                    "nineteenth great %(step)sgranddaughter%(inlaw)s", 
                    "twentieth great %(step)sgranddaughter%(inlaw)s", ]

_sister_level = [ "", "%(step)ssister%(inlaw)s", "%(step)saunt%(inlaw)s",
                  "%(step)sgrandaunt%(inlaw)s", 
                  "great %(step)sgrandaunt%(inlaw)s",
                  "second great %(step)sgrandaunt%(inlaw)s",
                  "third great %(step)sgrandaunt%(inlaw)s",
                  "fourth great %(step)sgrandaunt%(inlaw)s",
                  "fifth great %(step)sgrandaunt%(inlaw)s",
                  "sixth great %(step)sgrandaunt%(inlaw)s",
                  "seventh great %(step)sgrandaunt%(inlaw)s",
                  "eighth great %(step)sgrandaunt%(inlaw)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 = [ "", "%(step)sbrother%(inlaw)s", "%(step)suncle%(inlaw)s",
                   "%(step)sgranduncle%(inlaw)s", 
                   "great %(step)sgranduncle%(inlaw)s",
                   "second great %(step)sgranduncle%(inlaw)s",
                   "third great %(step)sgranduncle%(inlaw)s",  
                   "fourth great %(step)sgranduncle%(inlaw)s",
                   "fifth great %(step)sgranduncle%(inlaw)s",  
                   "sixth great %(step)sgranduncle%(inlaw)s",
                   "seventh great %(step)sgranduncle%(inlaw)s", 
                   "eighth great %(step)sgranduncle%(inlaw)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 = [ "", "%(step)snephew%(inlaw)s", "%(step)sgrandnephew%(inlaw)s", 
                  "great %(step)sgrandnephew%(inlaw)s",
                  "second great %(step)sgrandnephew%(inlaw)s",
                  "third great %(step)sgrandnephew%(inlaw)s",  
                  "fourth great %(step)sgrandnephew%(inlaw)s",
                  "fifth great %(step)sgrandnephew%(inlaw)s", 
                  "sixth great %(step)sgrandnephew%(inlaw)s",
                  "seventh great %(step)sgrandnephew%(inlaw)s",
                  "eighth great %(step)sgrandnephew%(inlaw)s",
                  "ninth great %(step)sgrandnephew%(inlaw)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 = [ "", "%(step)sniece%(inlaw)s", "%(step)sgrandniece%(inlaw)s", 
                 "great %(step)sgrandniece%(inlaw)s", 
                 "second great %(step)sgrandniece%(inlaw)s",
                 "third great %(step)sgrandniece%(inlaw)s", 
                 "fourth great %(step)sgrandniece%(inlaw)s",
                 "fifth great %(step)sgrandniece%(inlaw)s", 
                 "sixth great %(step)sgrandniece%(inlaw)s",
                 "seventh great %(step)sgrandniece%(inlaw)s",
                 "eighth great %(step)sgrandniece%(inlaw)s",
                 "ninth great %(step)sgrandniece%(inlaw)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",                        "grandchildren", 
    "great grandchildren",             "second great grandchildren",
    "third great grandchildren",       "fourth great grandchildren",
    "fifth great grandchildren",       "sixth great grandchildren",
    "seventh great grandchildren",     "eighth great grandchildren",
    "ninth great grandchildren",       "tenth great grandchildren",
    "eleventh great grandchildren",    "twelfth great grandchildren",
    "thirteenth great grandchildren",  "fourteenth great grandchildren",
    "fifteenth great grandchildren",   "sixteenth great grandchildren",
    "seventeenth great grandchildren", "eighteenth great grandchildren",
     "nineteenth great grandchildren", "twentieth great grandchildren", ]

_siblings_level = [ "",
    "siblings",                           "uncles/aunts", 
    "granduncles/aunts",                  "great granduncles/aunts", 
    "second great granduncles/aunts",     "third great granduncles/aunts",  
    "fourth great granduncles/aunts",     "fifth great granduncles/aunts",  
    "sixth great granduncles/aunts",      "seventh great granduncles/aunts", 
    "eighth great granduncles/aunts",     "ninth great granduncles/aunts", 
    "tenth great granduncles/aunts",      "eleventh great granduncles/aunts",  
    "twelfth great granduncles/aunts",    "thirteenth great granduncles/aunts", 
    "fourteenth great granduncles/aunts", "fifteenth great granduncles/aunts", 
    "sixteenth great granduncles/aunts",  "seventeenth great granduncles/aunts", 
    "eighteenth great granduncles/aunts", "nineteenth great granduncles/aunts", 
    "twentieth great granduncles/aunts", ]
    
_sibling_level = [ "",
    "%(step)ssibling%(inlaw)s",                          
    "%(step)suncle/aunt%(inlaw)s", 
    "%(step)sgranduncle/aunt%(inlaw)s",                  
    "great %(step)sgranduncle/aunt%(inlaw)s", 
    "second great %(step)sgranduncle/aunt%(inlaw)s",     
    "third great %(step)sgranduncle/aunt%(inlaw)s",  
    "fourth great %(step)sgranduncle/aunt%(inlaw)s",     
    "fifth great %(step)sgranduncle/aunt%(inlaw)s",  
    "sixth great %(step)sgranduncle/aunt%(inlaw)s",      
    "seventh great %(step)sgranduncle/aunt%(inlaw)s", 
    "eighth great %(step)sgranduncle/aunt%(inlaw)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 = [   "", 
                            "siblings",
                            "nephews/nieces",
                            "grandnephews/nieces", 
                            "great grandnephews/nieces",
                            "second great grandnephews/nieces",
                            "third great grandnephews/nieces",
                            "fourth great grandnephews/nieces",
                            "fifth great grandnephews/nieces",
                            "sixth great grandnephews/nieces",
                            "seventh great grandnephews/nieces",
                            "eighth great grandnephews/nieces",
                            "ninth great grandnephews/nieces",
                            "tenth great grandnephews/nieces",
                            "eleventh great grandnephews/nieces",
                            "twelfth great grandnephews/nieces",
                            "thirteenth great grandnephews/nieces",
                            "fourteenth great grandnephews/nieces",
                            "fifteenth great grandnephews/nieces",
                            "sixteenth great grandnephews/nieces",
                            "seventeenth great grandnephews/nieces",
                            "eighteenth great grandnephews/nieces",
                            "nineteenth great grandnephews/nieces",
                            "twentieth great grandnephews/nieces",    ]


#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------


class RelationshipCalculator:
    
    REL_MOTHER           = 'm'      # going up to mother
    REL_FATHER           = 'f'      # going up to father
    REL_MOTHER_NOTBIRTH  = 'M'      # going up to mother, not birth relation
    REL_FATHER_NOTBIRTH  = 'F'      # going up to father, not birth relation
    REL_SIBLING          = 's'      # going sideways to sibling (no parents)
    REL_FAM_BIRTH        = 'a'      # going up to family (mother and father)
    REL_FAM_NONBIRTH     = 'A'      # going up to family, not birth relation
    REL_FAM_BIRTH_MOTH_ONLY = 'b'   # going up to fam, only birth rel to mother
    REL_FAM_BIRTH_FATH_ONLY = 'c'   # going up to fam, only birth rel to father
    
    REL_FAM_INLAW_PREFIX = 'L'      # going to the partner.
    
    #sibling types
    NORM_SIB = 0                    # same birth parents
    HALF_SIB_MOTHER = 1             # same mother, father known to be different
    HALF_SIB_FATHER = 2             # same father, mother known to be different
    STEP_SIB = 3                    # birth parents known to be different
    UNKNOWN_SIB  = 4                # insufficient data to draw conclusion
    
    #sibling strings
    STEP= 'step'
    HALF = 'half-'

    INLAW='-in-law'
        
    #partner types
    PARTNER_MARRIED        = 1
    PARTNER_UNMARRIED      = 2
    PARTNER_CIVIL_UNION    = 3
    PARTNER_UNKNOWN_REL    = 4
    PARTNER_EX_MARRIED     = 5
    PARTNER_EX_UNMARRIED   = 6
    PARTNER_EX_CIVIL_UNION = 7
    PARTNER_EX_UNKNOWN_REL = 8
    
    def __init__(self):
        self.signal_keys = []
        self.state_signal_key = None
        self.storemap = False
        self.dirtymap = True
        self.stored_map = None
        self.map_handle = None
        self.map_meta = None
        self.__db_connected = False
        self.depth = 15
        try:
            import Config
            self.set_depth(Config.get(Config.GENERATION_DEPTH))
        except ImportError:
            pass

    def set_depth(self, depth):
        """ set how deep relationships must be searched. Input must be an 
            integer > 0
        """
        if not depth == self.depth:
            self.depth = depth
            self.dirtymap = True

    def get_depth(self):
        """ obtain depth of relationship search
        """
        return self.depth
    

    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:
            return self.DIST_FATHER % {'step': step, 'inlaw': inlaw,
                                       'level': level}
        else:
            return _father_level[level] % {'step': step, 'inlaw': inlaw} 

    DIST_SON = "distant %(step)sdescendant%(inlaw)s (%(level)d generations)"
    
    def _get_son(self, level, step='', inlaw=''):
        """Internal english method to create relation string
        """
        if level>len(_son_level)-1:
            return self.DIST_SON % {'step': step, 'inlaw': inlaw,
                                    'level': level}
        else:
            return _son_level[level] % {'step': step, 'inlaw': 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:
            return self.DIST_MOTHER % {'step': step, 'inlaw': inlaw,
                                       'level': level}
        else:
            return _mother_level[level] % {'step': step, 'inlaw': inlaw} 

    DIST_DAUGHTER = "distant %(step)sdescendant%(inlaw)s (%(level)d generations)"

    def _get_daughter(self, level, step='', inlaw=''):
        """Internal english method to create relation string
        """
        if level>len(_daughter_level)-1:
            return self.DIST_DAUGHTER % {'step': step, 'inlaw': inlaw, 
                                         'level': level}
        else:
            return _daughter_level[level] % {'step': step, 'inlaw': inlaw}

    def _get_parent_unknown(self, level, step='', inlaw=''):
        """Internal english method to create relation string
        """
        if level < len(_level_name):
            return _level_name[level] + ' ' + '%sancestor%s' % (step, inlaw)
        else:
            return "distant %sancestor%s (%d generations)" % (step, inlaw, 
                                                              level)

    DIST_CHILD = "distant %(step)sdescendant (%(level)d generations)"

    def _get_child_unknown(self, level, step='', inlaw=''):
        """Internal english method to create relation string
        """
        if level < len(_level_name):
            return _level_name[level] + ' ' + '%(step)sdescendant%(inlaw)s' % {
                                                'step': step, 'inlaw': inlaw}
        else:
            return self.DIST_CHILD % {'step': step, 'level': level}

    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:
            return self.DIST_AUNT % {'step': step, 'inlaw': inlaw}
        else:
            return _sister_level[level] % {'step': step, 'inlaw': 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:
            return self.DIST_UNCLE % {'step': step, 'inlaw': inlaw}
        else:
            return _brother_level[level] % {'step': step, 'inlaw': inlaw} 

    DIST_NEPHEW = "distant %(step)snephew%(inlaw)s"

    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:
            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):
        """ Translation free determination of type of orig and other as siblings
            The procedure returns sibling types, these can be passed to 
            get_sibling_relationship_string.
            Only call this method if known that orig and other are siblings
        """
        fatherorig, motherorig = self._get_birth_parents(db, orig)
        fatherother, motherother = self._get_birth_parents(db, other)
        if fatherorig and motherorig and fatherother and motherother:
            if fatherother == fatherorig and motherother == motherorig:
                return self.NORM_SIB
            elif fatherother == fatherorig:
                #all birth parents are known, one
                return self.HALF_SIB_FATHER
            elif motherother == motherorig:
                return self.HALF_SIB_MOTHER
            else :
                return self.STEP_SIB
        else:
            # some birth parents are not known, hence we or cannot know if
            # half siblings. step siblings might be possible, otherwise give up
            orig_nb_par = self._get_nonbirth_parent_list(db, orig)
            if fatherother and fatherother in orig_nb_par:
                #the birth parent of other is non-birth of orig
                if motherother and motherother == motherorig:
                    return self.HALF_SIB_MOTHER
                else:
                    return self.STEP_SIB
            if motherother and motherother in orig_nb_par:
                #the birth parent of other is non-birth of orig
                if fatherother and fatherother == fatherorig:
                    return self.HALF_SIB_FATHER
                else:
                    return self.STEP_SIB
            other_nb_par = self._get_nonbirth_parent_list(db, other)
            if fatherorig and fatherorig in other_nb_par:
                #the one birth parent of other is non-birth of orig
                if motherorig and motherother == motherorig:
                    return self.HALF_SIB_MOTHER
                else:
                    return self.STEP_SIB
            if motherorig and motherorig in other_nb_par:
                #the one birth parent of other is non-birth of orig
                if fatherother and fatherother == fatherorig:
                    return self.HALF_SIB_FATHER
                else:
                    return self.STEP_SIB
            #there is an unknown birth parent, it could be that this is the
            # birth parent of the other person
            return self.UNKNOWN_SIB

    def get_parents(self, level):
        if level>len(_parents_level)-1:
            return "distant ancestors (%d generations)" % level
        else:
            return _parents_level[level]

    def _get_birth_parents(self, db, person):
        """ method that returns the birthparents of a person as tuple
            (mother handle, father handle), if no known birthparent, the 
            handle is replaced by None
        """
        birthfather = None
        birthmother = None
        for fam in person.get_parent_family_handle_list():
            family = db.get_family_from_handle(fam)
            childrel = [(ref.get_mother_relation(), 
                             ref.get_father_relation()) for ref in 
                                family.get_child_ref_list() 
                                if ref.ref == person.handle]
            if not birthmother and childrel[0][0] == gen.lib.ChildRefType.BIRTH:
                birthmother = family.get_mother_handle()
            if not birthfather and childrel[0][1] == gen.lib.ChildRefType.BIRTH:
                birthfather = family.get_father_handle()
            if birthmother and birthfather:
                break
        return (birthmother, birthfather)

    def _get_nonbirth_parent_list(self, db, person):
        """ returns a list of handles of parents of which it is known 
            they are not birth parents. 
            So all parents which do not have relation BIRTH or UNKNOWN
            are returned.
        """
        nb_parents = []
        for fam in person.get_parent_family_handle_list():
            family = db.get_family_from_handle(fam)
            childrel = [(ref.get_mother_relation(), 
                             ref.get_father_relation()) for ref in 
                                family.get_child_ref_list() 
                                if ref.ref == person.handle]
            if not childrel[0][0] == gen.lib.ChildRefType.BIRTH \
                    and not childrel[0][0] == gen.lib.ChildRefType.UNKNOWN :
                nb_parents.append(family.get_mother_handle())
            if not childrel[0][1] == gen.lib.ChildRefType.BIRTH \
                    and not childrel[0][1] == gen.lib.ChildRefType.UNKNOWN :
                nb_parents.append(family.get_father_handle())
        #make every person appear only once:
        return list(set(nb_parents))

    def get_spouse_type(self, db, orig, other, all_rel = False):
        """ Translation free determination if orig and other are partners.
            The procedure returns partner types, these can be passed to 
            get_partner_relationship_string.
            If all_rel=False, returns None or a partner type. 
            If all_rel=True, returns a list, empty if no partner
        """
        val = []
        for f in orig.get_family_handle_list():
            family = db.get_family_from_handle(f)
            # return first found spouse type
            if family and other.get_handle() in [family.get_father_handle(),
                                                 family.get_mother_handle()]:
                family_rel = family.get_relationship()
                #check for divorce event:
                ex = False
                for eventref in family.get_event_ref_list():
                    event = db.get_event_from_handle(eventref.ref)
                    if event and (event.get_type() == gen.lib.EventType.DIVORCE
                        or event.get_type() == gen.lib.EventType.ANNULMENT):
                        ex = True
                        break
                if family_rel == gen.lib.FamilyRelType.MARRIED:
                    if ex:
                        val.append(self.PARTNER_EX_MARRIED)
                    else:
                        val.append(self.PARTNER_MARRIED)
                elif family_rel == gen.lib.FamilyRelType.UNMARRIED:
                    if ex:
                        val.append(self.PARTNER_EX_UNMARRIED)
                    else:
                        val.append(self.PARTNER_UNMARRIED)
                elif family_rel == gen.lib.FamilyRelType.CIVIL_UNION:
                    if ex:
                        val.append(self.PARTNER_EX_CIVIL_UNION)
                    else:
                        val.append(self.PARTNER_CIVIL_UNION)
                else:
                    if ex:
                        val.append(self.PARTNER_EX_UNKNOWN_REL)
                    else:
                        val.append(self.PARTNER_UNKNOWN_REL)

        if all_rel :
            return val
        else:
            #last relation is normally the defenitive relation
            if val:
                return val[-1]
            else:
                return None
        
    def is_spouse(self, db, orig, other, all_rel=False):
        """ determine the spouse relation
        """
        type = self.get_spouse_type(db, orig, other, all_rel)
        if type:
            return self.get_partner_relationship_string(type, 
                        orig.get_gender(), other.get_gender())
        else:
            return None
        
    def get_relationship_distance_new(self, db, orig_person,
                                      other_person,
                                      all_families=False, 
                                      all_dist=False, 
                                      only_birth=True):
        """
        Return if all_dist == True a 'tuple, string':
            (rank, person handle, firstRel_str, firstRel_fam,
             secondRel_str, secondRel_fam), msg 
        or if all_dist == True a 'list of tuple, string': 
            [.....], msg:
            
        NOTE: _new can be removed once all rel_xx modules no longer overwrite
            get_relationship_distance
        
        The tuple or list of tuples consists of:
         
        *rank           Total number of generations from common ancestor to 
                        the two persons, rank is -1 if no relations found
        *person_handle  The Common ancestor
        *firstRel_str   String with the path to the common ancestor 
                        from orig Person
        *firstRel_fam   Family numbers along the path as a list, eg [0,0,1]. 
                        For parent in multiple families, eg [0. [0, 2], 1]
        *secondRel_str  String with the path to the common ancestor 
                        from otherPerson
        *secondRel_fam  Family numbers along the path, eg [0,0,1]. 
                        For parent in multiple families, eg [0. [0, 2], 1]
        *msg            List of messages indicating errors. Empyt list if no
                        errors.
                        
        Example:
                firstRel_str = 'ffm' and firstRel_fam = [2,0,1] means 
                common ancestor is mother of the second family of the 
                father of the first family of the father of the third 
                family.
        Note that the same person might be present twice if the person is
        reached via a different branch too. Path (firstRel_str and 
        secondRel_str) will of course be different
        
        @param db: database to work on
        @param orig_person: first person 
        @type orig_person:  Person Obj
        @param other_person: second person, relation is sought between
                             first and second person
        @type other_person:  Person Obj
        @param all_families: if False only Main family is searched, otherwise
                             all families are used
        @type all_families:  bool
        @param all_dist: if False only the shortest distance is returned, 
                         otherwise all relationships
        @type all_dist:  bool
        @param only_birth: if True only parents with birth relation are 
                           considered
        @type only_birth:  bool
        """
        #data storage to communicate with recursive functions
        self.__maxDepthReached = False
        self.__loopDetected = False
        self.__max_depth = self.get_depth()
        self.__all_families = all_families
        self.__all_dist = all_dist
        self.__only_birth = only_birth
        self.__crosslinks = False    # no crosslinks
        
        firstRel   = -1
        secondRel  = -1
        common_str = []
        common_fam = []
        self.__msg = []
        
        common = []
        firstMap = {}
        firstList = []
        secondMap = {}
        secondList = []
        rank = 9999999

        try:
            if (self.storemap and self.stored_map is not None 
                    and self.map_handle == orig_person.handle 
                    and not self.dirtymap): 
                firstMap = self.stored_map
                self.__maxDepthReached, self.__loopDetected, \
                 self.__all_families,\
                 self.__all_dist, self.__only_birth,\
                 self.__crosslinks, self.__msg = self.map_meta
                self.__msg = list(self.__msg)
            else:
                self.__apply_filter(db, orig_person, '', [], firstMap)
                self.map_meta = (self.__maxDepthReached,
                                 self.__loopDetected, 
                                 self.__all_families,
                                 self.__all_dist, self.__only_birth,
                                 self.__crosslinks, list(self.__msg))
            self.__apply_filter(db, other_person, '', [], secondMap,
                                    stoprecursemap = firstMap)
        except RuntimeError:
            return (-1,None,-1,[],-1,[] ) , \
                            [_("Relationship loop detected")] + self.__msg

        if self.storemap:
            self.stored_map = firstMap
            self.dirtymap = False
            self.map_handle = orig_person.handle
            
        for person_handle in secondMap.keys() :
            if firstMap.has_key(person_handle) :
                com = []
                #a common ancestor
                for rel1, fam1 in zip(firstMap[person_handle][0],
                                        firstMap[person_handle][1]):
                    l1 = len(rel1)
                    for rel2, fam2 in zip(secondMap[person_handle][0], 
                                        secondMap[person_handle][1]):
                        l2 = len(rel2)
                        #collect paths to arrive at common ancestor
                        com.append((l1+l2, person_handle, rel1, fam1,
                                                          rel2, fam2))
                #insert common ancestor in correct position,
                #  if shorter links, check if not subset
                #  if longer links, check if not superset
                pos=0
                for ranknew, handlenew,rel1new,fam1new,rel2new,fam2new in com :
                    insert = True
                    for rank, handle, rel1, fam1, rel2, fam2 in common :
                        if ranknew < rank : 
                            break
                        elif ranknew >= rank :
                            #check subset
                            if rel1 == rel1new[:len(rel1)] and \
                                    rel2 == rel2new[:len(rel2)] :
                                #subset relation exists already
                                insert = False
                                break
                        pos += 1
                    if insert :
                        if common :
                            common.insert(pos, (ranknew, handlenew,
                                    rel1new, fam1new,rel2new,fam2new))
                        else:
                            common = [(ranknew, handlenew,
                                    rel1new, fam1new, rel2new, fam2new)]
                        #now check if superset must be deleted from common
                        deletelist=[]
                        index = pos+1
                        for rank, handle,rel1,fam1,rel2,fam2 in common[pos+1:]:
                            if rel1new == rel1[:len(rel1new)] and \
                                    rel2new == rel2[:len(rel2new)] :
                                deletelist.append(index)
                            index += 1
                        deletelist.reverse()
                        for index in deletelist:
                            del common[index]  
        #check for extra messages
        if self.__maxDepthReached :
            self.__msg += [_('Family tree reaches back more than the maximum '
                        '%d generations searched.\nIt is possible that '
                        'relationships have been missed') % (self.__max_depth)]

        if common and not self.__all_dist :
            rank          = common[0][0]
            person_handle = common[0][1]
            firstRel      = common[0][2]
            firstFam      = common[0][3]
            secondRel     = common[0][4]
            secondFam     = common[0][5]
            return (rank,person_handle,firstRel,firstFam,secondRel,secondFam),\
                        self.__msg
        if common : 
            #list with tuples (rank, handle person,rel_str_orig,rel_fam_orig,
            #       rel_str_other,rel_fam_str) and messages
            return common, self.__msg
        if not self.__all_dist :
            return  (-1,None,'',[],'',[]), self.__msg
        else :
            return [(-1,None,'',[],'',[])], self.__msg
    
    def __apply_filter(self, db, person, rel_str, rel_fam, pmap,
                            depth=1, stoprecursemap=None):
        """Typically this method is called recursively in two ways:
            First method is stoprecursemap= None 
            In this case a recursemap is builded by storing all data.
            
            Second method is with a stoprecursemap given
            In this case parents are recursively looked up. If present in 
            stoprecursemap, a common ancestor is found, and the method can 
            stop looking further. If however self.__crosslinks == True, the data
            of first contains loops, and parents
            will be looked up anyway an stored if common. At end the doubles
            are filtered out
        """
        if person == None or not person.handle :
            return
        
        if depth > self.__max_depth:
            self.__maxDepthReached = True
            #print 'Maximum ancestor generations ('+str(depth)+') reached', \
            #            '(' + rel_str + ').',\
            #            'Stopping relation algorithm.'
            return
        depth += 1
        
        commonancestor = False
        store = True                            #normally we store all parents
        if stoprecursemap:
            store = False                       #but not if a stop map given
            if stoprecursemap.has_key(person.handle):
                commonancestor = True
                store = True

        #add person to the map, take into account that person can be obtained 
        #from different sides 
        if pmap.has_key(person.handle):
            #person is already a grandparent in another branch, we already have
            # had lookup of all parents, we call that a crosslink
            if not stoprecursemap:
                self.__crosslinks = True
            pmap[person.handle][0] += [rel_str]
            pmap[person.handle][1] += [rel_fam]
            #check if there is no loop father son of his son, ...
            # loop means person is twice reached, same rel_str in begin
            for rel1 in pmap[person.handle][0]: 
                for rel2 in pmap[person.handle][0] :
                    if len(rel1) < len(rel2) and \
                            rel1 == rel2[:len(rel1)]:
                        #loop, keep one message in storage!
                        self.__loopDetected = True
                        self.__msg += [_("Relationship loop detected:") + \
                            _("Person %s connects to himself via %s") % \
                                (person.get_primary_name().get_name(),
                                 rel2[len(rel1):])]
                        return
        elif store:
            pmap[person.handle] = [[rel_str],[rel_fam]]
            
        #having added person to the pmap, we only look up recursively to 
        # parents if this person is not common relative
        # if however the first map has crosslinks, we need to continue reduced
        if commonancestor and not self.__crosslinks :
            #don't continue search, great speedup!
            return 

        family_handles = []
        main = person.get_main_parents_family_handle()
        if main :
            family_handles = [main]
        if self.__all_families :
            family_handles = person.get_parent_family_handle_list() 
            
        try:
            parentstodo = {}
            fam = 0
            for family_handle in family_handles :
                rel_fam_new = rel_fam + [fam]
                family = db.get_family_from_handle(family_handle)
                #obtain childref for this person
                childrel = [(ref.get_mother_relation(), 
                             ref.get_father_relation()) for ref in 
                                family.get_child_ref_list() 
                                if ref.ref == person.handle]
                fhandle = family.father_handle
                mhandle = family.mother_handle
                for data in [(fhandle, self.REL_FATHER, 
                                self.REL_FATHER_NOTBIRTH, childrel[0][1]), 
                             (mhandle, self.REL_MOTHER, 
                                self.REL_MOTHER_NOTBIRTH, childrel[0][0])]:
                    if data[0] and not data[0] in parentstodo.keys() :
                        persontodo = db.get_person_from_handle(data[0])
                        if data[3] == gen.lib.ChildRefType.BIRTH :
                            addstr = data[1]
                        elif not self.__only_birth :
                            addstr = data[2]
                        else :
                            addstr = ''
                        if addstr :
                            parentstodo[data[0]] = (persontodo, 
                                                    rel_str + addstr,
                                                    rel_fam_new)
                    elif data [0] and data[0] in parentstodo.keys():
                        #this person is already scheduled to research
                        #update family list
                        famlist = parentstodo[data[0]][2]
                        if not isinstance(famlist[-1], list) and \
                                not fam == famlist[-1]:
                            famlist = famlist[:-1] + [[famlist[-1]]]
                        if isinstance(famlist[-1], list) and \
                                fam not in famlist[-1] :
                            famlist = famlist[:-1] + [famlist[-1] + [fam]]
                            parentstodo[data[0]] = (parentstodo[data[0]][0],
                                                    parentstodo[data[0]][1],
                                                    famlist
                                                    )
                if not fhandle and not mhandle and stoprecursemap is None:
                    #family without parents, add brothers for orig person
                    #other person has recusemap, and will stop when seeing
                    #the brother.
                    child_list = [ref.ref for ref in family.get_child_ref_list()
                          if ref.ref != person.handle]
                    addstr = self.REL_SIBLING
                    for chandle in child_list :
                        if pmap.has_key(chandle) :
                            pmap[chandle][0] += [rel_str + addstr]
                            pmap[chandle][1] += [rel_fam_new]
                            #person is already a grandparent in another branch
                        else:
                            pmap[chandle] = [[rel_str+addstr],[rel_fam_new]]
                fam += 1

            for handle in parentstodo.keys():
                data = parentstodo[handle]
                self.__apply_filter(db, data[0],
                                data[1], data[2],
                                pmap, depth, stoprecursemap)
        except:
            import traceback
            print traceback.print_exc()
            return

    def collapse_relations(self, relations):
        """ Internal method to condense the relationships as returned by
            get_relationship_distance_new.
            Common ancestors in the same family are collapsed to one entry,
            changing the person paths to family paths, eg 'mf' and 'mm' become
            'ma'
            
            relations : list of relations as returned by 
                        get_relationship_distance_new with all_dist = True
                        
            returns : the same data as relations, but collapsed, hence the 
                        handle entry is now a list of handles, and the 
                        path to common ancestors can now contain family
                        identifiers (eg 'a', ...)
                        In the case of sibling, this is replaced by family
                        with common ancestor handles empty list []!
        """
        if relations[0][0] == -1 :
            return relations
        commonnew = []
        existing_path = []
        for relation in relations:
            relstrfirst = None
            commonhandle = [relation[1]]
            if relation[2] :
                relstrfirst = relation[2][:-1]
            relstrsec = None
            if relation[4] :
                relstrsec = relation[4][:-1]
            relfamfirst = relation[3][:]
            relfamsec = relation[5][:]
            #handle pure sibling:
            rela2 = relation[2]
            rela4 = relation[4]
            if relation[2] and relation[2][-1] == self.REL_SIBLING:
                #sibling will be the unique common ancestor, 
                #change to a family with unknown handle for common ancestor
                rela2 = relation[2][:-1] + self.REL_FAM_BIRTH
                rela4 = relation[4] + self.REL_FAM_BIRTH
                relfamsec = relfamsec + [relfamfirst[-1]]
                relstrsec = relation[4][:-1]
                commonhandle = []
                    
            # a unique path to family of common person:
            familypaths = []
            if relfamfirst and isinstance(relfamfirst[-1], list):
                if relfamsec and isinstance(relfamsec[-1], list):
                    for val1 in relfamfirst[-1]:
                        for val2 in relfamsec[-1]:
                            familypaths.append((relstrfirst, relstrsec,
                                                relfamfirst[:-1] + [val1], 
                                                relfamsec[:-1] + [val2]))
                else:
                    for val1 in relfamfirst[-1]:
                        familypaths.append((relstrfirst, relstrsec,
                                            relfamfirst[:-1] + [val1], 
                                            relfamsec))
            elif relfamsec and isinstance(relfamsec[-1], list):
                for val2 in relfamsec[-1]:
                    familypaths.append((relstrfirst, relstrsec,
                                        relfamfirst, 
                                        relfamsec[:-1] + [val2]))
            else:
                familypaths.append((relstrfirst, relstrsec,
                                    relfamfirst, relfamsec))
            for familypath in familypaths:
                #familypath = (relstrfirst, relstrsec, relfamfirst, relfamsec)
                try:
                    posfam = existing_path.index(familypath)
                except ValueError:
                    posfam = None
                #if relstr is '', the ancestor is unique, if posfam None, 
                # first time we see this family path
                if (posfam is not None and relstrfirst is not None and 
                        relstrsec is not None):
                    #we already have a common ancestor of this family, just add the
                    #other, setting correct family relation
                    tmp = commonnew[posfam]
                    frstcomstr = rela2[-1]
                    scndcomstr = tmp[2][-1]
                    newcomstra = self.famrel_from_persrel(frstcomstr, scndcomstr)
                    frstcomstr = rela4[-1]
                    scndcomstr = tmp[4][-1]
                    newcomstrb = self.famrel_from_persrel(frstcomstr, scndcomstr)

                    commonnew[posfam] = (tmp[0], tmp[1]+commonhandle, 
                                 rela2[:-1]+newcomstra, 
                                 tmp[3], rela4[:-1]+newcomstrb,
                                 tmp[5])
                else :
                    existing_path.append(familypath)
                    commonnew.append((relation[0], commonhandle, rela2,
                                    familypath[2], rela4, familypath[3]) 
                                    )
        #we now have multiple person handles, single families, now collapse
        #  families again if all else equal
        collapsed = commonnew[:1]
        for rel in commonnew[1:]:
            found = False
            for newrel in collapsed:
                if newrel[0:3] == rel[0:3] and newrel[4] == rel[4]:
                    #another familypath to arrive at same result, merge
                    path1 = []
                    path2 = []
                    for a, b in zip(newrel[3], rel[3]):
                        if a == b:
                            path1.append(a)
                        elif isinstance(a, list):
                            path1.append(a.append(b))
                        else:
                            path1.append([a, b])
                    for a, b in zip(newrel[5], rel[5]):
                        if a == b:
                            path2.append(a)
                        elif isinstance(a, list):
                            path2.append(a.append(b))
                        else:
                            path2.append([a, b])
                    newrel[3][:] = path1[:]
                    newrel[5][:] = path2[:]
                    found = True
                    break
            if not found:
                collapsed.append(rel)
        
        return collapsed

    def famrel_from_persrel(self, persrela, persrelb):
        """ Conversion from eg 'f' and 'm' to 'a', so relation to the two 
            persons of a common family is converted to a family relation
        """
        if persrela == persrelb:
            #should not happen, procedure called in error, just return value
            return persrela
        if (persrela == self.REL_MOTHER and persrelb == self.REL_FATHER) or \
            (persrelb == self.REL_MOTHER and persrela == self.REL_FATHER):
            return self.REL_FAM_BIRTH
        if (persrela == self.REL_MOTHER and persrelb == self.REL_FATHER_NOTBIRTH) or \
            (persrelb == self.REL_MOTHER and persrela == self.REL_FATHER_NOTBIRTH):
            return self.REL_FAM_BIRTH_MOTH_ONLY
        if (persrela == self.REL_FATHER and persrelb == self.REL_MOTHER_NOTBIRTH) or \
            (persrelb == self.REL_FATHER and persrela == self.REL_MOTHER_NOTBIRTH):
            return self.REL_FAM_BIRTH_FATH_ONLY
        #catch calling with family relations already, return val
        if (persrela == self.REL_FAM_BIRTH or 
                persrela == self.REL_FAM_BIRTH_FATH_ONLY or
                persrela == self.REL_FAM_BIRTH_MOTH_ONLY or 
                persrela == self.REL_FAM_NONBIRTH):
            return persrela
        if (persrelb == self.REL_FAM_BIRTH or 
                persrelb == self.REL_FAM_BIRTH_FATH_ONLY or
                persrelb == self.REL_FAM_BIRTH_MOTH_ONLY or 
                persrelb == self.REL_FAM_NONBIRTH):
            return persrelb
        return self.REL_FAM_NONBIRTH

    def only_birth(self, path):
        """ given a path to common ancestor. Return True if only birth 
            relations, False otherwise
        """
        only_birth = True
        for str in path:
            only_birth = only_birth and (str not in [self.REL_FAM_NONBIRTH, 
                           self.REL_FATHER_NOTBIRTH, self.REL_MOTHER_NOTBIRTH])
        return only_birth

    def get_one_relationship(self, db, orig_person, other_person, 
                             extra_info=False):
        """
        returns a string representing the most relevant relationship between 
        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:
            rel_str = _("undefined")
            stop = True

        if not stop and orig_person.get_handle() == other_person.get_handle():
            rel_str = ''
            stop = True

        if not stop:
            is_spouse = self.is_spouse(db, orig_person, other_person)
            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(
                                db, orig_person, other_person,
                                all_dist=True,
                                all_families=True, only_birth=False)
        if data[0][0] == -1:
            if extra_info:
                return ('', -1, -1)
            else:
                return ''

        data = self.collapse_relations(data)

        #most relevant relationship is a birth family relation of lowest rank
        databest = [data[0]]
        rankbest = data[0][0]
        for rel in data :
            #data is sorted on rank
            if rel[0] == rankbest:
                databest.append(rel)
        rel = databest[0]
        dist_orig = len(rel[2])
        dist_other= len(rel[4])
        if len(databest) == 1:
            birth = self.only_birth(rel[2]) and self.only_birth(rel[4])
            if dist_orig == 1 and dist_other == 1:
                rel_str = self.get_sibling_relationship_string(
                            self.get_sibling_type(
                                                db, orig_person, other_person), 
                            orig_person.get_gender(),
                            other_person.get_gender())
            else:
                rel_str = self.get_single_relationship_string(dist_orig,
                                                  dist_other,
                                                  orig_person.get_gender(),
                                                  other_person.get_gender(),
                                                  rel[2], rel[4],
                                                  only_birth=birth, 
                                                  in_law_a=False, 
                                                  in_law_b=False)
        else:
            order = [self.REL_FAM_BIRTH, self.REL_FAM_BIRTH_MOTH_ONLY,
                     self.REL_FAM_BIRTH_FATH_ONLY, self.REL_MOTHER,
                     self.REL_FATHER, self.REL_SIBLING, self.REL_FAM_NONBIRTH, 
                     self.REL_MOTHER_NOTBIRTH, self.REL_FATHER_NOTBIRTH]
            orderbest = order.index(self.REL_MOTHER)
            for relother in databest:
                relbirth = self.only_birth(rel[2]) and self.only_birth(rel[4])
                if relother[2] == '' or relother[4]== '':
                    #direct relation, take that
                    rel = relother
                    break
                if not relbirth and self.only_birth(relother[2]) \
                                and self.only_birth(relother[4]) :
                    #birth takes precedence
                    rel = relother
                    continue
                if order.index(relother[2][-1]) < order.index(rel[2][-1]) and\
                        order.index(relother[2][-1]) < orderbest:
                    rel = relother
                    continue
                if order.index(relother[4][-1]) < order.index(rel[4][-1]) and\
                        order.index(relother[4][-1]) < orderbest:
                    rel = relother
                    continue
                if order.index(rel[2][-1]) < orderbest or \
                        order.index(rel[4][-1]) < orderbest:
                    #keep the good one
                    continue
                if order.index(relother[2][-1]) < order.index(rel[2][-1]):
                    rel = relother
                    continue
                if order.index(relother[2][-1]) == order.index(rel[2][-1]) and\
                        order.index(relother[4][-1]) < order.index(rel[4][-1]):
                    rel = relother
                    continue
            dist_orig = len(rel[2])
            dist_other= len(rel[4])
            birth = self.only_birth(rel[2]) and self.only_birth(rel[4])
            if dist_orig == 1 and dist_other == 1:
                rel_str =  self.get_sibling_relationship_string(
                            self.get_sibling_type(
                                                db, orig_person, other_person), 
                            orig_person.get_gender(),
                            other_person.get_gender())
            else:
                rel_str = self.get_single_relationship_string(dist_orig,
                                                  dist_other,
                                                  orig_person.get_gender(),
                                                  other_person.get_gender(),
                                                  rel[2], rel[4],
                                                  only_birth=birth, 
                                                  in_law_a=False, 
                                                  in_law_b=False)
        if extra_info:
            return (rel_str, dist_orig, dist_other)
        else:
            return rel_str

    def get_all_relationships(self, db, orig_person, other_person):
        """ Return a tuple, of which the first entry is a list with all
            relationships in text, and the second a list of lists of all common
            ancestors that have that text as relationship
        """
        relstrings = []
        commons = {}
        if orig_person == None:
            return ([], [])

        if orig_person.get_handle() == other_person.get_handle():
            return ([], [])

        is_spouse = self.is_spouse(db, orig_person, other_person)
        if is_spouse:
            relstrings.append(is_spouse)
            commons[is_spouse] = []
        
        data, msg = self.get_relationship_distance_new(
                                db, orig_person, other_person,
                                all_dist=True,
                                all_families=True, only_birth=False)
        if not data[0][0] == -1:
            for rel in data :
                rel2 = rel[2]
                rel4 = rel[4]
                rel1 = rel[1]
                dist_orig = len(rel[2])
                dist_other= len(rel[4])
                if rel[2] and rel[2][-1] == self.REL_SIBLING:
                    rel2 = rel2[:-1] + self.REL_FAM_BIRTH
                    dist_other += 1
                    rel4 = rel4 + self.REL_FAM_BIRTH
                    rel1 = None
                birth = self.only_birth(rel2) and self.only_birth(rel4)
                if dist_orig == 1 and dist_other == 1:
                    rel_str = self.get_sibling_relationship_string(
                                self.get_sibling_type(
                                                db, orig_person, other_person), 
                                orig_person.get_gender(),
                                other_person.get_gender())
                else:
                    rel_str = self.get_single_relationship_string(dist_orig,
                                                     dist_other,
                                                     orig_person.get_gender(),
                                                     other_person.get_gender(),
                                                     rel2, rel4,
                                                     only_birth=birth, 
                                                     in_law_a=False, 
                                                     in_law_b=False)
                if not rel_str in relstrings:
                    relstrings.append(rel_str)
                    if rel1:
                        commons[rel_str] = [rel1]
                    else:
                        #unknown parent eg
                        commons[rel_str] = []
                else:
                    if rel1:
                        commons[rel_str].append(rel1)
        #construct the return tupply, relstrings is ordered on rank automatic
        common_list = []
        for rel_str in relstrings:
            common_list.append(commons[rel_str])
        return (relstrings, common_list)

    def get_grandparents_string(self, db, orig_person, other_person):
        """
        returns a string representing the relationship between the two people
        if the other_person is a grandparent in general terms and in plural
        """
        (rel_str, dist_orig, dist_other) = self.get_one_relationship(db, 
                                            orig_person, other_person,
                                            extra_info = True)

        if dist_other == 0:
            return self.get_parents(dist_orig)
        else:
            return None
        
    def get_plural_relationship_string(self, Ga, Gb):
        """
        Provide a string that describes the relationsip between a person, and
        a group of people with the same relationship. E.g. "grandparents" or
        "children".
        
        Ga and Gb can be used to mathematically calculate the relationship.
        See the Wikipedia entry for more information:
            http://en.wikipedia.org/wiki/Cousin#Mathematical_definitions
        
        @param Ga: The number of generations between the main person and the 
        common ancestor.
        @type Ga: int
        @param Gb: The number of generations between the group of people and the
        common ancestor
        @type Gb: int
        @returns: A string describing the relationship between the person and
        the group.
        @rtype: str
        """
        rel_str = "distant relatives"
        if Ga == 0:
            # These are descendants
            if Gb < len(_children_level):
                rel_str = _children_level[Gb]
            else:
                rel_str = "distant descendants"
        elif Gb == 0:
            # These are parents/grand parents
            if Ga < len(_parents_level):
                rel_str = _parents_level[Ga]
            else:
                rel_str = "distant ancestors"
        elif Gb == 1:
            # These are siblings/aunts/uncles
            if Ga < len(_siblings_level):
                rel_str = _siblings_level[Ga]
            else:
                rel_str = "distant uncles/aunts"
        elif Ga == 1:
            # These are nieces/nephews
            if Gb < len(_nephews_nieces_level):
                rel_str = _nephews_nieces_level[Gb]
            else:
                rel_str = "distant nephews/nieces"
        elif Ga > 1 and Ga == Gb:
            # These are cousins in the same generation
            if Ga <= len(_level_name):
                rel_str = "%s cousins" % _level_name[Ga-1]
            else:
                rel_str = "distant cousins"
        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 Gb <= len(_level_name) and (Ga-Gb) < len(_removed_level):
                rel_str = "%s cousins%s (up)" % ( _level_name[Gb-1], 
                                                  _removed_level[Ga-Gb] )
            else:
                rel_str =  "distant cousins"
        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 Ga <= len(_level_name) and (Gb-Ga) < len(_removed_level):
                rel_str = "%s cousins%s (down)" % ( _level_name[Ga-1], 
                                                    _removed_level[Gb-Ga] )
            else:
                rel_str =  "distant cousins"
        return rel_str
    
    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):
        """
        Provide a string that describes the relationsip between a person, and
        another person. E.g. "grandparent" or "child".
        To be used as: 'person b is the grandparent of a', this will 
            be in translation string :
                            'person b is the %(relation)s of a'
            Note that languages with gender should add 'the' inside the 
            translation, so eg in french:
                            'person b est %(relation)s de a'
            where relation will be here: le grandparent
        
        Ga and Gb can be used to mathematically calculate the relationship.
        See the Wikipedia entry for more information:
            http://en.wikipedia.org/wiki/Cousin#Mathematical_definitions
        
        Some languages need to know the specific path to the common ancestor.
        Those languages should use reltocommon_a and reltocommon_b which is 
        a string like 'mfmf'. The possible string codes are:
            REL_MOTHER             # going up to mother
            REL_FATHER             # going up to father
            REL_MOTHER_NOTBIRTH    # going up to mother, not birth relation
            REL_FATHER_NOTBIRTH    # going up to father, not birth relation
            REL_FAM_BIRTH          # going up to family (mother and father)
            REL_FAM_NONBIRTH       # going up to family, not birth relation
            REL_FAM_BIRTH_MOTH_ONLY # going up to fam, only birth rel to mother
            REL_FAM_BIRTH_FATH_ONLY # going up to fam, only birth rel to father
        Prefix codes are stripped, so REL_FAM_INLAW_PREFIX is not present. 
        If the relation starts with the inlaw of the person a, then 'in_law_a'
        is True, if it starts with the inlaw of person b, then 'in_law_b' is
        True.
        Also REL_SIBLING (# going sideways to sibling (no parents)) is not 
        passed to this routine. The collapse_relations changes this to a 
        family relation. 
        Hence, calling routines should always strip REL_SIBLING and 
        REL_FAM_INLAW_PREFIX before calling get_single_relationship_string()
        Note that only_birth=False, means that in the reltocommon one of the
        NOTBIRTH specifiers is present.
        The REL_FAM identifiers mean that the relation is not via a common 
        ancestor, but via a common family (note that that is not possible for 
        direct descendants or direct ancestors!). If the relation to one of the
        parents in that common family is by birth, then 'only_birth' is not
        set to False. The only_birth() method is normally used for this.
            
        @param Ga: The number of generations between the main person and the 
                   common ancestor.
        @type Ga: int
        @param Gb: The number of generations between the other person and the
                   common ancestor
        @type Gb: int
        @param gender_a : gender of person a
        @type gender_a: int gender
        @param gender_b : gender of person b
        @type gender_b: int gender
        @param reltocommon_a : relation path to common ancestor or common
                            Family for person a. 
                            Note that length = Ga
        @type reltocommon_a: str 
        @param reltocommon_b : relation path to common ancestor or common
                            Family for person b. 
                            Note that length = Gb
        @type reltocommon_b: str 
        @param in_law_a : True if path to common ancestors is via the partner
                          of person a
        @type in_law_a: bool
        @param in_law_b : True if path to common ancestors is via the partner
                          of person b
        @type in_law_b: bool
        @param only_birth : True if relation between a and b is by birth only
                            False otherwise
        @type only_birth: bool
        @returns: A string describing the relationship between the two people
        @rtype: str
        
        NOTE: 1/the self.REL_SIBLING should not be passed to this routine, 
                so we should not check on it. All other self.
              2/for better determination of siblings, use if Ga=1=Gb 
                get_sibling_relationship_string
        """
        if only_birth:
            step = ''
        else:
            step = self.STEP

        if in_law_a or in_law_b :
            inlaw = self.INLAW
        else:
            inlaw = ''

        rel_str = "distant %srelative%s" % (step, inlaw)

        if Ga == 0:
            # b is descendant of a
            if Gb == 0 :
                rel_str = 'same person'
            elif gender_b == gen.lib.Person.MALE:
                rel_str = self._get_son(Gb, step, inlaw)
            elif gender_b == gen.lib.Person.FEMALE:
                rel_str = self._get_daughter(Gb, step, inlaw)
            else:
                rel_str = self._get_child_unknown(Gb, step, inlaw)
        elif Gb == 0:
            # b is parents/grand parent of a
            if 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:
                rel_str = self._get_parent_unknown(Ga, step, inlaw)
        elif Gb == 1:
            # b is sibling/aunt/uncle of a
            if gender_b == gen.lib.Person.MALE:
                rel_str = self._get_uncle(Ga, step, inlaw)
            elif gender_b == gen.lib.Person.FEMALE:
                rel_str = self._get_aunt(Ga, step, inlaw)
            else:
                rel_str = self._get_sibling(Ga, step, inlaw)
        elif Ga == 1:
            # b is niece/nephew of a
            if gender_b == gen.lib.Person.MALE:
                rel_str = self._get_nephew(Gb-1, step, inlaw)
            elif gender_b == gen.lib.Person.FEMALE:
                rel_str = self._get_niece(Gb-1, step, inlaw)
            elif Gb < len(_niece_level) and Gb < len(_nephew_level):
                rel_str = "%s or %s" % (self._get_nephew(Gb-1, step, inlaw),
                                        self._get_niece(Gb-1, step, inlaw))
            else:
                rel_str = "distant %snephews/nieces%s" % (step, inlaw)
        elif Ga == Gb:
            # a and b cousins in the same generation
            rel_str = self._get_cousin(Ga-1, 0, dir = '', step=step, 
                                     inlaw=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 = self._get_cousin(Gb-1, Ga-Gb, dir = ' (up)', 
                                     step=step, inlaw=inlaw)
        elif 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.
            rel_str = self._get_cousin(Ga-1, Gb-Ga, dir = ' (down)', 
                                     step=step, inlaw=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.
            DON'T TRANSLATE THIS PROCEDURE IF LOGIC IS EQUAL IN YOUR LANGUAGE,
                AND SAME METHODS EXIST (get_uncle, get_aunt, get_sibling)
        """
        if sib_type == self.NORM_SIB or sib_type == self.UNKNOWN_SIB:
            typestr = ''
        elif sib_type == self.HALF_SIB_MOTHER \
                or sib_type == self.HALF_SIB_FATHER:
            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 gender_b == gen.lib.Person.MALE:
            rel_str = self._get_uncle(1, typestr, inlaw)
        elif gender_b == gen.lib.Person.FEMALE:
            rel_str = self._get_aunt(1, typestr, inlaw)
        else:
            rel_str = self._get_sibling(1, typestr, inlaw)
        return rel_str

    def get_partner_relationship_string(self, spouse_type, gender_a, gender_b):
        """ Determine the string giving the relation between two partnes of
            type spouse_type.
            Eg: b is the spouse of a
                Here 'spouse' is the string we need to determine
            DON'T TRANSLATE THIS PROCEDURE IF LOGIC IS EQUAL IN YOUR LANGUAGE,
                AS GETTEXT IS ALREADY USED !
        """
        #english only needs gender of b, we don't guess if unknown like in old 
        # procedure as that is stupid in present day cases!
        gender = gender_b

        if not spouse_type:
            return ''

        if spouse_type == self.PARTNER_MARRIED:
            if gender == gen.lib.Person.MALE:
                return _("husband")
            elif gender == gen.lib.Person.FEMALE:
                return _("wife")
            else:
                return _("gender unknown|spouse")
        elif spouse_type == self.PARTNER_EX_MARRIED:
            if gender == gen.lib.Person.MALE:
                return _("ex-husband")
            elif gender == gen.lib.Person.FEMALE:
                return _("ex-wife")
            else:
                return _("gender unknown|ex-spouse")
        elif spouse_type == self.PARTNER_UNMARRIED:
            if gender == gen.lib.Person.MALE:
                return _("unmarried|husband")
            elif gender == gen.lib.Person.FEMALE:
                return _("unmarried|wife")
            else:
                return _("gender unknown,unmarried|spouse")
        elif spouse_type == self.PARTNER_EX_UNMARRIED:
            if gender == gen.lib.Person.MALE:
                return _("unmarried|ex-husband")
            elif gender == gen.lib.Person.FEMALE:
                return _("unmarried|ex-wife")
            else:
                return _("gender unknown,unmarried|ex-spouse")
        elif spouse_type == self.PARTNER_CIVIL_UNION:
            if gender == gen.lib.Person.MALE:
                return _("male,civil union|partner")
            elif gender == gen.lib.Person.FEMALE:
                return _("female,civil union|partner")
            else:
                return _("gender unknown,civil union|partner")
        elif spouse_type == self.PARTNER_EX_CIVIL_UNION:
            if gender == gen.lib.Person.MALE:
                return _("male,civil union|former partner")
            elif gender == gen.lib.Person.FEMALE:
                return _("female,civil union|former partner")
            else:
                return _("gender unknown,civil union|former partner")
        elif spouse_type == self.PARTNER_UNKNOWN_REL:
            if gender == gen.lib.Person.MALE:
                return _("male,unknown relation|partner")
            elif gender == gen.lib.Person.FEMALE:
                return _("female,unknown relation|partner")
            else:
                return _("gender unknown,unknown relation|partner")
        else:
            # here we have spouse_type == self.PARTNER_EX_UNKNOWN_REL
            #   or other not catched types
            if gender == gen.lib.Person.MALE:
                return _("male,unknown relation|former partner")
            elif gender == gen.lib.Person.FEMALE:
                return _("female,unknown relation|former partner")
            else:
                return _("gender unknown,unknown relation|former partner")

    def connect_db_signals(self, dbstate):
        """ We can save work by storing a map, however, if database changes
            this map must be regenerated.
            Before close, the calling app must call disconnect_db_signals
        """
        if self.__db_connected:
            return
        assert(len(self.signal_keys)==0)
        self.state_signal_key = dbstate.connect('database-changed', 
                                                    self._dbchange_callback)
        self.__connect_db_signals(dbstate.db)
    
    def __connect_db_signals(self, db):
        signals = ['person-add', 'person-update', 'person-delete',
                    'person-rebuild', 'family-add', 'family-update', 
                    'family-delete', 'family-rebuild', 'database-changed']
        for name in signals:
            self.signal_keys.append(db.connect(name, 
                                                    self._datachange_callback))
        self.storemap = True
        self.__db_connected = True

    def disconnect_db_signals(self, dbstate):
        """ Method to disconnect to all signals the relationship calculator is
            subscribed
        """
        dbstate.disconnect(self.state_signal_key)
        for key in self.signal_keys:
            dbstate.db.disconnect(key)
        self.storemap = False
        self.stored_map = None

    def _dbchange_callback(self, db):
        """ When database changes, the map can no longer be used. 
            Connects must be remade
        """
        self.dirtymap = True
        #signals are disconnected on close of old database, connect to new
        self.__connect_db_signals(db)

    def _datachange_callback(self, list=[]):
        """ When data in database changes, the map can no  longer be used. 
            As the map might be in use or might be generated at the moment, 
            this method sets a dirty flag. Before reusing the map, this flag 
            will be checked
        """
        self.dirtymap = True


def _test(rc, onlybirth, inlawa, inlawb, printrelstr):
    """ this is a generic test suite for the singular relationship
            TRANSLATORS: do NOT translate, use __main__ !
    """
    import sys
    import random
    random.seed()
    def _rand_f_m():
        if random.randint(0, 1) == 0 :
            return 'f'
        else:
            return 'm'
        
    def _rand_relstr(len, endstr):
        if len == 0:
            return ''
        else:
            relstr = ''
            for i in range(len-1):
                relstr += _rand_f_m()
            return relstr + endstr
    
    FMT = '%+50s'
    MAX = 30
    
    #rc = RelationshipCalculator()
    
    print '\ntesting sons (Enter to start)\n'
    sys.stdin.readline()
    for i in range(MAX) :
        relstr = _rand_relstr(i,'f')
        rel =  FMT % rc.get_single_relationship_string(0, i, 
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.MALE,
                                            '', relstr,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, 
                                            in_law_b=inlawb)
        if printrelstr :
            print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting daughters\n'
    sys.stdin.readline()
    for i in range(MAX) :
        relstr = _rand_relstr(i,'m')
        rel = FMT % rc.get_single_relationship_string(0, i, 
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.FEMALE,
                                            '', relstr,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
            print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting unknown children\n'
    sys.stdin.readline()
    for i in range(MAX) :
        relstr = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(0, i, 
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.UNKNOWN,
                                            '', relstr,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
            print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting grandfathers\n'
    sys.stdin.readline()
    for i in range(MAX) :
        relstr = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(i, 0,
                                            gen.lib.Person.FEMALE, 
                                            gen.lib.Person.MALE,
                                            relstr, '',
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting grandmothers\n'
    sys.stdin.readline()
    for i in range(MAX) :
        relstr = _rand_relstr(i,'m')
        rel = FMT % rc.get_single_relationship_string(i, 0,
                                            gen.lib.Person.FEMALE, 
                                            gen.lib.Person.FEMALE,
                                            relstr, '',
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting unknown parents\n'
    sys.stdin.readline()
    for i in range(MAX) :
        relstr = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(i, 0,
                                            gen.lib.Person.FEMALE, 
                                            gen.lib.Person.UNKNOWN,
                                            relstr, '',
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting nieces\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstr = _rand_relstr(i,'m')
        rel = FMT % rc.get_single_relationship_string(1, i,
                                            gen.lib.Person.FEMALE, 
                                            gen.lib.Person.FEMALE,
                                            'm', relstr,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting nephews\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstr = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(1, i,
                                            gen.lib.Person.FEMALE, 
                                            gen.lib.Person.MALE,
                                            'f', relstr,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting unknown nephews/nieces\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstr = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(1, i,
                                            gen.lib.Person.FEMALE, 
                                            gen.lib.Person.UNKNOWN,
                                            'f', relstr,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting uncles\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstr = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(i, 1,
                                            gen.lib.Person.FEMALE, 
                                            gen.lib.Person.MALE,
                                            relstr, 'f',
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting aunts\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstr = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(i, 1,
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.FEMALE,
                                            relstr, 'f',
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting unknown uncles/aunts\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstr = _rand_relstr(i,'m')
        rel = FMT % rc.get_single_relationship_string(i, 1,
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.UNKNOWN,
                                            relstr, 'm',
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstr
        else:
            print rel
    print '\n\ntesting male cousins same generation\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstra = _rand_relstr(i,'f')
        relstrb = _rand_relstr(i,'f')
        rel = FMT % rc.get_single_relationship_string(i, i,
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.MALE,
                                            relstra, 
                                            relstrb,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstra, relstrb
        else:
            print rel
    print '\n\ntesting female cousins same generation\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstra = _rand_relstr(i,'m')
        relstrb = _rand_relstr(i,'m')
        rel = FMT % rc.get_single_relationship_string(i, i,
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.FEMALE,
                                            relstra, 
                                            relstrb,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstra, relstrb
        else:
            print rel
    print '\n\ntesting unknown cousins same generation\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        relstra = _rand_relstr(i,'m')
        relstrb = _rand_relstr(i,'m')
        rel = FMT % rc.get_single_relationship_string(i, i,
                                            gen.lib.Person.MALE, 
                                            gen.lib.Person.UNKNOWN,
                                            relstra, 
                                            relstrb,
                                            only_birth=onlybirth, 
                                            in_law_a=inlawa, in_law_b=inlawb)
        if printrelstr :
                print rel + ' |info:', relstra, relstrb
        else:
            print rel
    print '\n\ntesting some cousins up\n'
    sys.stdin.readline()
    import random
    random.seed()
    for i in range(1,MAX) :
        for j in range (i,MAX) :
            rnd = random.randint(0, 100)
            if rnd < 10 :
                relstra = _rand_relstr(j,'f')
                relstrb = _rand_relstr(i,'f')
                if rnd < 5 :
                    rel =  (FMT + ' |info: female, Ga=%2d, Gb=%2d') % (
                                    rc.get_single_relationship_string(j, i,
                                    gen.lib.Person.MALE, 
                                    gen.lib.Person.FEMALE,
                                    relstra, relstrb,
                                    only_birth=onlybirth, 
                                    in_law_a=inlawa, in_law_b=inlawb), j, i )
                    if printrelstr :
                        print rel + ' |info:', relstra, relstrb
                    else:
                        print rel
                else:
                    rel =  (FMT + ' |info:   male, Ga=%2d, Gb=%2d') % (
                                    rc.get_single_relationship_string(j, i,
                                    gen.lib.Person.MALE, 
                                    gen.lib.Person.MALE,
                                    relstra, relstrb,
                                    only_birth=onlybirth, 
                                    in_law_a=inlawa, in_law_b=inlawb), j, i )
                    if printrelstr :
                        print rel + ' |info:', relstra, relstrb
                    else:
                        print rel
    print '\n\ntesting some cousins down\n'
    sys.stdin.readline()
    for i in range(1,MAX) :
        for j in range (i,MAX) :
            rnd = random.randint(0, 100)
            if rnd < 10 :
                relstra = _rand_relstr(i,'f')
                relstrb = _rand_relstr(j,'f')
                if rnd < 5 :
                    rel = (FMT + ' |info: female, Ga=%2d, Gb=%2d') % (
                                    rc.get_single_relationship_string(i, j,
                                    gen.lib.Person.MALE, 
                                    gen.lib.Person.FEMALE,
                                    relstra, relstrb,
                                    only_birth=onlybirth, 
                                    in_law_a=inlawa, in_law_b=inlawb), i, j)
                    if printrelstr :
                        print rel + ' |info:', relstra, relstrb
                    else:
                        print rel
                else:
                    rel = (FMT + ' |info:   male, Ga=%2d, Gb=%2d') % (
                                    rc.get_single_relationship_string(i, j,
                                    gen.lib.Person.MALE, 
                                    gen.lib.Person.MALE,
                                    relstra, relstrb,
                                    only_birth=onlybirth, 
                                    in_law_a=inlawa, in_law_b=inlawb), i, j)
                    if printrelstr :
                        print rel + ' |info:', relstr
                    else:
                        print rel

def _testsibling(rc):
    vals = [(rc.NORM_SIB, 'sibling'),
            (rc.HALF_SIB_MOTHER, 'half sib mother side'),
            (rc.HALF_SIB_FATHER, 'half sib father side'),
            (rc.STEP_SIB, 'step sib'), (rc.UNKNOWN_SIB, 'undetermined sib')]
    FMT = '%+50s'
    for gendr, strgen in [(gen.lib.Person.MALE, 'male'), 
                           (gen.lib.Person.FEMALE, 'female'), 
                           (gen.lib.Person.UNKNOWN, 'unknown')]:
        for inlaw in [False, True]:
         for sibt, str in vals:
            print FMT % rc.get_sibling_relationship_string(
                                sibt, gen.lib.Person.MALE, gendr, 
                                in_law_a = inlaw) + ' |info:', str, strgen

def _test_spouse(rc):
    FMT = '%+50s'
    vals = [(rc.PARTNER_MARRIED, 'married'), (rc.PARTNER_UNMARRIED, 'unmarried'),
            (rc.PARTNER_CIVIL_UNION, 'civil union'), 
            (rc.PARTNER_UNKNOWN_REL, 'unknown rel'),
            (rc.PARTNER_EX_MARRIED, 'ex-married'), 
            (rc.PARTNER_EX_UNMARRIED, 'ex-unmarried'),
            (rc.PARTNER_EX_CIVIL_UNION, 'ex civil union'), 
            (rc.PARTNER_EX_UNKNOWN_REL, 'ex unknown rel')]

    for gender, strgen in [(gen.lib.Person.MALE, 'male'), 
                           (gen.lib.Person.FEMALE, 'female'), 
                           (gen.lib.Person.UNKNOWN, 'unknown')] :
        for spouse_type, str in vals:
            print FMT % rc.get_partner_relationship_string(
                            spouse_type, gen.lib.Person.MALE, gender) + \
                            ' |info: gender='+strgen+', rel='+str

def test(rc, printrelstr):
    """ this is a generic test suite for the singular relationship
            TRANSLATORS: do NOT translate, call this from 
                         __main__ in the rel_xx.py module.
    """
    import sys
    
    print '\nType  y   to do a test\n\n'
    print 'Test normal relations?'
    data = sys.stdin.readline()
    if data == 'y\n':
        _test(rc, True, False, False, printrelstr)
    print '\n\nTest step relations?'
    data = sys.stdin.readline()
    if data == 'y\n':
        _test(rc, False, False, False, printrelstr)
    print '\n\nTest in-law relations (first pers)?'
    data = sys.stdin.readline()
    if data == 'y\n':
        _test(rc, True, True, False, printrelstr)
    print '\n\nTest step and in-law relations?'
    data = sys.stdin.readline()
    if data == 'y\n':
        _test(rc, False, True, False, printrelstr)
    print '\n\nTest sibling types?'
    data = sys.stdin.readline()
    if data == 'y\n':
        _testsibling(rc)
    print '\n\nTest partner types?'
    data = sys.stdin.readline()
    if data == 'y\n':
        _test_spouse(rc)
    
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_fr.py 
    # (Above not needed here)
    
    """TRANSLATORS, copy this if statement at the bottom of your 
        rel_xx.py module, after adding: 'from Relationship import test'
        and test your work with:
        export PYTHONPATH=/path/to/gramps/src 
        python src/plugins/rel_xx.py
        
        See eg rel_fr.py at the bottom
    """
    rc = RelationshipCalculator()
    test(rc, True)
