def _deserialize(self, str0_: 'ByteArrayWrapper', pos: int) -> None:
cou = str0_.deserialize_short(pos)
while cou > 0:
it = ControlModelItem()
b = str0_.deserialize_byte(pos)
if ((((b) & 0x80)) != 0):
it.nominative_can_be_agent_and_pacient = True
it.typ = (Utils.valToEnum(((b) & 0x7F), ControlModelItemType))
if (it.typ == ControlModelItemType.WORD):
it.word = str0_.deserialize_string(pos)
licou = str0_.deserialize_short(pos)
while licou > 0:
bi = str0_.deserialize_byte(pos)
i = bi
b = str0_.deserialize_byte(pos)
if (i >= 0 and (i < len(ControlModelQuestion.ITEMS))):
it.links[ControlModelQuestion.ITEMS[i]] = Utils.valToEnum(
b, SemanticRole)
licou -= 1
self.items.append(it)
cou -= 1
cou = str0_.deserialize_short(pos)
while cou > 0:
p = str0_.deserialize_string(pos)
if (p is not None):
self.pacients.append(p)
cou -= 1
def _deserialize(self, str0_: 'ByteArrayWrapper', pos: int) -> bool:
id0__ = str0_.deserialize_short(pos)
if (id0__ <= 0):
return False
self.misc_info_id = (id0__)
iii = str0_.deserialize_short(pos)
mc = MorphClass()
mc.value = (iii)
if (mc.is_misc and mc.is_proper):
mc.is_misc = False
self.class0_ = mc
bbb = 0
bbb = str0_.deserialize_byte(pos)
self.gender = Utils.valToEnum(bbb, MorphGender)
bbb = str0_.deserialize_byte(pos)
self.number = Utils.valToEnum(bbb, MorphNumber)
bbb = str0_.deserialize_byte(pos)
mca = MorphCase()
mca.value = (bbb)
self.case_ = mca
s = str0_.deserialize_string(pos)
self.normal_tail = s
s = str0_.deserialize_string(pos)
self.full_normal_tail = s
return True
def __deserialize_item(self, stream: Stream) -> 'MorphBaseInfo':
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
ty = stream.readbyte()
res = (MorphBaseInfo() if ty == 0 else MorphWordForm())
res.class0_ = MorphClass._new53(
SerializerHelper.deserialize_short(stream))
res.case_ = MorphCase._new29(
SerializerHelper.deserialize_short(stream))
res.gender = Utils.valToEnum(
SerializerHelper.deserialize_short(stream), MorphGender)
res.number = Utils.valToEnum(
SerializerHelper.deserialize_short(stream), MorphNumber)
res.language = MorphLang._new56(
SerializerHelper.deserialize_short(stream))
if (ty == 0):
return res
wf = Utils.asObjectOrNull(res, MorphWordForm)
wf.normal_case = SerializerHelper.deserialize_string(stream)
wf.normal_full = SerializerHelper.deserialize_string(stream)
wf.undef_coef = SerializerHelper.deserialize_short(stream)
cou = SerializerHelper.deserialize_int(stream)
i = 0
while i < cou:
if (wf.misc is None):
wf.misc = MorphMiscInfo()
wf.misc.attrs.append(SerializerHelper.deserialize_string(stream))
i += 1
return res
def _hasMorphEquals(list0_: typing.List['MorphWordForm'],
mv: 'MorphWordForm') -> bool:
for mr in list0_:
if ((mv.class0_ == mr.class0_ and mv.number == mr.number
and mv.gender == mr.gender)
and mv.normal_case == mr.normal_case
and mv.normal_full == mr.normal_full):
mr.case_ = (mr.case_) | mv.case_
p = mv.misc.person
if (p != MorphPerson.UNDEFINED and p != mr.misc.person):
mr.misc = mr.misc.clone()
mr.misc.person = Utils.valToEnum(
(mr.misc.person) | (mv.misc.person), MorphPerson)
return True
for mr in list0_:
if ((mv.class0_ == mr.class0_ and mv.number == mr.number
and mv.case_ == mr.case_) and mv.normal_case == mr.normal_case
and mv.normal_full == mr.normal_full):
mr.gender = Utils.valToEnum((mr.gender) | (mv.gender),
MorphGender)
return True
for mr in list0_:
if ((mv.class0_ == mr.class0_ and mv.gender == mr.gender
and mv.case_ == mr.case_) and mv.normal_case == mr.normal_case
and mv.normal_full == mr.normal_full):
mr.number = Utils.valToEnum((mr.number) | (mv.number),
MorphNumber)
return True
return False
def __correctExtTypes(ex: 'NumberExToken') -> None:
t = ex.end_token.next0_
if (t is None):
return
ty = ex.ex_typ
wrapty480 = RefOutArgWrapper(ty)
tt = NumberExHelper.__corrExTyp2(t, wrapty480)
ty = wrapty480.value
if (tt is not None):
ex.ex_typ = ty
ex.end_token = tt
t = tt.next0_
if (t is None or t.next0_ is None):
return
if (t.isCharOf("/\\") or t.isValue("НА", None)):
pass
else:
return
tok = NumberExHelper._m_postfixes.tryParse(t.next0_,
TerminParseAttr.NO)
if (tok is not None and (((Utils.valToEnum(
tok.termin.tag, NumberExType)) != NumberExType.MONEY))):
ex.ex_typ2 = (Utils.valToEnum(tok.termin.tag, NumberExType))
ex.end_token = tok.end_token
ty = ex.ex_typ2
wrapty479 = RefOutArgWrapper(ty)
tt = NumberExHelper.__corrExTyp2(ex.end_token.next0_, wrapty479)
ty = wrapty479.value
if (tt is not None):
ex.ex_typ2 = ty
ex.end_token = tt
t = tt.next0_
def person(self) -> 'MorphPerson':
""" Лицо """
res = MorphPerson.UNDEFINED
if ("1 л." in self.__m_attrs):
res = (Utils.valToEnum((res) | (MorphPerson.FIRST), MorphPerson))
if ("2 л." in self.__m_attrs):
res = (Utils.valToEnum((res) | (MorphPerson.SECOND), MorphPerson))
if ("3 л." in self.__m_attrs):
res = (Utils.valToEnum((res) | (MorphPerson.THIRD), MorphPerson))
return res
def __getKind(self, s: str) -> 'TransportKind':
if (s is None):
return TransportKind.UNDEFINED
try:
res = Utils.valToEnum(s, TransportKind)
if (isinstance(res, TransportKind)):
return Utils.valToEnum(res, TransportKind)
except Exception as ex2549:
pass
return TransportKind.UNDEFINED
def tryParse(t : 'Token') -> 'DefinitionWithNumericToken':
""" Выделить определение с указанного токена
Args:
t(Token): токен
"""
if (not MiscHelper.canBeStartOfSentence(t)):
return None
tt = t
noun_ = None
num = None
first_pass2886 = True
while True:
if first_pass2886: first_pass2886 = False
else: tt = tt.next0_
if (not (tt is not None)): break
if (tt != t and MiscHelper.canBeStartOfSentence(tt)):
return None
if (not ((isinstance(tt, NumberToken)))):
continue
if (tt.whitespaces_after_count > 2 or tt == t):
continue
if (tt.morph.class0_.is_adjective):
continue
nn = NounPhraseHelper.tryParse(tt.next0_, NounPhraseParseAttr.NO, 0)
if (nn is None):
continue
num = (Utils.asObjectOrNull(tt, NumberToken))
noun_ = nn
break
if (num is None or num.int_value is None):
return None
res = DefinitionWithNumericToken(t, noun_.end_token)
res.number = num.int_value
res.number_begin_char = num.begin_char
res.number_end_char = num.end_char
res.noun = noun_.getNormalCaseText(None, True, MorphGender.UNDEFINED, False)
res.nouns_genetive = (Utils.ifNotNull(noun_.getMorphVariant(MorphCase.GENITIVE, True), (res.noun if res is not None else None)))
res.text = MiscHelper.getTextValue(t, num.previous, Utils.valToEnum((GetTextAttr.KEEPQUOTES) | (GetTextAttr.KEEPREGISTER), GetTextAttr))
if (num.is_whitespace_before):
res.text += " "
res.number_substring = MiscHelper.getTextValue(num, noun_.end_token, Utils.valToEnum((GetTextAttr.KEEPQUOTES) | (GetTextAttr.KEEPREGISTER), GetTextAttr))
res.text += res.number_substring
tt = noun_.end_token
while tt is not None:
if (MiscHelper.canBeStartOfSentence(tt)):
break
res.end_token = tt
tt = tt.next0_
if (res.end_token != noun_.end_token):
if (noun_.is_whitespace_after):
res.text += " "
res.text += MiscHelper.getTextValue(noun_.end_token.next0_, res.end_token, Utils.valToEnum((GetTextAttr.KEEPQUOTES) | (GetTextAttr.KEEPREGISTER), GetTextAttr))
return res
def kind2(self) -> 'InstrumentKind':
s = self.get_string_value(InstrumentBlockReferent.ATTR_KIND2)
if (s is None):
return InstrumentKind.UNDEFINED
try:
res = Utils.valToEnum(s, InstrumentKind)
if (isinstance(res, InstrumentKind)):
return Utils.valToEnum(res, InstrumentKind)
except Exception as ex1583:
pass
return InstrumentKind.UNDEFINED
def __tryParse(t: 'Token') -> 'BusinessFactItem':
tok = BusinessFactItem.__m_base_onto.tryParse(t, TerminParseAttr.NO)
if (tok is None and t.morph.class0_.is_verb and t.next0_ is not None):
tok = BusinessFactItem.__m_base_onto.tryParse(
t.next0_, TerminParseAttr.NO)
if (tok is not None):
ki = Utils.valToEnum(tok.termin.tag, BusinessFactKind)
if (ki != BusinessFactKind.UNDEFINED):
return BusinessFactItem._new402(t, tok.end_token,
BusinessFactItemTyp.BASE, ki,
tok.morph, tok.termin.tag2
is not None)
tt = tok.end_token.next0_
first_pass2765 = True
while True:
if first_pass2765: first_pass2765 = False
else: tt = tt.next0_
if (not (tt is not None)): break
if (tt.morph.class0_.is_preposition):
continue
tok = BusinessFactItem.__m_base_onto.tryParse(
tt, TerminParseAttr.NO)
if (tok is None):
continue
ki = (Utils.valToEnum(tok.termin.tag, BusinessFactKind))
if (ki != BusinessFactKind.UNDEFINED):
return BusinessFactItem._new403(t, tok.end_token,
BusinessFactItemTyp.BASE,
ki, tok.morph)
tt = tok.end_token
npt = NounPhraseHelper.tryParse(t, NounPhraseParseAttr.NO, 0)
if (npt is not None):
if (((((npt.noun.isValue("АКЦИОНЕР", None) or npt.noun.isValue(
"ВЛАДЕЛЕЦ", None) or npt.noun.isValue("ВЛАДЕЛИЦА", None))
or npt.noun.isValue("СОВЛАДЕЛЕЦ", None)
or npt.noun.isValue("СОВЛАДЕЛИЦА", None))
or npt.noun.isValue("АКЦІОНЕР", None) or npt.noun.isValue(
"ВЛАСНИК", None)) or npt.noun.isValue("ВЛАСНИЦЯ", None)
or npt.noun.isValue("СПІВВЛАСНИК", None))
or npt.noun.isValue("СПІВВЛАСНИЦЯ", None)):
return BusinessFactItem._new403(t, npt.end_token,
BusinessFactItemTyp.BASE,
BusinessFactKind.HAVE,
npt.morph)
if (npt is not None):
if ((npt.noun.isValue("ОСНОВАТЕЛЬ", None)
or npt.noun.isValue("ОСНОВАТЕЛЬНИЦА", None)
or npt.noun.isValue("ЗАСНОВНИК", None))
or npt.noun.isValue("ЗАСНОВНИЦЯ", None)):
return BusinessFactItem._new403(t, npt.end_token,
BusinessFactItemTyp.BASE,
BusinessFactKind.CREATE,
npt.morph)
return None
def kind(self) -> 'SentimentKind':
s = self.getStringValue(SentimentReferent.ATTR_KIND)
if (s is None):
return SentimentKind.UNDEFINED
try:
res = Utils.valToEnum(s, SentimentKind)
if (isinstance(res, SentimentKind)):
return Utils.valToEnum(res, SentimentKind)
except Exception as ex2497:
pass
return SentimentKind.UNDEFINED
def pointer(self) -> 'DatePointerType':
""" Дополнительный указатель примерной даты """
s = self.get_string_value(DateReferent.ATTR_POINTER)
if (s is None):
return DatePointerType.NO
try:
res = Utils.valToEnum(s, DatePointerType)
if (isinstance(res, DatePointerType)):
return Utils.valToEnum(res, DatePointerType)
except Exception as ex783:
pass
return DatePointerType.NO
def kind(self) -> 'DecreeChangeValueKind':
""" Тип значение """
s = self.getStringValue(DecreeChangeValueReferent.ATTR_KIND)
if (s is None):
return DecreeChangeValueKind.UNDEFINED
try:
res = Utils.valToEnum(s, DecreeChangeValueKind)
if (isinstance(res, DecreeChangeValueKind)):
return Utils.valToEnum(res, DecreeChangeValueKind)
except Exception as ex1083:
pass
return DecreeChangeValueKind.UNDEFINED
def detail(self) -> 'AddressDetailType':
""" ополнительная детализация места (пересечение, около ...) """
s = self.getStringValue(AddressReferent.ATTR_DETAIL)
if (s is None):
return AddressDetailType.UNDEFINED
try:
res = Utils.valToEnum(s, AddressDetailType)
if (isinstance(res, AddressDetailType)):
return Utils.valToEnum(res, AddressDetailType)
except Exception as ex342:
pass
return AddressDetailType.UNDEFINED
def kind(self) -> 'DefinitionKind':
""" Тип тезиса """
s = self.get_string_value(DefinitionReferent.ATTR_KIND)
if (s is None):
return DefinitionKind.UNDEFINED
try:
res = Utils.valToEnum(s, DefinitionKind)
if (isinstance(res, DefinitionKind)):
return Utils.valToEnum(res, DefinitionKind)
except Exception as ex1122:
pass
return DefinitionKind.UNDEFINED
def kind(self) -> 'BusinessFactKind':
""" Классификатор бизнес-факта """
s = self.getStringValue(BusinessFactReferent.ATTR_KIND)
if (s is None):
return BusinessFactKind.UNDEFINED
try:
res = Utils.valToEnum(s, BusinessFactKind)
if (isinstance(res, BusinessFactKind)):
return Utils.valToEnum(res, BusinessFactKind)
except Exception as ex448:
pass
return BusinessFactKind.UNDEFINED
def kind2(self) -> 'InstrumentKind':
""" Классификатор дополнительный """
s = self.getStringValue(InstrumentBlockReferent.ATTR_KIND2)
if (s is None):
return InstrumentKind.UNDEFINED
try:
res = Utils.valToEnum(s, InstrumentKind)
if (isinstance(res, InstrumentKind)):
return Utils.valToEnum(res, InstrumentKind)
except Exception as ex1477:
pass
return InstrumentKind.UNDEFINED
def kind(self) -> 'FundsKind':
""" Классификатор ценной бумаги """
s = self.getStringValue(FundsReferent.ATTR_KIND)
if (s is None):
return FundsKind.UNDEFINED
try:
res = Utils.valToEnum(s, FundsKind)
if (isinstance(res, FundsKind)):
return Utils.valToEnum(res, FundsKind)
except Exception as ex449:
pass
return FundsKind.UNDEFINED
def kind(self) -> 'InstrumentKind':
""" Тип фрагмента """
s = self.get_string_value(InstrumentBlockReferent.ATTR_KIND)
if (s is None):
return InstrumentKind.UNDEFINED
try:
if (s == "Part" or s == "Base" or s == "Special"):
return InstrumentKind.UNDEFINED
res = Utils.valToEnum(s, InstrumentKind)
if (isinstance(res, InstrumentKind)):
return Utils.valToEnum(res, InstrumentKind)
except Exception as ex1582:
pass
return InstrumentKind.UNDEFINED
def kind(self) -> 'InstrumentKind':
""" Классификатор """
s = self.getStringValue(InstrumentBlockReferent.ATTR_KIND)
if (s is None):
return InstrumentKind.UNDEFINED
try:
if (s == "Part" or s == "Base" or s == "Special"):
return InstrumentKind.UNDEFINED
res = Utils.valToEnum(s, InstrumentKind)
if (isinstance(res, InstrumentKind)):
return Utils.valToEnum(res, InstrumentKind)
except Exception as ex1476:
pass
return InstrumentKind.UNDEFINED
def kind(self) -> 'DecreeChangeKind':
""" Классификатор """
s = self.get_string_value(DecreeChangeReferent.ATTR_KIND)
if (s is None):
return DecreeChangeKind.UNDEFINED
try:
if (s == "Add"):
return DecreeChangeKind.APPEND
res = Utils.valToEnum(s, DecreeChangeKind)
if (isinstance(res, DecreeChangeKind)):
return Utils.valToEnum(res, DecreeChangeKind)
except Exception as ex1111:
pass
return DecreeChangeKind.UNDEFINED
def deserialize_derivate_group(str0_: 'ByteArrayWrapper',
dg: 'DerivateGroup', pos: int) -> None:
attr = str0_.deserialize_short(pos)
if (((attr & 1)) != 0):
dg.is_dummy = True
if (((attr & 2)) != 0):
dg.not_generate = True
if (((attr & 4)) != 0):
dg.m_transitive = 0
if (((attr & 8)) != 0):
dg.m_transitive = 1
if (((attr & 0x10)) != 0):
dg.m_rev_agent_case = 0
if (((attr & 0x20)) != 0):
dg.m_rev_agent_case = 1
if (((attr & 0x40)) != 0):
dg.m_rev_agent_case = 2
dg.questions = (Utils.valToEnum(str0_.deserialize_short(pos),
NextModelQuestion))
dg.questions_ref = (Utils.valToEnum(str0_.deserialize_short(pos),
NextModelQuestion))
dg.prefix = str0_.deserialize_string(pos)
cou = str0_.deserialize_short(pos)
while cou > 0:
w = DerivateWord(dg)
w.spelling = str0_.deserialize_string(pos)
w.class0_ = MorphClass()
w.class0_.value = (str0_.deserialize_short(pos))
w.lang = MorphLang._new10(str0_.deserialize_short(pos))
w.attrs.value = (str0_.deserialize_short(pos))
dg.words.append(w)
cou -= 1
cou = str0_.deserialize_short(pos)
while cou > 0:
pref = Utils.ifNotNull(str0_.deserialize_string(pos), "")
cas = MorphCase()
cas.value = (str0_.deserialize_short(pos))
if (dg.nexts is None):
dg.nexts = dict()
dg.nexts[pref] = cas
cou -= 1
cou = str0_.deserialize_short(pos)
while cou > 0:
pref = Utils.ifNotNull(str0_.deserialize_string(pos), "")
cas = MorphCase()
cas.value = (str0_.deserialize_short(pos))
if (dg.nexts_ref is None):
dg.nexts_ref = dict()
dg.nexts_ref[pref] = cas
cou -= 1
def __remove_items_morph_base_info(self, inf: 'MorphBaseInfo') -> None:
if (self.__m_items is None):
return
if (len(self.__m_items) == 0):
if (inf.gender != MorphGender.UNDEFINED):
self.__m_gender = (Utils.valToEnum(
(self.__m_gender) & (inf.gender), MorphGender))
if (inf.number != MorphNumber.UNDEFINED):
self.__m_number = (Utils.valToEnum(
(self.__m_number) & (inf.number), MorphNumber))
if (not inf.case_.is_undefined):
self.__m_case &= inf.case_
return
for i in range(len(self.__m_items) - 1, -1, -1):
ok = True
it = self.__m_items[i]
if (inf.gender != MorphGender.UNDEFINED):
if (((it.gender) & (inf.gender)) == (MorphGender.UNDEFINED)):
ok = False
ch_num = False
if (inf.number != MorphNumber.PLURAL
and inf.number != MorphNumber.UNDEFINED):
if (((it.number) & (inf.number)) == (MorphNumber.UNDEFINED)):
ok = False
ch_num = True
if (not inf.class0_.is_undefined):
if (((inf.class0_) & it.class0_).is_undefined):
ok = False
if (not inf.case_.is_undefined):
if (((inf.case_) & it.case_).is_undefined):
ok = False
if (not ok):
del self.__m_items[i]
self.__m_need_recalc = True
else:
if (not inf.case_.is_undefined):
if (it.case_ != (((inf.case_) & it.case_))):
it.case_ = ((inf.case_) & it.case_)
self.__m_need_recalc = True
if (inf.gender != MorphGender.UNDEFINED):
if ((it.gender) != ((inf.gender) & (it.gender))):
it.gender = Utils.valToEnum((inf.gender) & (it.gender),
MorphGender)
self.__m_need_recalc = True
if (ch_num):
if ((it.number) != ((inf.number) & (it.number))):
it.number = Utils.valToEnum((inf.number) & (it.number),
MorphNumber)
self.__m_need_recalc = True
def _deserialize(self, str0_: 'ByteArrayWrapper', pos: int) -> None:
b = str0_.deserialize_byte(pos)
self.transitive = b != (0)
sh = str0_.deserialize_short(pos)
self.questions = (Utils.valToEnum(sh, QuestionType))
sh = str0_.deserialize_short(pos)
if (sh != 0):
pr = str0_.deserialize_string(pos)
cas = MorphCase()
cas.value = (sh)
self.agent = NextModelItem(pr, cas)
sh = str0_.deserialize_short(pos)
if (sh != 0):
pr = str0_.deserialize_string(pos)
cas = MorphCase()
cas.value = (sh)
self.pacient = NextModelItem(pr, cas)
sh = str0_.deserialize_short(pos)
if (sh != 0):
pr = str0_.deserialize_string(pos)
cas = MorphCase()
cas.value = (sh)
self.instrument = NextModelItem(pr, cas)
cou = str0_.deserialize_short(pos)
while cou > 0:
pref = str0_.deserialize_string(pos)
if (pref is None):
pref = ""
cas = MorphCase()
sh = str0_.deserialize_short(pos)
cas.value = (sh)
if (self.nexts is None):
self.nexts = dict()
self.nexts[pref] = cas
cou -= 1
def __try_parse(t: 'Token') -> 'AutoannoSentToken':
if (t is None or not MiscHelper.can_be_start_of_sentence(t)):
return None
res = AutoannoSentToken(t, t)
has_verb = False
while t is not None:
if (MiscHelper.can_be_start_of_sentence(t)
and t != res.begin_token):
break
r = t.get_referent()
if (isinstance(r, KeywordReferent)):
res.rank += r.rank
if (r.typ == KeywordType.PREDICATE):
has_verb = True
elif (isinstance(t, TextToken)):
mc = t.get_morph_class_in_dictionary()
if (mc.is_pronoun or mc.is_personal_pronoun):
res.rank -= (1)
elif (t.length_char > 1):
res.rank -= 0.1
res.end_token = t
t = t.next0_
if (not has_verb):
res.rank /= (3)
res.value = MiscHelper.get_text_value_of_meta_token(
res,
Utils.valToEnum(
(GetTextAttr.KEEPREGISTER) | (GetTextAttr.KEEPQUOTES),
GetTextAttr))
return res
def __tryParse(t: 'Token') -> 'AutoannoSentToken':
if (t is None or not MiscHelper.canBeStartOfSentence(t)):
return None
res = AutoannoSentToken(t, t)
has_verb = False
while t is not None:
if (MiscHelper.canBeStartOfSentence(t) and t != res.begin_token):
break
r = t.getReferent()
if (isinstance(r, KeywordReferent)):
res.rank += (r).rank
if ((r).typ == KeywordType.PREDICATE):
has_verb = True
elif (isinstance(t, TextToken)):
mc = t.getMorphClassInDictionary()
if (mc.is_pronoun or mc.is_personal_pronoun):
res.rank -= (1)
elif (t.length_char > 1):
res.rank -= .1
res.end_token = t
t = t.next0_
if (not has_verb):
res.rank /= (3)
res.value = MiscHelper.getTextValueOfMetaToken(
res,
Utils.valToEnum(
(GetTextAttr.KEEPREGISTER) | (GetTextAttr.KEEPQUOTES),
GetTextAttr))
return res
def remove_items(self, it: object, eq: bool = False) -> None:
""" Удалить элементы, не соответствующие элементу
Args:
it(object):
"""
if (isinstance(it, MorphCase)):
self.__remove_items_morph_case(it)
elif (isinstance(it, MorphClass)):
self.__remove_items_morph_class(it, eq)
elif (isinstance(it, MorphBaseInfo)):
self.__remove_items_morph_base_info(it)
elif (isinstance(it, MorphNumber)):
self.__remove_items_morph_number(Utils.valToEnum(it, MorphNumber))
elif (isinstance(it, MorphGender)):
self._remove_items_morph_gender(Utils.valToEnum(it, MorphGender))
def try_parse(t: 'Token') -> 'DelimToken':
if (not (isinstance(t, TextToken))):
return None
if (t.is_comma_and):
res0 = DelimToken.try_parse(t.next0_)
if (res0 is not None):
res0.begin_token = t
return res0
return None
tok = DelimToken.__m_onto.try_parse(t, TerminParseAttr.NO)
if (tok is not None):
res = DelimToken(t, tok.end_token)
res.typ = (Utils.valToEnum(tok.termin.tag, DelimType))
res.doublt = tok.termin.tag2 is not None
res2 = DelimToken.try_parse(res.end_token.next0_)
if (res2 is not None):
if (res2.typ == res.typ):
res.end_token = res2.end_token
res.doublt = False
if (t.morph.class0_.is_pronoun):
npt = NounPhraseHelper.try_parse(
t, NounPhraseParseAttr.PARSEADVERBS, 0, None)
if (npt is not None and npt.end_char > res.end_char):
return None
return res
return None
def gender(self) -> 'MorphGender':
res = MorphGender.UNDEFINED
for it in self.items:
res = (Utils.valToEnum((res) | (it.gender), MorphGender))
if (res == MorphGender.FEMINIE or res == MorphGender.MASCULINE):
return res
else:
return MorphGender.UNDEFINED
def typ(self) -> 'KeywordType':
str0_ = self.getStringValue(KeywordReferent.ATTR_TYPE)
if (str0_ is None):
return KeywordType.UNDEFINED
try:
return Utils.valToEnum(str0_, KeywordType)
except Exception as ex:
return KeywordType.UNDEFINED
