def AdjustEndings(forms, full_name):
# ustalam prawdopodobny jezyk, z ktorego pochodzi pelne nazwisko
lang = Lang.Language(full_name)
# przegladam formy (napisy typu: temat + | + zakonczenie)
for i in range(len(forms)):
# przegladam reguly uzgadniania
for rule in EA.Rules:
# stosuje regule uzgadniania na i-tej formie
forms[i] = Aux.ApplyRule(forms[i], rule, lang)
return forms
def ApplyParadigm(base_form, paradigm):
# usuniecie podpowiedzi (formy znormalizowane typu Locke/k, Laplace/s)
if r'/' in base_form:
base_form = base_form.split(r'/')[0]
# utworzenie tematu (pseudotematu)
stem = ''
N_sg = paradigm[0]
stem = Aux.GetStem(base_form, N_sg)
res = []
# przejrzenie wszystkich zakonczen w paradygmacie
# uwaga: do funkcji trzeba wprowadzic liste zakonczen (koncowek),
# a nie element listy Paradigms, ktory zawiera 4 podlisty (spis zakonczen form wejciowych, koncowki meskie, zenskie, nijakie, zensko-meskie)
for case in paradigm:
res.append(stem + '|' + str(case))
return res
def Decline(base_form, gender, if_person, if_alive, name_no, full_name, if_adj = False):
if not Aux.CheckIfDeclinable(base_form, ''):
return [base_form]*16
# zachowaj forme wejsciowa
raw_base_form = base_form
res = []
# Normalizacja formy wejściowej
base_form = Normalize(base_form, full_name)
# Dopasowanie paradygmatu (zestawu zakończeń)
paradigm = MatchParadigm(base_form, gender, full_name, name_no, if_adj)
# Dodanie zakończeń
res = ApplyParadigm(base_form, paradigm)
# Dopasowanie zakończeń
res = AdjustEndings(res, full_name)
# Korekta formy wejściowej (niektóre reguły mogą ją zmodyfikować)
if (raw_base_form != res[0]):
res[0] = raw_base_form
# res[0] = base_form.split(r'/')[0] if r'/' in base_form else base_form
# Korekta form synkretycznych (bierników)
res = CorrectSincretism(res, if_person, if_alive)
# Korekta form typu Jessica
res = CorrectJessica(res)
# Ostateczna korekta:
res = Proofread(res)
return res
# Inne oznaczenia:
# {} = litera niema, np. Clark{e} [wym. klark]
# [] = litera wstawna, np. An[e]ka: Anka, Anki..., ale Anek
# ^ = litera miękcząca, np. Piotr + ^e > Piotrze, Dorota + ^e > Dorocie
# > = Zmiana po zastosowaniu 1 reguły
# >> = Zmiana po zastosowaniu n reguł
# | = granica między tematem a końcówką, a dokładniej granica zjawisk dopasowania zakończeń
# *) Granica | jest przesuwana przez niektóre reguły po to, by kolejne reguły mogły zostać wykonane
# 0 = końcówka zerowa
# ~ = dowolny ciąg liter
# EPENTEZY (PRZED INNYMI REGULAMI!!!)
#######################################################
# ^[e]C|0 > |^eC, C = ń, c, r - wstawienie [e] w formach na ~eń|0, np. Kwiet^[e]ń|0 >> Kwietnia, Lip^[e]c|0 > Lipiec (z przesunięciem granicy |)*
bef = Aux.Product(['^', ''], ['[e]'], ['ń', 'c', 'r'], ['|0'])
c = ['']
aft = Aux.Product(['|^', '|'], ['e'], ['ń', 'c', 'r'], ['|'])
Rules.append([bef, c, aft])
# ^[e]ń > tń - usunięcie [e] w formach na ~eń|~, np. Kwiecień > Kwietnia, Lip^[e]c|0 > Lipca
bef = Aux.Product(['^', ''], ['[e]'], ['ń', 'c', 'r'], ['|'])
aft = Aux.Product(['|^', '|'], [''], ['ń', 'c', 'r'], ['|'])
Rules.append([bef, c, aft])
#######################################################
#######################################################
# ![e]l|0 > |!el - wstawienie [e] w formach na ~el|0, np. Dek![e]l|0 >> Dekiel (z przesunięciem granicy |)*
bef = Aux.Product(['', '!'], ['[e]'], ['l', 'ł'], ['|0'])
aft = Aux.Product(['|', '|!'], ['e'], ['l', 'ł'], ['|'])
Rules.append([bef, c, aft])
# ![e]l > l - usunięcie [e] w formach na ~el|~, np. Dek![e]la > Dekla
'iom', '$', 'iami', 'iach'
]
f = n = mf = empty
Paradigms.append([en, m, f, n, mf, af])
# 3 sm1_Cy (typ Nagy, Barany, Kodaly)
en = ['ny/!ń!', 'gy/!dź!', 'ly/!j!']
m = [
'0', 'a', 'owi', '$', 'em', 'u', 'u', 'owie', 'e', 'e', 'ów', '0', 'om',
'$', 'ami', 'ach'
]
f = n = mf = empty
Paradigms.append([en, m, f, n, mf, af])
# 4 sm1_Cio (typ Bodzio, Badoglio, Fabio, Palladio)
en = Aux.Product(['dz', 'z', 'c', 's', 'n', 'l', 'b', 'p', 'd', 't'], ['io'])
m = [
'io', 'ia', 'iowi', '$', 'iem', 'iu', 'iu', 'iowie', 'ie', 'ie', 'iów',
'i', 'iom', '$', 'iami', 'iach'
]
f = n = mf = empty
Paradigms.append([en, m, f, n, mf, af])
# 5 sm1_lj (typ Anatol, Bartłomiej, Stanley)
en = ['l', 'j']
m = [
'0', 'a', 'owi', '$', 'em', 'u', 'u', 'owie', 'e', 'e', 'ów', 'i', 'om',
'$', 'ami', 'ach'
]
f = n = mf = empty
Paradigms.append([en, m, f, n, mf, af])
import Declinator.Auxiliary as Aux
# Reguly normalizacji form wejsciowych
Rules = []
# NAZWISKA NIEODMIENNE
# Typ Dubois, Attenborough
end = Aux.Product([
'Noah', 'Hugo', 'Vigo', 'ough', 'ois', 'oit', 'oix', 'eu', 'oux', 'eau',
'ó', 'ois', 'drew', 'thew'
], [''])
c = ['en', 'fr']
nrm = Aux.Product([
'Noah', 'Hugo', 'Vigo', 'ough', 'ois', 'oit', 'oix', 'eu', 'oux', 'eau',
'ó', 'ois', 'drew', 'thew'
], ['/NDM'])
Rules.append([end, c, nrm])
# JĘZYK WĘGIERSKI
# Typ Nagy [nodź], Barany [barań], Kodaly [kodaj], Zápolya [zapoja]
end = Aux.Product(['a', 'e', 'o', 'u', 'i'], ['gy', 'ny', 'ly', 'lya'])
c = ['hu']
nrm = Aux.Product(['a', 'e', 'o', 'u', 'i'],
['gy/!dź!', 'ny/!ń!', 'ly/!j!', 'lya/!ja!'])
Rules.append([end, c, nrm])
### Typ Balazs (tylko węgierski, więc nie jest potrzebny warunek)
end = ['zs']
c = ['']
nrm = ['zs/!ż']
def MatchParadigm(base_form, gender, full_name, name_no, if_adj = False):
res = []
# Tworze liste paradygmatow
Paradigms = P.Paradigms
# Przegladam paradygmaty
for Para in Paradigms:
# Sprawdzam, zakonczenia podane w paradygmacie (pierwszy element) znajduja sie w formie wejsciwej
if Aux.IsAtEnd(base_form, Para[0]):
# Sprawdzam rodzaj gramatyczny:
# Jesli podano, ze forma wejsciowa jest rodzaju meskiego
if gender == 'm':
# Wynik to drugi element paradygmatu - zbior zakonczen meskich
res = Para[1]
# Pobieram ostatnia litere formy wejsciowej
# last_letter = base_form.split('/')[0][-1] if r'/' in base_form else base_form[-1]
last_letter = base_form[-1]
# Probuje rozpoznac jezyk pelnego nazwiska
language = Lang.Language((full_name))
# Korekta nazwisk! na -o:
# jesli polskie (slowianskie) -> paradygmat żeński (Lato, Laty jak kobieta, kobiety),
# jesli niepolskie (nieslowianskie) -> paradygmat męski (Marco Polo, Marca Pola jak ojciec, ojca)
if last_letter == 'o' and name_no == 1 and language == 'slav': # forma na -o i nazwisko i niesłowiańskie
# zwracam paradygmat zensko-meski (zenski w lp, meski w lm)
res = Para[4]
# Korekta imion i nazwisk na -e:
# jesli imię -> nieodmienne (Enrique), WYJĄTEK: Mojsze
# jesli nazwisko -> odmienne (Dante, Dantego)
elif (last_letter == 'e' or last_letter == 'é') and name_no == 0 and "Mojsze" not in base_form: # forma na -e i imię
res = Paradigms[0][1]
break
else: # wszystkie inne przypadki: zwracam paradygmat meski
res = Para[1]
break
# paradygmat zenski
elif gender == 'f':
if if_adj:
# jeśli wprowadzono informację, że forma bazowa jest przymiotnikiem
res = Para[5] # wybieram paradygmat af (przymiotnikowy żeński)
else:
# jeśli brak informacji, że forma bazowa jest przymiotnikiem
res = Para[2] # wybieram paradygmat f (rzeczownikowy żeski)
break
# paradygmat nijaki
elif gender == 'n':
res = Para[3]
break
# brak rodzaju - zwracam pierwszy paradygmat z list - paradygmat pusty (brak zakonczen)
else:
res = Paradigms[0][1]
break
# Jeśli nie znaleziono żadnego paradygmatu, funkcja zwraca paradygmat pusty (bez zakończeń)
if res == []:
res = Paradigms[0][1]
return res