def __findForSurname(self, attr_name : str, surname : str, find_shortest : bool=False) -> str:
rus = LanguageHelper.isCyrillicChar(surname[0])
res = None
for a in self.slots:
if (a.type_name == attr_name):
v = str(a.value)
if (LanguageHelper.isCyrillicChar(v[0]) != rus):
continue
if (res is None):
res = v
elif (find_shortest and (len(v) < len(res))):
res = v
return res
def __getName(self, cyr : bool) -> str:
name = None
for i in range(2):
for s in self.slots:
if (s.type_name == GeoReferent.ATTR_NAME):
v = str(s.value)
if (Utils.isNullOrEmpty(v)):
continue
if (i == 0):
if (not LanguageHelper.isCyrillicChar(v[0])):
if (cyr):
continue
elif (not cyr):
continue
if (name is None):
name = v
elif (len(name) > len(v)):
if ((len(v) < 4) and (len(name) < 10)):
pass
elif (name[len(name) - 1] == 'В'):
pass
else:
name = v
elif ((len(name) < 4) and len(v) >= 4 and (len(v) < 10)):
name = v
if (name is not None):
break
if (name == "МОЛДОВА"):
name = "МОЛДАВИЯ"
elif (name == "БЕЛАРУСЬ"):
name = "БЕЛОРУССИЯ"
return Utils.ifNotNull(name, "?")
def toString(self,
short_variant: bool,
lang: 'MorphLang' = None,
lev: int = 0) -> str:
res = io.StringIO()
str0_ = None
for s in self.slots:
if (s.type_name == WeaponReferent.ATTR_TYPE):
n = s.value
if (str0_ is None or (len(n) < len(str0_))):
str0_ = n
if (str0_ is not None):
print(str0_.lower(), end="", file=res)
str0_ = self.getStringValue(WeaponReferent.ATTR_BRAND)
if ((str0_) is not None):
print(" {0}".format(
MiscHelper.convertFirstCharUpperAndOtherLower(str0_)),
end="",
file=res,
flush=True)
str0_ = self.getStringValue(WeaponReferent.ATTR_MODEL)
if ((str0_) is not None):
print(" {0}".format(str0_), end="", file=res, flush=True)
str0_ = self.getStringValue(WeaponReferent.ATTR_NAME)
if ((str0_) is not None):
print(" \"{0}\"".format(
MiscHelper.convertFirstCharUpperAndOtherLower(str0_)),
end="",
file=res,
flush=True)
for s in self.slots:
if (s.type_name == WeaponReferent.ATTR_NAME and str0_ !=
(s.value)):
if (LanguageHelper.isCyrillicChar(str0_[0]) !=
LanguageHelper.isCyrillicChar((s.value)[0])):
print(" ({0})".format(
MiscHelper.convertFirstCharUpperAndOtherLower(
s.value)),
end="",
file=res,
flush=True)
break
str0_ = self.getStringValue(WeaponReferent.ATTR_NUMBER)
if ((str0_) is not None):
print(", номер {0}".format(str0_), end="", file=res, flush=True)
return Utils.toStringStringIO(res)
def __correctModel(self) -> None:
tt = self.end_token.next0_
if (tt is None or tt.whitespaces_before_count > 2):
return
if (tt.isValue(":\\/.", None) or tt.is_hiphen):
tt = tt.next0_
if (isinstance(tt, NumberToken)):
tmp = io.StringIO()
print((tt).value, end="", file=tmp)
is_lat = LanguageHelper.isLatinChar(self.value[0])
self.end_token = tt
tt = tt.next0_
first_pass3157 = True
while True:
if first_pass3157: first_pass3157 = False
else: tt = tt.next0_
if (not (tt is not None)): break
if ((isinstance(tt, TextToken)) and tt.length_char == 1
and tt.chars.is_letter):
if (not tt.is_whitespace_before or
((tt.previous is not None and tt.previous.is_hiphen))):
ch = (tt).term[0]
self.end_token = tt
ch2 = chr(0)
if (LanguageHelper.isLatinChar(ch) and not is_lat):
ch2 = LanguageHelper.getCyrForLat(ch)
if (ch2 != (chr(0))):
ch = ch2
elif (LanguageHelper.isCyrillicChar(ch) and is_lat):
ch2 = LanguageHelper.getLatForCyr(ch)
if (ch2 != (chr(0))):
ch = ch2
print(ch, end="", file=tmp)
continue
break
self.value = "{0}-{1}".format(self.value,
Utils.toStringStringIO(tmp))
self.alt_value = MiscHelper.createCyrLatAlternative(self.value)
if (not self.end_token.is_whitespace_after
and self.end_token.next0_ is not None
and ((self.end_token.next0_.is_hiphen
or self.end_token.next0_.isCharOf("\\/")))):
if (not self.end_token.next0_.is_whitespace_after and
(isinstance(self.end_token.next0_.next0_, NumberToken))):
self.end_token = self.end_token.next0_.next0_
self.value = "{0}-{1}".format(self.value,
(self.end_token).value)
if (self.alt_value is not None):
self.alt_value = "{0}-{1}".format(self.alt_value,
(self.end_token).value)
def correctWordByMorph(self, word: str, lang: 'MorphLang') -> str:
if (LanguageHelper.isCyrillicChar(word[0])):
if (lang is not None):
if (InnerMorphology.M_ENGINE_RU.language.is_ru and lang.is_ru):
return InnerMorphology.M_ENGINE_RU.correctWordByMorph(word)
if (InnerMorphology.M_ENGINE_UA.language.is_ua and lang.is_ua):
return InnerMorphology.M_ENGINE_UA.correctWordByMorph(word)
if (InnerMorphology.M_ENGINE_BY.language.is_by and lang.is_by):
return InnerMorphology.M_ENGINE_BY.correctWordByMorph(word)
if (InnerMorphology.M_ENGINE_KZ.language.is_kz and lang.is_kz):
return InnerMorphology.M_ENGINE_KZ.correctWordByMorph(word)
return InnerMorphology.M_ENGINE_RU.correctWordByMorph(word)
else:
return InnerMorphology.M_ENGINE_EN.correctWordByMorph(word)
def getAllWordforms(self, word: str,
lang: 'MorphLang') -> typing.List['MorphWordForm']:
if (LanguageHelper.isCyrillicChar(word[0])):
if (lang is not None):
if (InnerMorphology.M_ENGINE_RU.language.is_ru and lang.is_ru):
return InnerMorphology.M_ENGINE_RU.getAllWordforms(word)
if (InnerMorphology.M_ENGINE_UA.language.is_ua and lang.is_ua):
return InnerMorphology.M_ENGINE_UA.getAllWordforms(word)
if (InnerMorphology.M_ENGINE_BY.language.is_by and lang.is_by):
return InnerMorphology.M_ENGINE_BY.getAllWordforms(word)
if (InnerMorphology.M_ENGINE_KZ.language.is_kz and lang.is_kz):
return InnerMorphology.M_ENGINE_KZ.getAllWordforms(word)
return InnerMorphology.M_ENGINE_RU.getAllWordforms(word)
else:
return InnerMorphology.M_ENGINE_EN.getAllWordforms(word)
def getWordform(self, word: str, cla: 'MorphClass', gender: 'MorphGender',
cas: 'MorphCase', num: 'MorphNumber', lang: 'MorphLang',
add_info: 'MorphWordForm') -> str:
if (LanguageHelper.isCyrillicChar(word[0])):
if (InnerMorphology.M_ENGINE_RU.language.is_ru and lang.is_ru):
return InnerMorphology.M_ENGINE_RU.getWordform(
word, cla, gender, cas, num, add_info)
if (InnerMorphology.M_ENGINE_UA.language.is_ua and lang.is_ua):
return InnerMorphology.M_ENGINE_UA.getWordform(
word, cla, gender, cas, num, add_info)
if (InnerMorphology.M_ENGINE_BY.language.is_by and lang.is_by):
return InnerMorphology.M_ENGINE_BY.getWordform(
word, cla, gender, cas, num, add_info)
if (InnerMorphology.M_ENGINE_KZ.language.is_kz and lang.is_kz):
return InnerMorphology.M_ENGINE_KZ.getWordform(
word, cla, gender, cas, num, add_info)
return InnerMorphology.M_ENGINE_RU.getWordform(
word, cla, gender, cas, num, add_info)
else:
return InnerMorphology.M_ENGINE_EN.getWordform(
word, cla, gender, cas, num, add_info)
def setShortestCanonicalText(self,
ignore_termins_with_notnull_tags: bool = False
) -> None:
""" В качестве канонического текста установить самый короткий среди терминов
Args:
ignore_termins_with_notnull_tags(bool):
"""
self.__m_canonic_text = (None)
for t in self.termins:
if (ignore_termins_with_notnull_tags and t.tag is not None):
continue
if (len(t.terms) == 0):
continue
s = t.canonic_text
if (not LanguageHelper.isCyrillicChar(s[0])):
continue
if (self.__m_canonic_text is None):
self.__m_canonic_text = s
elif (len(s) < len(self.__m_canonic_text)):
self.__m_canonic_text = s
def process(self, word : str) -> typing.List['MorphWordForm']:
""" Обработка одного слова
Args:
word(str): слово должно быть в верхнем регистре
"""
if (Utils.isNullOrEmpty(word)):
return None
res = None
if (len(word) > 1):
i = 0
while i < len(word):
ch = word[i]
if (LanguageHelper.isCyrillicVowel(ch) or LanguageHelper.isLatinVowel(ch)):
break
i += 1
if (i >= len(word)):
return res
mvs = [ ]
tn = self.m_root
i = 0
while i <= len(word):
if (tn.lazy_pos > 0):
self.__loadTreeNode(tn)
if (tn.rules is not None):
word_begin = None
word_end = None
if (i == 0):
word_end = word
elif (i < len(word)):
word_end = word[i:]
else:
word_end = ""
if (res is None):
res = list()
for r in tn.rules:
wrapmvs14 = RefOutArgWrapper(None)
inoutres15 = Utils.tryGetValue(r.variants, word_end, wrapmvs14)
mvs = wrapmvs14.value
if (inoutres15):
if (word_begin is None):
if (i == len(word)):
word_begin = word
elif (i > 0):
word_begin = word[0:0+i]
else:
word_begin = ""
r.processResult(res, word_begin, mvs)
if (tn.nodes is None or i >= len(word)):
break
ch = ord(word[i])
wraptn16 = RefOutArgWrapper(None)
inoutres17 = Utils.tryGetValue(tn.nodes, ch, wraptn16)
tn = wraptn16.value
if (not inoutres17):
break
i += 1
need_test_unknown_vars = True
if (res is not None):
for r in res:
if ((r.class0_.is_pronoun or r.class0_.is_noun or r.class0_.is_adjective) or (r.class0_.is_misc and r.class0_.is_conjunction) or r.class0_.is_preposition):
need_test_unknown_vars = False
elif (r.class0_.is_adverb and r.normal_case is not None):
if (not LanguageHelper.endsWithEx(r.normal_case, "О", "А", None, None)):
need_test_unknown_vars = False
elif (r.normal_case == "МНОГО"):
need_test_unknown_vars = False
elif (r.class0_.is_verb and len(res) > 1):
ok = False
for rr in res:
if (rr != r and rr.class0_ != r.class0_):
ok = True
break
if (ok and not LanguageHelper.endsWith(word, "ИМ")):
need_test_unknown_vars = False
if (need_test_unknown_vars and LanguageHelper.isCyrillicChar(word[0])):
gl = 0
sog = 0
j = 0
while j < len(word):
if (LanguageHelper.isCyrillicVowel(word[j])):
gl += 1
else:
sog += 1
j += 1
if ((gl < 2) or (sog < 2)):
need_test_unknown_vars = False
if (need_test_unknown_vars and res is not None and len(res) == 1):
if (res[0].class0_.is_verb):
if ("н.вр." in res[0].misc.attrs and "нес.в." in res[0].misc.attrs and not "страд.з." in res[0].misc.attrs):
need_test_unknown_vars = False
elif ("б.вр." in res[0].misc.attrs and "сов.в." in res[0].misc.attrs):
need_test_unknown_vars = False
elif (res[0].normal_case is not None and LanguageHelper.endsWith(res[0].normal_case, "СЯ")):
need_test_unknown_vars = False
if (res[0].class0_.is_undefined and "прдктв." in res[0].misc.attrs):
need_test_unknown_vars = False
if (need_test_unknown_vars):
if (self.m_root_reverce is None):
return res
tn = self.m_root_reverce
tn0 = None
for i in range(len(word) - 1, -1, -1):
if (tn.lazy_pos > 0):
self.__loadTreeNode(tn)
ch = ord(word[i])
if (tn.nodes is None):
break
wrapnext18 = RefOutArgWrapper(None)
inoutres19 = Utils.tryGetValue(tn.nodes, ch, wrapnext18)
next0_ = wrapnext18.value
if (not inoutres19):
break
tn = next0_
if (tn.lazy_pos > 0):
self.__loadTreeNode(tn)
if (tn.reverce_variants is not None):
tn0 = tn
break
else: i = -1
if (tn0 is not None):
glas = i < 4
while i >= 0:
if (LanguageHelper.isCyrillicVowel(word[i]) or LanguageHelper.isLatinVowel(word[i])):
glas = True
break
i -= 1
if (glas):
for mv in tn0.reverce_variants:
if (((not mv.class0_.is_verb and not mv.class0_.is_adjective and not mv.class0_.is_noun) and not mv.class0_.is_proper_surname and not mv.class0_.is_proper_geo) and not mv.class0_.is_proper_secname):
continue
ok = False
for rr in res:
if (rr.is_in_dictionary):
if (rr.class0_ == mv.class0_ or rr.class0_.is_noun):
ok = True
break
if (not mv.class0_.is_adjective and rr.class0_.is_verb):
ok = True
break
if (ok):
continue
if (len(mv.tail) > 0 and not LanguageHelper.endsWith(word, mv.tail)):
continue
r = MorphWordForm(mv, word)
if (not MorphWordForm._hasMorphEquals(res, r)):
r.undef_coef = mv.coef
if (res is None):
res = list()
res.append(r)
if (word == "ПРИ" and res is not None):
for i in range(len(res) - 1, -1, -1):
if (res[i].class0_.is_proper_geo):
del res[i]
else: i = -1
if (res is None or len(res) == 0):
return None
MorphEngine.__sort(res, word)
for v in res:
if (v.normal_case is None):
v.normal_case = word
if (v.class0_.is_verb):
if (v.normal_full is None and LanguageHelper.endsWith(v.normal_case, "ТЬСЯ")):
v.normal_full = v.normal_case[0:0+len(v.normal_case) - 2]
v.language = self.language
if (v.class0_.is_preposition):
v.normal_case = LanguageHelper.normalizePreposition(v.normal_case)
mc = MorphClass()
for i in range(len(res) - 1, -1, -1):
if (not res[i].is_in_dictionary and res[i].class0_.is_adjective and len(res) > 1):
if ("к.ф." in res[i].misc.attrs or "неизм." in res[i].misc.attrs):
del res[i]
continue
if (res[i].is_in_dictionary):
mc.value |= res[i].class0_.value
else: i = -1
if (mc == MorphClass.VERB and len(res) > 1):
for r in res:
if (r.undef_coef > (100) and r.class0_ == MorphClass.ADJECTIVE):
r.undef_coef = (0)
if (len(res) == 0):
return None
return res
def toString(self,
short_variant: bool,
lang: 'MorphLang',
lev: int = 0) -> str:
res = io.StringIO()
str0_ = None
for s in self.slots:
if (s.type_name == TransportReferent.ATTR_TYPE):
n = s.value
if (str0_ is None or (len(n) < len(str0_))):
str0_ = n
if (str0_ is not None):
print(str0_, end="", file=res)
elif (self.kind == TransportKind.AUTO):
print("автомобиль", end="", file=res)
elif (self.kind == TransportKind.FLY):
print("самолет", end="", file=res)
elif (self.kind == TransportKind.SHIP):
print("судно", end="", file=res)
elif (self.kind == TransportKind.SPACE):
print("космический корабль", end="", file=res)
else:
print(Utils.enumToString(self.kind), end="", file=res)
str0_ = self.getStringValue(TransportReferent.ATTR_BRAND)
if ((str0_) is not None):
print(" {0}".format(
MiscHelper.convertFirstCharUpperAndOtherLower(str0_)),
end="",
file=res,
flush=True)
str0_ = self.getStringValue(TransportReferent.ATTR_MODEL)
if ((str0_) is not None):
print(" {0}".format(
MiscHelper.convertFirstCharUpperAndOtherLower(str0_)),
end="",
file=res,
flush=True)
str0_ = self.getStringValue(TransportReferent.ATTR_NAME)
if ((str0_) is not None):
print(" \"{0}\"".format(
MiscHelper.convertFirstCharUpperAndOtherLower(str0_)),
end="",
file=res,
flush=True)
for s in self.slots:
if (s.type_name == TransportReferent.ATTR_NAME and str0_ !=
(s.value)):
if (LanguageHelper.isCyrillicChar(str0_[0]) !=
LanguageHelper.isCyrillicChar((s.value)[0])):
print(" ({0})".format(
MiscHelper.convertFirstCharUpperAndOtherLower(
s.value)),
end="",
file=res,
flush=True)
break
str0_ = self.getStringValue(TransportReferent.ATTR_CLASS)
if ((str0_) is not None):
print(" класса \"{0}\"".format(
MiscHelper.convertFirstCharUpperAndOtherLower(str0_)),
end="",
file=res,
flush=True)
str0_ = self.getStringValue(TransportReferent.ATTR_NUMBER)
if ((str0_) is not None):
print(", номер {0}".format(str0_), end="", file=res, flush=True)
str0_ = self.getStringValue(TransportReferent.ATTR_NUMBER_REGION)
if ((str0_) is not None):
print(str0_, end="", file=res)
if (self.findSlot(TransportReferent.ATTR_ROUTEPOINT, None, True)
is not None):
print(" (".format(), end="", file=res, flush=True)
fi = True
for s in self.slots:
if (s.type_name == TransportReferent.ATTR_ROUTEPOINT):
if (fi):
fi = False
else:
print(" - ", end="", file=res)
if (isinstance(s.value, Referent)):
print((s.value).toString(True, lang, 0),
end="",
file=res)
else:
print(s.value, end="", file=res)
print(")", end="", file=res)
if (not short_variant):
str0_ = self.getStringValue(TransportReferent.ATTR_STATE)
if ((str0_) is not None):
print("; {0}".format(str0_), end="", file=res, flush=True)
str0_ = self.getStringValue(TransportReferent.ATTR_ORG)
if ((str0_) is not None):
print("; {0}".format(str0_), end="", file=res, flush=True)
return Utils.toStringStringIO(res)
def __toFullString(self, last_name_first : bool, lang : 'MorphLang') -> str:
id0_ = None
for a in self.slots:
if (a.type_name == PersonReferent.ATTR_IDENTITY):
s = str(a.value)
if (id0_ is None or len(s) > len(id0_)):
id0_ = s
if (id0_ is not None):
return MiscHelper.convertFirstCharUpperAndOtherLower(id0_)
sss = self.getStringValue("NAMETYPE")
if (sss == "china"):
last_name_first = True
n = self.getStringValue(PersonReferent.ATTR_LASTNAME)
if (n is not None):
res = io.StringIO()
if (last_name_first):
print("{0} ".format(n), end="", file=res, flush=True)
s = self.__findForSurname(PersonReferent.ATTR_FIRSTNAME, n, False)
if (s is not None):
print("{0}".format(s), end="", file=res, flush=True)
if (PersonReferent.__isInitial(s)):
print('.', end="", file=res)
else:
print(' ', end="", file=res)
s = self.__findForSurname(PersonReferent.ATTR_MIDDLENAME, n, False)
if (s is not None):
print("{0}".format(s), end="", file=res, flush=True)
if (PersonReferent.__isInitial(s)):
print('.', end="", file=res)
else:
print(' ', end="", file=res)
if (not last_name_first):
print(n, end="", file=res)
elif (Utils.getCharAtStringIO(res, res.tell() - 1) == ' '):
Utils.setLengthStringIO(res, res.tell() - 1)
if (LanguageHelper.isCyrillicChar(n[0])):
nl = None
for sl in self.slots:
if (sl.type_name == PersonReferent.ATTR_LASTNAME):
ss = Utils.asObjectOrNull(sl.value, str)
if (len(ss) > 0 and LanguageHelper.isLatinChar(ss[0])):
nl = ss
break
if (nl is not None):
nal = self.__findForSurname(PersonReferent.ATTR_FIRSTNAME, nl, False)
if (nal is None):
print(" ({0})".format(nl), end="", file=res, flush=True)
elif (PersonReferent.SHOW_LASTNAME_ON_FIRST_POSITION):
print(" ({0} {1})".format(nl, nal), end="", file=res, flush=True)
else:
print(" ({0} {1})".format(nal, nl), end="", file=res, flush=True)
return MiscHelper.convertFirstCharUpperAndOtherLower(Utils.toStringStringIO(res))
else:
n = self.getStringValue(PersonReferent.ATTR_FIRSTNAME)
if ((n) is not None):
s = self.__findForSurname(PersonReferent.ATTR_MIDDLENAME, n, False)
if (s is not None):
n = "{0} {1}".format(n, s)
n = MiscHelper.convertFirstCharUpperAndOtherLower(n)
nik = self.getStringValue(PersonReferent.ATTR_NICKNAME)
tit = self.__findShortestKingTitul(False)
if (tit is not None):
n = "{0} {1}".format(tit, n)
if (nik is not None):
n = "{0} {1}".format(n, nik)
return n
return "?"
def parse(t: 'Token', max_char: int, prev: 'LineToken') -> 'LineToken':
from pullenti.ner.TextToken import TextToken
from pullenti.ner.NumberToken import NumberToken
from pullenti.morph.LanguageHelper import LanguageHelper
from pullenti.ner.core.BracketParseAttr import BracketParseAttr
from pullenti.ner.core.BracketHelper import BracketHelper
from pullenti.ner.decree.DecreeReferent import DecreeReferent
if (t is None or t.end_char > max_char):
return None
res = ListHelper.LineToken(t, t)
first_pass3004 = True
while True:
if first_pass3004: first_pass3004 = False
else: t = t.next0_
if (not (t is not None and t.end_char <= max_char)): break
if (t.isChar(':')):
if (res.is_newline_before and res.begin_token.isValue(
"ПРИЛОЖЕНИЕ", "ДОДАТОК")):
res.is_list_head = True
res.end_token = t
break
if (t.isChar(';')):
if (not t.is_whitespace_after):
pass
if (t.previous is not None and (isinstance(
t.previous.getReferent(), DecreeReferent))):
if (not t.is_whitespace_after):
continue
if (t.next0_ is not None and (isinstance(
t.next0_.getReferent(), DecreeReferent))):
continue
res.is_list_item = True
res.end_token = t
break
if (t.isChar('(')):
br = BracketHelper.tryParse(t, BracketParseAttr.NO, 100)
if (br is not None):
t = br.end_token
res.end_token = t
continue
if (t.is_newline_before and t != res.begin_token):
next0__ = True
if (t.previous.is_comma or t.previous.is_and
or t.isCharOf("(")):
next0__ = False
elif (t.chars.is_letter or (isinstance(t, NumberToken))):
if (t.chars.is_all_lower):
next0__ = False
elif (t.previous.chars.is_letter):
next0__ = False
if (next0__):
break
res.end_token = t
if (res.begin_token.is_hiphen):
res.is_list_item = (res.begin_token.next0_ is not None
and not res.begin_token.next0_.is_hiphen)
elif (res.begin_token.isCharOf("·")):
res.is_list_item = True
res.begin_token = res.begin_token.next0_
elif (res.begin_token.next0_ is not None
and ((res.begin_token.next0_.isChar(')') or
((prev is not None and
((prev.is_list_item or prev.is_list_head))))))):
if (res.begin_token.length_char == 1
or (isinstance(res.begin_token, NumberToken))):
res.is_list_item = True
if ((isinstance(res.begin_token, NumberToken))
and (res.begin_token).int_value is not None):
res.number = (res.begin_token).int_value
elif ((isinstance(res.begin_token, TextToken))
and res.begin_token.length_char == 1):
te = (res.begin_token).term
if (LanguageHelper.isCyrillicChar(te[0])):
res.number = ((ord(te[0])) - (ord('А')))
elif (LanguageHelper.isLatinChar(te[0])):
res.number = ((ord(te[0])) - (ord('A')))
return res
