Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e32e602b50
gramps/src/plugins/rel_pl.py
Raphael Ackermann b4cde9a54b 2008-03-05 Łukasz Rymarczyk <yenidai(at)poczta(dot)onet(dot)pl> 
* src/plugins/rel_pl.py: 0001776: Relationship calculator, update Polish
    Rewritten for 3.x version

svn: r10192
2008-03-05 07:39:45 +00:00

912 lines
32 KiB
Python
Raw Blame History

# -*- coding: utf-8 -*-
#
# 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
#
# Rewritten in 2008 for 3.x version by Łukasz Rymarczyk
# Written in 2007 by Piotr Czubaszek, largely based on rel_de.py by Alex Roitman.
# PL: Po objaśnienia oznaczania relacji zobacz Relationship.py
# EN: For more information see Relationship.py
#
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
import gen.lib
import Relationship
import types
from gettext import gettext as _
from PluginUtils import register_relcalc
#-------------------------------------------------------------------------
#
# Polish-specific definitions of relationships
#
#-------------------------------------------------------------------------
# określa liczebnik porządkowy
_level_name = [ "pierwszego", "drugiego", "trzeciego", "czwartego", "piątego",
"szóstego", "siódmego", "ósmego", "dziewiątego", "dziesiątego",
"jedenastego", "dwunastego","trzynastego", "czternastego", "piętnastego",
"szesnastego", "siedemnastego", "osiemnastego","dziewiętnastego", "dwudziestego", ]
_father_level = [ "",
"ojciec",
"dziadek",
"pradziadek",
"prapradziadek",
"praprapradziadek",
"prapraprapradziadek",
"praprapraprapradziadek",
"prapraprapraprapradziadek",
"praprapraprapraprapradziadek",
"prapraprapraprapraprapradziadek",
]
_mother_level = [ "",
"matka",
"babcia",
"prababcia",
"praprababcia",
"prapraprababcia",
"praprapraprababcia",
"prapraprapraprababcia",
"praprapraprapraprababcia",
"prapraprapraprapraprababcia",
"praprapraprapraprapraprababcia",
]
_son_level = [ "",
"syn",
"wnuk",
"prawnuk",
"praprawnuk",
"prapraprauwnuk",
"praprapraprauwnuk",
"prapraprapraprawnuk",
"praprapraprapraprawnuk",
"prapraprapraprapraprawnuk",
"praprapraprapraprapraprawnuk",
]
_daughter_level = [ "",
"córka",
"wnuczka",
"prawnuczka",
"praprawnuczka",
"prapraprauwnuczka",
"praprapraprauwnuczka",
"prapraprapraprawnuczka",
"praprapraprapraprawnuczka",
"prapraprapraprapraprawnuczka",
"praprapraprapraprapraprawnuczka",
]
_sister_level_of_male = [ "", "siostra", "ciotka stryjeczna",
"babcia stryjeczna",
"prababcia stryjeczna",
"praprababcia stryjeczna",
"prapraprababcia stryjeczna",
"praprapraprababcia stryjeczna",
"prapraprapraprababcia stryjeczna",
"praprapraprapraprababcia stryjeczna",
"prapraprapraprapraprababcia stryjeczna",
"praprapraprapraprapraprababcia stryjeczna",
]
_sister_level_of_female = [ "", "siostra", "ciotka",
"babcia cioteczna",
"prababcia cioteczna",
"praprababcia cioteczna",
"prapraprababcia cioteczna",
"praprapraprababcia cioteczna",
"prapraprapraprababcia cioteczna",
"praprapraprapraprababcia cioteczna",
"prapraprapraprapraprababcia cioteczna",
"praprapraprapraprapraprababcia cioteczna",
]
_brother_level_of_male = [ "", "brat", "stryj",
"dziadek stryjeczny",
"pradziadek stryjeczny",
"prapradziadek stryjeczny",
"praprapradziadek stryjeczny",
"prapraprapradziadek stryjeczny",
"praprapraprapradziadek stryjeczny",
"prapraprapraprapradziadek stryjeczny",
"praprapraprapraprapradziadek stryjeczny",
"prapraprapraprapraprapradziadek stryjeczny",
]
_brother_level_of_female = [ "", "brat", "wuj",
"dziadek cioteczny",
"pradziadek cioteczny",
"prapradziadek cioteczny",
"praprapradziadek cioteczny",
"prapraprapradziadek cioteczny",
"praprapraprapradziadek cioteczny",
"prapraprapraprapradziadek cioteczny",
"praprapraprapraprapradziadek cioteczny",
"prapraprapraprapraprapradziadek cioteczny",
]
_nephew_level_of_brothers_son = [ "", "bratanek",
"syn bratanka",
"wnuk bratanka",
"prawnuk bratanka",
"praprawnuk bratanka",
"prapraprawnuk bratanka",
"praprapraprawnuk bratanka",
"prapraprapraprawnuk bratanka",
"praprapraprapraprawnuk bratanka",
"prapraprapraprapraprawnuk bratanka",
]
_nephew_level_of_brothers_daughter = [ "", "bratanica",
"syn bratanicy",
"wnuk bratanicy",
"prawnuk bratanicy",
"praprawnuk bratanicy",
"prapraprawnuk bratanicy",
"praprapraprawnuk bratanicy",
"prapraprapraprawnuk bratanicy",
"praprapraprapraprawnuk bratanicy",
"prapraprapraprapraprawnuk bratanicy",
"praprapraprapraprapraprawnuk bratanicy",
]
_nephew_level_of_sisters_son = [ "", "siostrzeniec",
"syn siostrzeńca",
"wnuk siostrzeńca",
"prawnuk siostrzeńca",
"praprawnuk siostrzeńca",
"prapraprawnuk siostrzeńca",
"praprapraprawnuk siostrzeńca",
"prapraprapraprawnuk siostrzeńca",
"praprapraprapraprawnuk siostrzeńca",
"prapraprapraprapraprawnuk siostrzeńca",
]
_nephew_level_of_sisters_daughter = [ "", "siostrzenica",
"syn siostrzenicy",
"wnuk siostrzenicy",
"prawnuk siostrzenicy",
"praprawnuk siostrzenicy",
"prapraprawnuk siostrzenicy",
"praprapraprawnuk siostrzenicy",
"prapraprapraprawnuk siostrzenicy",
"praprapraprapraprawnuk siostrzenicy",
"prapraprapraprapraprawnuk siostrzenicy",
]
_niece_level_of_brothers_son = [ "", "bratanica",
"córka bratanka",
"wnuczka bratanka",
"prawnuczka bratanka",
"praprawnuczka bratanka",
"prapraprawnuczka bratanka",
"praprapraprawnuczka bratanka",
"prapraprapraprawnuczka bratanka",
"praprapraprapraprawnuczka bratanka",
]
_niece_level_of_brothers_daughter = [ "", "bratanica",
"córka bratanicy",
"wnuczka bratanicy",
"prawnuczka bratanicy",
"praprawnuczka bratanicy",
"prapraprawnuczka bratanicy",
"praprapraprawnuczka bratanicy",
"prapraprapraprawnuczka bratanicy",
"praprapraprapraprawnuczka bratanicy",
]
_niece_level_of_sisters_son = [ "", "siostrzenica",
"córka siostrzeńca",
"wnuczka siostrzeńca",
"prawnuczka siostrzeńca",
"praprawnuczka siostrzeńca",
"prapraprawnuczka siostrzeńca",
"praprapraprawnuczka siostrzeńca",
"prapraprapraprawnuczka siostrzeńca",
"praprapraprapraprawnuczka siostrzeńca",
]
_niece_level_of_sisters_daughter = [ "", "siostrzenica",
"córka siostrzenicy",
"wnuczka siostrzenicy",
"prawnuczka siostrzenicy",
"praprawnuczka siostrzenicy",
"prapraprawnuczka siostrzenicy",
"praprapraprawnuczka siostrzenicy",
"prapraprapraprawnuczka siostrzenicy",
"praprapraprapraprawnuczka siostrzenicy",
]
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
class RelationshipCalculator(Relationship.RelationshipCalculator):
def __init__(self):
Relationship.RelationshipCalculator.__init__(self)
#--------------------------------------------------
#
#
#
#--------------------------------------------------
def get_son(self, level, inlaw=''):
"""
Podaje tekst zawierający informację, jak bardzo potomek męski
(np. syn) jest spokrewniony do danej osoby
"""
# Określ, czy osoba jest przybraną, czy rodzoną
if inlaw == '':
t_inlaw =""
else:
t_inlaw ="przybrany "
# TODO: dodać rozpoznawanie pasierb/pasierbica
if level >= 0 and level < len(_son_level):
return t_inlaw +_son_level[level]
elif level >= len(_son_level) \
and (level - 1) < len(_level_name):
return t_inlaw + \
"potomek męski %s pokolenia" % _level_name[level - 1]
else:
return t_inlaw + \
"potomek męski w %d pokoleniu" % level
def get_daughter(self, level, inlaw=''):
"""
Podaje tekst zawierający informację, jak bardzo potomek żeński
(np. córka) jest spokrewniony do danej osoby
"""
# Określ, czy osoba jest przybraną, czy rodzoną
# + stwórz obie formy (męską i żeńską)
if inlaw == '':
t_inlaw =""
t_inlawM =""
else:
t_inlaw ="przybrana "
t_inlawM ="przybrany "
# TODO: dodać rozpoznawanie pasierb/pasierbica
if level >= 0 and level < len(_daughter_level):
return t_inlaw + _daughter_level[level]
elif level >= len(_daughter_level) \
and (level - 1) < len(_level_name):
return t_inlawM + \
"potomek żeński %s pokolenia" % _level_name[level - 1]
else:
return t_inlawM + \
"potomek żeński w %d pokoleniu" % level
def get_child_unknown(self, level, inlaw=''):
"""
Podaje tekst zawierający informację, jak bardzo potomek
o nieokreślonej płci jest spokrewniony dodanej osoby
"""
# Określ, czy osoba jest przybraną, czy rodzoną
if inlaw == '':
t_inlaw =""
else:
t_inlaw ="przybrany "
if level == 1:
if inlaw == '' :
return "dziecko"
else:
return "przybrane dziecko"
elif level >= 1 and (level - 1) < len(_level_name):
return t_inlaw + "potomek %s pokolenia" % _level_name[level - 1]
else:
return t_inlaw + "potomek w %d pokoleniu" % level
def get_sword_distaff(self, level, reltocommon, spacebefore = ""):
"""
PL: Generuje relację po mieczu/po kądzieli
EN: Generate relation 'by sword' or 'by distaff', polish specific
"""
if level <=1:
return ""
elif level == 2:
# dziadek/babcia
if reltocommon[0] == self.REL_FATHER:
# ze strony rodzonego ojca
return spacebefore + "po mieczu"
elif reltocommon[0] == self.REL_MOTHER:
# ze strony rodzonej matki
return spacebefore + "po kądzieli"
else:
# relacja inna niż rodzona
return ""
elif level == 3:
# pradziadek/prababcia
if (reltocommon[0] == self.REL_FATHER) \
& (reltocommon[1] == self.REL_FATHER):
# pradziadek od dziadka ze strony ojca
return spacebefore + "podwójnego miecza"
elif (reltocommon[0] == self.REL_FATHER) \
& (reltocommon[1] == self.REL_MOTHER):
# pradziadek od babci ze strony ojca
return spacebefore + "raz po mieczu, dalej po kądzieli"
elif (reltocommon[0] == self.REL_MOTHER) \
& (reltocommon[1] == self.REL_FATHER):
# pradziadek od dziadka ze strony matki
return spacebefore + "raz po kądzieli, dalej po mieczu"
elif (reltocommon[0] == self.REL_MOTHER) \
& (reltocommon[1] == self.REL_MOTHER):
# pradziadek od babci ze strony matki
return spacebefore + "podwójnej kądzieli"
else:
# relacja inna niż rodzona
return ""
elif level == 4:
# prapradziadek/praprababcia
if (reltocommon[0] == self.REL_FATHER) \
& (reltocommon[1] == self.REL_FATHER) \
& (reltocommon[2] == self.REL_FATHER):
# tzw. linia męska
return spacebefore + "potrójnego miecza"
if (reltocommon[0] == self.REL_FATHER) \
& (reltocommon[1] == self.REL_FATHER) \
& (reltocommon[2] == self.REL_FATHER):
# tzw. linia żeńska
return spacebefore + "potrójnego miecza"
else:
return ""
else:
return ""
def get_father(self, level, reltocommon, inlaw=''):
"""
Podaje tekst zawierający informację, jak bardzo przodek męski
(np. ojciec) jest spokrewniony do danej osoby
"""
if inlaw == '':
t_inlaw =""
else:
t_inlaw ="przybrany "
if level >= 0 and level < len(_father_level):
# Jeśli znasz bezpośrednią nazwę relacji, to ją zastosuj
if level == 1:
# ojciec
return t_inlaw + _father_level[level]
elif (level >= 2) & (level <= 4):
# dziadek, pradziadek, prapradziadek
return t_inlaw + _father_level[level] \
+ self.get_sword_distaff(level, reltocommon, ' ')
else:
return t_inlaw + _father_level[level]
elif level >= len(_father_level) \
and (level - 1) < len(_level_name):
# jeśli istnieje liczebnik dla danej liczby
return t_inlaw + \
"przodek męski %s pokolenia" % (_level_name[level - 1])
else:
# dla pozostałych przypadków wypisz relację liczbowo
return t_inlaw + \
"przodek męski w %d pokoleniu" % level
def get_mother(self, level, reltocommon, inlaw=''):
"""
Podaje tekst zawierający informację, jak bardzo przodek żeński
(np. matka) jest spokrewniony do danej osoby
"""
if inlaw == '':
t_inlaw =""
else:
t_inlaw ="przybrana "
if level >= 0 and level < len(_mother_level):
# Jeśli znasz bezpośrednią nazwę relacji, to ją zastosuj
if level == 1:
# matka
return t_inlaw + _mother_level[level]
elif (level >= 2) & (level <= 4):
# babcia, prababcia, praprababcia
return t_inlaw + _mother_level[level] \
+ self.get_sword_distaff(level, reltocommon, ' ')
else:
return t_inlaw + _mother_level[level]
elif level >= len(_mother_level) \
and (level - 1) < len(_level_name):
# jeśli istnieje liczebnik dla danej liczby
return t_inlaw + \
"przodek żeński %s pokolenia" % (_level_name[level - 1])
else:
# dla pozostałych przypadków wypisz relację liczbowo
return t_inlaw +"przodek żeński w %d pokoleniu" % level
def get_parent_unknown(self, level, inlaw=''):
"""
Podaje tekst zawierający informację, jak bardzo przodek
o nieokreślonej płci jest spokrewniony dodanej osoby
"""
if inlaw == '':
t_inlaw =""
else:
t_inlaw ="przybrany "
if level == 1:
return t_inlaw + "rodzic"
elif level > 1 and (level - 1) < len(_level_name):
if (level >= 2) & (level <= 4):
# babcia, prababcia, praprababcia
# (albo dziadek, pradziadek, prapradziadek)
tmp = t_inlaw +\
"przodek %s pokolenia" % (_level_name[level - 1])
# TODO: try to recognize a gender...
return tmp
# + self.get_sword_distaff(level, reltocommon, ' ')
else:
return t_inlaw + \
"przodek %s pokolenia" % (_level_name[level - 1])
else:
return t_inlaw +"przodek w %d pokoleniu" % level
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".
"""
if only_birth:
step = ''
else:
step = self.STEP
if in_law_a or in_law_b :
inlaw = self.INLAW
else:
inlaw = ''
# b is the same person as a
if Ga == 0 and Gb == 0:
rel_str = 'ta sama osoba'
elif Ga == 0:
# b is son/descendant of a
if gender_b == gen.lib.Person.MALE:
if inlaw and Gb == 1 and not step:
rel_str = "zięć"
else:
rel_str = self.get_son(Gb, inlaw)
elif gender_b == gen.lib.Person.FEMALE:
if inlaw and Gb == 1 and not step:
rel_str = "synowa"
else:
rel_str = self.get_daughter(Gb, inlaw)
else:
rel_str = self.get_child_unknown(Gb, inlaw)
elif Gb == 0:
# b is parent/grand parent of a
if gender_b == gen.lib.Person.MALE:
if inlaw and Gb == 1 and not step:
# TODO: znaleźć odpowiedniki w zależności czy to syn/córka
rel_str = "teść"
else:
rel_str = self.get_father(Ga, reltocommon_a, inlaw)
elif gender_b == gen.lib.Person.FEMALE:
if inlaw and Gb == 1 and not step:
# TODO: znaleźć odpowiedniki w zależności czy to syn/córka
rel_str = "teściowa"
else:
rel_str = self.get_mother(Ga, reltocommon_a, inlaw)
else:
rel_str = self.get_parent_unknown(Ga, inlaw)
elif Ga == 1 and Gb == 1:
# rodzeństwo
if gender_b == gen.lib.Person.MALE:
if inlaw and not step:
rel_str = "brat przyrodni"
else:
rel_str = "brat rodzony"
elif gender_b == gen.lib.Person.FEMALE:
if inlaw and not step:
rel_str = "siostra przyrodnia"
else:
rel_str = "siostra rodzony"
else:
rel_str = "brat/siostra"
elif Gb == 1 and Ga > 1:
# Przyjmij, że nie rozróżniamy osób prawnie i nieprawnie przybranych...
if Ga == 2:
# rodzeństwo rodziców
# brat ojca, czyli stryj
if (gender_b == gen.lib.Person.MALE) \
& (reltocommon_a[0] == self.REL_FATHER):
rel_str = "stryj"
# siostra ojca, czyli ciotka ???
elif (gender_b == gen.lib.Person.FEMALE) \
& (reltocommon_a[0] == self.REL_FATHER):
rel_str = "ciotka (tzw. stryjna)"
# brat matki, czyli wuj/wujek
elif (gender_b == gen.lib.Person.MALE) \
& (reltocommon_a[0] == self.REL_MOTHER):
rel_str = "wuj (wujek)"
# siostra matki, czyli ciotka
elif (gender_b == gen.lib.Person.FEMALE) \
& (reltocommon_a[0] == self.REL_MOTHER):
rel_str = "ciotka"
else:
rel_str = "brat lub siostra rodzica"
elif Ga == 3:
# rodzeństwo dziadków rodziców osoby sprawdzanej
# rodzeństwo dziadka po mieczu (ojca ojca)
if (reltocommon_a[0] == self.REL_FATHER) \
& (reltocommon_a[1] == self.REL_FATHER):
if (gender_b == gen.lib.Person.MALE):
rel_str = "dziadek stryjeczny (tzw przestryj, stary stryj)"
elif (gender_b == gen.lib.Person.FEMALE):
rel_str = "babcia stryjeczna"
else:
rel_str = "rodzeństwo przodka w 2 pokoleniu"
# rodzeństwo babki po mieczu (matki ojca)
elif (reltocommon_a[0] == self.REL_FATHER) \
& (reltocommon_a[1] == self.REL_MOTHER):
# TODO: Należy sprawdzić, czy w staropolszczyźnie nie ma
# dokładniejszych określeń dla tego typu relacji
# TODO: EN: Try to check, whether in old polish language
# are more specific word for this kind of relation
if (gender_b == gen.lib.Person.MALE):
rel_str = "dziadek stryjeczny (tzw przestryj, stary stryj)"
elif (gender_b == gen.lib.Person.FEMALE):
rel_str = "babcia stryjeczna"
else:
rel_str = "rodzeństwo przodka w 2 pokoleniu"
# rodzeństwo dziadka po kądzieli (ojca matki)
elif (reltocommon_a[0] == self.REL_MOTHER) \
& (reltocommon_a[1] == self.REL_FATHER):
# TODO: Należy sprawdzić, czy w staropolszczyźnie nie ma
# dokładniejszych określeń dla tego typu relacji
# TODO: EN: Try to check, whether in old polish language
# are more specific word for this kind of relation
if (gender_b == gen.lib.Person.MALE):
rel_str = "dziadek cioteczny (starop. prapociot)"
elif (gender_b == gen.lib.Person.FEMALE):
rel_str = "babcia cioteczna (starop. praciota)"
else:
rel_str = "rodzeństwo przodka w 2 pokoleniu"
# rodzeństwo babki po kądzieli (matki matki)
elif (reltocommon_a[0] == self.REL_MOTHER) \
& (reltocommon_a[1] == self.REL_MOTHER):
# TODO: Należy sprawdzić, czy w staropolszczyźnie nie ma
# dokładniejszych określeń dla tego typu relacji
# TODO: EN: Try to check, whether in old polish language
# are more specific word for this kind of relation
if (gender_b == gen.lib.Person.MALE):
rel_str = "dziadek cioteczny (starop. prapociot)"
elif (gender_b == gen.lib.Person.FEMALE):
rel_str = "babcia cioteczna (starop. praciota)"
else:
rel_str = "rodzeństwo przodka w 2 pokoleniu"
else:
if (gender_b == gen.lib.Person.MALE):
rel_str = "rodzeństwo dziadka"
elif (gender_b == gen.lib.Person.FEMALE):
rel_str = "rodzeństwo babci"
else:
rel_str = "rodzeństwo przodka w 2 pokoleniu"
elif Ga > 3:
# pradziadkowie... (grandparents)
if (gender_b == gen.lib.Person.MALE) \
& (reltocommon_a[0] == self.REL_FATHER):
if Ga >= 0 and Ga < len(_brother_level_of_male):
rel_str = _brother_level_of_male[Ga]
else:
rel_str = "rodzeństwo przodka męskiego %d pokolenia" % Ga
elif (gender_b == gen.lib.Person.FEMALE) \
& (reltocommon_a[0] == self.REL_FATHER):
if Ga >= 0 and Ga < len(_sister_level_of_male):
rel_str = _sister_level_of_male[Ga]
else:
rel_str = "rodzeństwo przodka żeńskiego %d pokolenia" % Ga
elif (gender_b == gen.lib.Person.MALE) \
& (reltocommon_a[0] == self.REL_MOTHER):
if Ga >= 0 and Ga < len(_brother_level_of_female):
rel_str = _brother_level_of_male[Ga]
else:
rel_str = "rodzeństwo przodka męskiego %d pokolenia" % Ga
elif (gender_b == gen.lib.Person.FEMALE) \
& (reltocommon_a[0] == self.REL_MOTHER):
if Ga >= 0 and Ga < len(_sister_level_of_female):
rel_str = _sister_level_of_male[Ga]
else:
rel_str = "rodzeństwo przodka żeńskiego %d pokolenia" % Ga
else:
rel_str = "rodzeństwo przodka %d pokolenia" % Ga
else:
# A program should never goes there, but...
rel_str = "Relacja nie określona"
elif Ga ==1 and Gb > 1:
# syn brata
if (gender_b == gen.lib.Person.MALE) \
& (reltocommon_b[0] == self.REL_FATHER):
if Gb < len(_nephew_level_of_brothers_son):
rel_str = _nephew_level_of_brothers_son[Gb]
else:
rel_str = "męski potomek w %d pokoleniu brata" % Gb
# córka brata
elif (gender_b == gen.lib.Person.FEMALE) \
& (reltocommon_b[0] == self.REL_FATHER):
if Gb < len(_nephew_level_of_brothers_daughter):
rel_str = _nephew_level_of_brothers_daughter[Gb]
else:
rel_str = "żeński potomek w %d pokoleniu brata" % Gb
# syn siostry
if (gender_b == gen.lib.Person.MALE) \
& (reltocommon_b[0] == self.REL_MOTHER):
if Gb < len(_nephew_level_of_sisters_son):
rel_str = _nephew_level_of_sisters_son[Gb]
else:
rel_str = "męski potomek w %d pokoleniu brata" % Gb
# córka siostry
elif (gender_b == gen.lib.Person.FEMALE) \
& (reltocommon_b[0] == self.REL_MOTHER):
if Gb < len(_nephew_level_of_sisters_daughter):
rel_str = _nephew_level_of_sisters_daughter[Gb]
else:
rel_str = "żeński potomek w %d pokoleniu brata" % Gb
# potomek brata
elif (reltocommon_b[0] == self.REL_FATHER):
rel_str = "potomek w %d pokoleniu brata" % Gb
# potomek brata
elif (reltocommon_b[0] == self.REL_MOTHER):
rel_str = "potomek w %d pokoleniu brata" % Gb
else :
rel_str = "potomek w %d pokoleniu rodzeństwa" % Gb
elif Ga > 1 and Gb > 1:
if (gender_b == gen.lib.Person.MALE):
if Ga==2 and Gb==2:
rel_str = "kuzyn"
else:
rel_str = "daleki kuzyn (%d. stopień pokrewieństwa)" % (Ga+Gb)
elif (gender_b == gen.lib.Person.FEMALE):
if Ga==2 and Gb==2:
rel_str = "kuzynka"
else:
rel_str = "daleka kuzynka (%d. stopień pokrewieństwa)" % (Ga+Gb)
else:
if Ga==2 and Gb==2:
rel_str = "kuzyn(ka)"
else:
rel_str = "daleki członek rodziny (%d. stopień pokrewieństwa)" % (Ga+Gb)
else:
# A program should never goes there, but...
rel_str ="nieokreślony stopień pokrewieństwa"
return rel_str
def get_sibling_relationship_string(self, sib_type, gender_a, gender_b,
in_law_a=False, in_law_b=False):
if in_law_a or in_law_b :
inlaw = self.INLAW
else:
inlaw = ''
if sib_type == self.NORM_SIB:
if not inlaw:
if gender_b == gen.lib.Person.MALE:
rel_str = 'brat (rodzony)'
elif gender_b == gen.lib.Person.FEMALE:
rel_str = 'siostra (rodzona)'
else:
rel_str = 'brat lub siostra (rodzeni)'
else:
if gender_b == gen.lib.Person.MALE:
# TODO: znaleźć odpowiednik
rel_str = "brat (pasierb)"
elif gender_b == gen.lib.Person.FEMALE:
# TODO: znaleźć odpowiednik
rel_str = "siostra (pasierbica)"
else:
# TODO: znaleźć odpowiednik
rel_str = "brat lub siostra (pasierb/pasierbica)"
elif sib_type == self.UNKNOWN_SIB:
if not inlaw:
if gender_b == gen.lib.Person.MALE:
rel_str = 'brat'
elif gender_b == gen.lib.Person.FEMALE:
rel_str = 'siostra'
else:
rel_str = 'brat lub siostra'
else:
if gender_b == gen.lib.Person.MALE:
# TODO: znaleźć odpowiednik
rel_str = "brat (brat/szwagier)"
elif gender_b == gen.lib.Person.FEMALE:
# TODO: znaleźć odpowiednik
rel_str = "siostra (bratowa/szwagierka)"
else:
# TODO: znaleźć odpowiednik
rel_str = "brat lub siostra (szwagier/szagierka)"
elif sib_type == self.HALF_SIB_FATHER:
if gender_b == gen.lib.Person.MALE:
rel_str = "brat przyrodni"
elif gender_b == gen.lib.Person.FEMALE:
rel_str = "siostra przyrodnia"
else:
rel_str = "brat/siostra przyrodni"
elif sib_type == self.HALF_SIB_MOTHER:
if gender_b == gen.lib.Person.MALE:
rel_str = "brat przyrodni"
elif gender_b == gen.lib.Person.FEMALE:
rel_str = "siostra przyrodnia"
else:
rel_str = "brat/siostra przyrodni"
elif sib_type == self.STEP_SIB:
if gender_b == gen.lib.Person.MALE:
rel_str = "brat przyrodni"
elif gender_b == gen.lib.Person.FEMALE:
rel_str = "siostra przyrodnia"
else:
rel_str = "brat lub siostra przyrodnia"
else:
rel_str = "nieokreślona relacja rodzeństwa"
return rel_str
#-------------------------------------------------------------------------
#
# Register this class with the Plugins system
#
#-------------------------------------------------------------------------
register_relcalc(RelationshipCalculator,
["pl", "PL", "pl_PL", "polski", "Polski",
"pl_PL.UTF-8", "pl_PL.UTF8", "pl_PL.utf-8", "pl_PL.utf8",
"pl_PL.iso-8859-2", "pl_PL.iso8859-2",
"pl_PL.cp1250", "pl_PL.cp-1250"] )
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_pl.py
"""TRANSLATORS, copy this if statement at the bottom of your
rel_xx.py module, and test your work with:
python src/plugins/rel_xx.py
"""
from Relationship import test
rc = RelationshipCalculator()
test(rc, True)
# Local variables:
# buffer-file-coding-system: utf-8
Reference in New Issue View Git Blame Copy Permalink