def create_referent_with_register(self,
ad: 'AnalyzerData') -> 'UnitReferent':
ur = self.ext_onto
if (self.unit is not None):
ur = UnitToken.__create_referent(self.unit)
elif (self.unknown_name is not None):
ur = UnitReferent()
ur.add_slot(UnitReferent.ATTR_NAME, self.unknown_name, False, 0)
ur.is_unknown = True
if (self.pow0_ != 1):
ur.add_slot(UnitReferent.ATTR_POW, str(self.pow0_), False, 0)
owns = list()
owns.append(ur)
if (self.unit is not None):
uu = self.unit.base_unit
while uu is not None:
ur0 = UnitToken.__create_referent(uu)
owns.append(ur0)
uu = uu.base_unit
for i in range(len(owns) - 1, -1, -1):
if (ad is not None):
owns[i] = (Utils.asObjectOrNull(ad.register_referent(owns[i]),
UnitReferent))
if (i > 0):
owns[i - 1].add_slot(UnitReferent.ATTR_BASEUNIT, owns[i],
False, 0)
if (owns[i - 1].tag.base_multiplier != 0):
owns[i - 1].add_slot(
UnitReferent.ATTR_BASEFACTOR,
NumberHelper.double_to_string(
owns[i - 1].tag.base_multiplier), False, 0)
return owns[0]
def real_value(self, value_) -> float:
val = NumberHelper.double_to_string(value_)
ii = val.find('.')
if (ii > 0):
val = val[0:0 + ii]
self.add_slot(MoneyReferent.ATTR_VALUE, val, True, 0)
re = ((value_ - self.value)) * (100)
self.add_slot(MoneyReferent.ATTR_REST, str(math.floor((re + 0.0001))),
True, 0)
return value_
def try_parse(t : 'Token') -> 'ReferentToken':
if (t is None):
return None
if (not (isinstance(t, NumberToken)) and t.length_char != 1):
return None
nex = NumberHelper.try_parse_number_with_postfix(t)
if (nex is None or nex.ex_typ != NumberExType.MONEY):
if ((isinstance(t, NumberToken)) and (isinstance(t.next0_, TextToken)) and (isinstance(t.next0_.next0_, NumberToken))):
if (t.next0_.is_hiphen or t.next0_.morph.class0_.is_preposition):
res1 = NumberHelper.try_parse_number_with_postfix(t.next0_.next0_)
if (res1 is not None and res1.ex_typ == NumberExType.MONEY):
res0 = MoneyReferent()
if ((t.next0_.is_hiphen and res1.real_value == 0 and res1.end_token.next0_ is not None) and res1.end_token.next0_.is_char('(')):
nex2 = NumberHelper.try_parse_number_with_postfix(res1.end_token.next0_.next0_)
if ((nex2 is not None and nex2.ex_typ_param == res1.ex_typ_param and nex2.end_token.next0_ is not None) and nex2.end_token.next0_.is_char(')')):
if (nex2.value == t.value):
res0.currency = nex2.ex_typ_param
res0.add_slot(MoneyReferent.ATTR_VALUE, nex2.value, True, 0)
return ReferentToken(res0, t, nex2.end_token.next0_)
if (isinstance(t.previous, NumberToken)):
if (nex2.value == (((t.previous.real_value * (1000)) + t.value))):
res0.currency = nex2.ex_typ_param
res0.add_slot(MoneyReferent.ATTR_VALUE, nex2.value, True, 0)
return ReferentToken(res0, t.previous, nex2.end_token.next0_)
elif (isinstance(t.previous.previous, NumberToken)):
if (nex2.real_value == (((t.previous.previous.real_value * (1000000)) + (t.previous.real_value * (1000)) + t.real_value))):
res0.currency = nex2.ex_typ_param
res0.add_slot(MoneyReferent.ATTR_VALUE, nex2.value, True, 0)
return ReferentToken(res0, t.previous.previous, nex2.end_token.next0_)
res0.currency = res1.ex_typ_param
res0.add_slot(MoneyReferent.ATTR_VALUE, t.value, False, 0)
return ReferentToken(res0, t, t)
return None
res = MoneyReferent()
res.currency = nex.ex_typ_param
val = nex.value
if (val.find('.') > 0):
val = val[0:0+val.find('.')]
res.add_slot(MoneyReferent.ATTR_VALUE, val, True, 0)
re = math.floor(round(((nex.real_value - res.value)) * (100), 6))
if (re != 0):
res.add_slot(MoneyReferent.ATTR_REST, str(re), True, 0)
if (nex.real_value != nex.alt_real_value):
if (math.floor(res.value) != math.floor(nex.alt_real_value)):
val = NumberHelper.double_to_string(nex.alt_real_value)
if (val.find('.') > 0):
val = val[0:0+val.find('.')]
res.add_slot(MoneyReferent.ATTR_ALTVALUE, val, True, 0)
re = (math.floor(round(((nex.alt_real_value - (math.floor(nex.alt_real_value)))) * (100), 6)))
if (re != res.rest and re != 0):
res.add_slot(MoneyReferent.ATTR_ALTREST, str(re), True, 0)
if (nex.alt_rest_money > 0):
res.add_slot(MoneyReferent.ATTR_ALTREST, str(nex.alt_rest_money), True, 0)
t1 = nex.end_token
if (t1.next0_ is not None and t1.next0_.is_char('(')):
rt = MoneyAnalyzer.try_parse(t1.next0_.next0_)
if ((rt is not None and rt.referent.can_be_equals(res, ReferentsEqualType.WITHINONETEXT) and rt.end_token.next0_ is not None) and rt.end_token.next0_.is_char(')')):
t1 = rt.end_token.next0_
else:
rt = MoneyAnalyzer.try_parse(t1.next0_)
if (rt is not None and rt.referent.can_be_equals(res, ReferentsEqualType.WITHINONETEXT)):
t1 = rt.end_token
if (res.alt_value is not None and res.alt_value > res.value):
if (t.whitespaces_before_count == 1 and (isinstance(t.previous, NumberToken))):
delt = math.floor((res.alt_value - res.value))
if ((((res.value < 1000) and ((delt % 1000)) == 0)) or (((res.value < 1000000) and ((delt % 1000000)) == 0))):
t = t.previous
res.add_slot(MoneyReferent.ATTR_VALUE, res.get_string_value(MoneyReferent.ATTR_ALTVALUE), True, 0)
res.add_slot(MoneyReferent.ATTR_ALTVALUE, None, True, 0)
return ReferentToken(res, t, t1)
def __try_parse(t : 'Token', prev : 'WeaponItemToken', after_conj : bool, attach_high : bool=False) -> 'WeaponItemToken':
if (t is None):
return None
if (BracketHelper.is_bracket(t, True)):
wit = WeaponItemToken.__try_parse(t.next0_, prev, after_conj, attach_high)
if (wit is not None):
if (wit.end_token.next0_ is None):
wit.begin_token = t
return wit
if (BracketHelper.is_bracket(wit.end_token.next0_, True)):
wit.begin_token = t
wit.end_token = wit.end_token.next0_
return wit
tok = WeaponItemToken.M_ONTOLOGY.try_parse(t, TerminParseAttr.NO)
if (tok is not None):
res = WeaponItemToken(t, tok.end_token)
res.typ = (Utils.valToEnum(tok.termin.tag, WeaponItemToken.Typs))
if (res.typ == WeaponItemToken.Typs.NOUN):
res.value = tok.termin.canonic_text
if (tok.termin.tag2 is not None):
res.is_doubt = True
tt = res.end_token.next0_
first_pass3426 = True
while True:
if first_pass3426: first_pass3426 = False
else: tt = tt.next0_
if (not (tt is not None)): break
if (tt.whitespaces_before_count > 2):
break
wit = WeaponItemToken.__try_parse(tt, None, False, False)
if (wit is not None):
if (wit.typ == WeaponItemToken.Typs.BRAND):
res.__inner_tokens.append(wit)
tt = wit.end_token
res.end_token = tt
continue
break
if (not (isinstance(tt, TextToken))):
break
mc = tt.get_morph_class_in_dictionary()
if (mc == MorphClass.ADJECTIVE):
if (res.alt_value is None):
res.alt_value = res.value
if (res.alt_value.endswith(res.value)):
res.alt_value = res.alt_value[0:0+len(res.alt_value) - len(res.value)]
res.alt_value = "{0}{1} {2}".format(res.alt_value, tt.term, res.value)
res.end_token = tt
continue
break
return res
if (res.typ == WeaponItemToken.Typs.BRAND or res.typ == WeaponItemToken.Typs.NAME):
res.value = tok.termin.canonic_text
return res
if (res.typ == WeaponItemToken.Typs.MODEL):
res.value = tok.termin.canonic_text
if (isinstance(tok.termin.tag2, list)):
li = Utils.asObjectOrNull(tok.termin.tag2, list)
for to in li:
wit = WeaponItemToken._new2758(t, tok.end_token, Utils.valToEnum(to.tag, WeaponItemToken.Typs), to.canonic_text, tok.begin_token == tok.end_token)
res.__inner_tokens.append(wit)
if (to.additional_vars is not None and len(to.additional_vars) > 0):
wit.alt_value = to.additional_vars[0].canonic_text
res.__correct_model()
return res
nnn = MiscHelper.check_number_prefix(t)
if (nnn is not None):
tit = TransItemToken._attach_number(nnn, True)
if (tit is not None):
res = WeaponItemToken._new2759(t, tit.end_token, WeaponItemToken.Typs.NUMBER)
res.value = tit.value
res.alt_value = tit.alt_value
return res
if (((isinstance(t, TextToken)) and t.chars.is_letter and t.chars.is_all_upper) and (t.length_char < 4)):
if ((t.next0_ is not None and ((t.next0_.is_hiphen or t.next0_.is_char('.'))) and (t.next0_.whitespaces_after_count < 2)) and (isinstance(t.next0_.next0_, NumberToken))):
res = WeaponItemToken._new2760(t, t.next0_, WeaponItemToken.Typs.MODEL, True)
res.value = t.term
res.__correct_model()
return res
if ((isinstance(t.next0_, NumberToken)) and not t.is_whitespace_after):
res = WeaponItemToken._new2760(t, t, WeaponItemToken.Typs.MODEL, True)
res.value = t.term
res.__correct_model()
return res
if (t.term == "СП" and (t.whitespaces_after_count < 3) and (isinstance(t.next0_, TextToken))):
pp = WeaponItemToken.__try_parse(t.next0_, None, False, False)
if (pp is not None and ((pp.typ == WeaponItemToken.Typs.MODEL or pp.typ == WeaponItemToken.Typs.BRAND))):
res = WeaponItemToken._new2759(t, t, WeaponItemToken.Typs.NOUN)
res.value = "ПИСТОЛЕТ"
res.alt_value = "СЛУЖЕБНЫЙ ПИСТОЛЕТ"
return res
if (((isinstance(t, TextToken)) and t.chars.is_letter and not t.chars.is_all_lower) and t.length_char > 2):
ok = False
if (prev is not None and ((prev.typ == WeaponItemToken.Typs.NOUN or prev.typ == WeaponItemToken.Typs.MODEL or prev.typ == WeaponItemToken.Typs.BRAND))):
ok = True
elif (prev is None and t.previous is not None and t.previous.is_comma_and):
ok = True
if (ok):
res = WeaponItemToken._new2760(t, t, WeaponItemToken.Typs.NAME, True)
res.value = t.term
if ((t.next0_ is not None and t.next0_.is_hiphen and (isinstance(t.next0_.next0_, TextToken))) and t.next0_.next0_.chars == t.chars):
res.value = "{0}-{1}".format(res.value, t.next0_.next0_.term)
res.end_token = t.next0_.next0_
if (prev is not None and prev.typ == WeaponItemToken.Typs.NOUN):
res.typ = WeaponItemToken.Typs.BRAND
if (res.end_token.next0_ is not None and res.end_token.next0_.is_hiphen and (isinstance(res.end_token.next0_.next0_, NumberToken))):
res.typ = WeaponItemToken.Typs.MODEL
res.__correct_model()
elif (not res.end_token.is_whitespace_after and (isinstance(res.end_token.next0_, NumberToken))):
res.typ = WeaponItemToken.Typs.MODEL
res.__correct_model()
return res
if (t.is_value("МАРКА", None)):
res = WeaponItemToken.__try_parse(t.next0_, prev, after_conj, False)
if (res is not None and res.typ == WeaponItemToken.Typs.BRAND):
res.begin_token = t
return res
if (BracketHelper.can_be_start_of_sequence(t.next0_, True, False)):
br = BracketHelper.try_parse(t.next0_, BracketParseAttr.NO, 100)
if (br is not None):
return WeaponItemToken._new2764(t, br.end_token, WeaponItemToken.Typs.BRAND, MiscHelper.get_text_value(br.begin_token, br.end_token, GetTextAttr.NO))
if (((isinstance(t, TextToken)) and (isinstance(t.next0_, TextToken)) and t.next0_.length_char > 1) and not t.next0_.chars.is_all_lower):
return WeaponItemToken._new2764(t, t.next0_, WeaponItemToken.Typs.BRAND, t.term)
if (t.is_value("КАЛИБР", "КАЛІБР")):
tt1 = t.next0_
if (tt1 is not None and ((tt1.is_hiphen or tt1.is_char(':')))):
tt1 = tt1.next0_
num = NumbersWithUnitToken.try_parse(tt1, None, False, False, False, False)
if (num is not None and num.single_val is not None):
return WeaponItemToken._new2764(t, num.end_token, WeaponItemToken.Typs.CALIBER, NumberHelper.double_to_string(num.single_val))
if (isinstance(t, NumberToken)):
num = NumbersWithUnitToken.try_parse(t, None, False, False, False, False)
if (num is not None and num.single_val is not None):
if (len(num.units) == 1 and num.units[0].unit is not None and num.units[0].unit.name_cyr == "мм"):
return WeaponItemToken._new2764(t, num.end_token, WeaponItemToken.Typs.CALIBER, NumberHelper.double_to_string(num.single_val))
if (num.end_token.next0_ is not None and num.end_token.next0_.is_value("КАЛИБР", "КАЛІБР")):
return WeaponItemToken._new2764(t, num.end_token.next0_, WeaponItemToken.Typs.CALIBER, NumberHelper.double_to_string(num.single_val))
if (t.is_value("ПРОИЗВОДСТВО", "ВИРОБНИЦТВО")):
tt1 = t.next0_
if (tt1 is not None and ((tt1.is_hiphen or tt1.is_char(':')))):
tt1 = tt1.next0_
if (isinstance(tt1, ReferentToken)):
if ((isinstance(tt1.get_referent(), OrganizationReferent)) or (isinstance(tt1.get_referent(), GeoReferent))):
return WeaponItemToken._new2769(t, tt1, WeaponItemToken.Typs.DEVELOPER, tt1.get_referent())
return None
def real_value(self, value_) -> float:
from pullenti.ner.core.NumberHelper import NumberHelper
self.value = NumberHelper.double_to_string(value_)
return value_
def add_value(self, d: float) -> None:
self.add_slot(MeasureReferent.ATTR_VALUE,
NumberHelper.double_to_string(d), False, 0)