def _tryParse(t: 'Token', add_units: 'TerminCollection', second: bool,
can_omit_number: bool) -> 'NumbersWithUnitToken':
if (t is None):
return None
while t is not None:
if (t.is_comma_and or t.isValue("НО", None)):
t = t.next0_
else:
break
t0 = t
about_ = False
min_max = 0
wrapmin_max1523 = RefOutArgWrapper(min_max)
ttt = NumbersWithUnitToken._isMinOrMax(t, wrapmin_max1523)
min_max = wrapmin_max1523.value
if (ttt is not None):
t = ttt.next0_
if (t is None):
return None
if (t is None):
return None
if (t.isChar('~') or t.isValue("ОКОЛО", None)
or t.isValue("ПРИМЕРНО", None)):
t = t.next0_
about_ = True
if (t is None):
return None
if (t0.isChar('(')):
mt0 = NumbersWithUnitToken._tryParse(t.next0_, add_units, False,
False)
if (mt0 is not None and mt0.end_token.next0_ is not None
and mt0.end_token.next0_.isChar(')')):
if (second):
if (mt0.from_val is not None and mt0.to_val is not None
and mt0.from_val == (-mt0.to_val)):
pass
else:
return None
mt0.begin_token = t0
mt0.end_token = mt0.end_token.next0_
uu = UnitToken.tryParseList(mt0.end_token.next0_, add_units,
False)
if (uu is not None and len(mt0.units) == 0):
mt0.units = uu
mt0.end_token = uu[len(uu) - 1].end_token
return mt0
plusminus = False
unit_before = False
dty = NumbersWithUnitToken.DiapTyp.UNDEFINED
uni = None
tok = NumbersWithUnitToken.M_TERMINS.tryParse(t, TerminParseAttr.NO)
if (tok is not None):
t = tok.end_token.next0_
dty = (Utils.valToEnum(tok.termin.tag,
NumbersWithUnitToken.DiapTyp))
if (not tok.is_whitespace_after):
if (t is None):
return None
if (t.isCharOf(":")):
pass
elif (isinstance(t, NumberToken)):
pass
elif (t.is_comma and t.next0_ is not None
and t.next0_.isValue("ЧЕМ", None)):
t = t.next0_.next0_
if (t is not None and t.morph.class0_.is_preposition):
t = t.next0_
else:
return None
if (t is not None and t.isChar('(')):
uni = UnitToken.tryParseList(t.next0_, add_units, False)
if (uni is not None):
t = uni[len(uni) - 1].end_token.next0_
while t is not None:
if (t.isCharOf("):")):
t = t.next0_
else:
break
mt0 = NumbersWithUnitToken._tryParse(
t, add_units, False, can_omit_number)
if (mt0 is not None and len(mt0.units) == 0):
mt0.begin_token = t0
mt0.units = uni
return mt0
elif (t.isChar('<')):
dty = NumbersWithUnitToken.DiapTyp.LS
t = t.next0_
if (t is not None and t.isChar('=')):
t = t.next0_
dty = NumbersWithUnitToken.DiapTyp.LE
elif (t.isChar('>')):
dty = NumbersWithUnitToken.DiapTyp.GT
t = t.next0_
if (t is not None and t.isChar('=')):
t = t.next0_
dty = NumbersWithUnitToken.DiapTyp.GE
elif (t.isChar('≤')):
dty = NumbersWithUnitToken.DiapTyp.LE
t = t.next0_
elif (t.isChar('≥')):
dty = NumbersWithUnitToken.DiapTyp.GE
t = t.next0_
if (t is not None and t.isChar(':')):
t = t.next0_
if (t is not None):
if (t.isChar('+') or t.isValue("ПЛЮС", None)):
t = t.next0_
if (t is not None and not t.is_whitespace_before):
if (t.is_hiphen):
t = t.next0_
plusminus = True
elif ((t.isCharOf("\\/") and t.next0_ is not None
and not t.is_newline_after) and t.next0_.is_hiphen):
t = t.next0_.next0_
plusminus = True
elif (second and ((t.isCharOf("\\/÷…~")))):
t = t.next0_
elif ((t.is_hiphen and t == t0 and not second)
and NumbersWithUnitToken.M_TERMINS.tryParse(
t.next0_, TerminParseAttr.NO) is not None):
tok = NumbersWithUnitToken.M_TERMINS.tryParse(
t.next0_, TerminParseAttr.NO)
t = tok.end_token.next0_
dty = (Utils.valToEnum(tok.termin.tag,
NumbersWithUnitToken.DiapTyp))
elif (t.is_hiphen and t == t0
and ((t.is_whitespace_after or second))):
t = t.next0_
elif (t.isChar('±')):
t = t.next0_
plusminus = True
elif ((second and t.isChar('.') and t.next0_ is not None)
and t.next0_.isChar('.')):
t = t.next0_.next0_
if (t is not None and t.isChar('.')):
t = t.next0_
if (t is None):
return None
num = NumberHelper.tryParseRealNumber(t, True)
if (num is None):
uni = UnitToken.tryParseList(t, add_units, False)
if (uni is not None):
unit_before = True
t = uni[len(uni) - 1].end_token.next0_
delim = False
while t is not None:
if (t.isCharOf(":,")):
delim = True
t = t.next0_
else:
break
if (not delim):
if (t is None or not t.is_whitespace_before):
return None
if (t.next0_ is not None and t.is_hiphen
and t.is_whitespace_after):
delim = True
t = t.next0_
num = NumberHelper.tryParseRealNumber(t, True)
res = None
rval = 0
if (num is None):
tt = NumbersWithUnitToken.M_SPEC.tryParse(t, TerminParseAttr.NO)
if (tt is not None):
rval = (tt.termin.tag)
unam = tt.termin.tag2
for u in UnitsHelper.UNITS:
if (u.fullname_cyr == unam):
uni = list()
uni.append(UnitToken._new1517(t, t, u))
break
if (uni is None):
return None
res = NumbersWithUnitToken._new1519(t0, tt.end_token, about_)
t = tt.end_token.next0_
else:
if (not can_omit_number):
return None
if ((uni is not None and len(uni) == 1
and uni[0].begin_token == uni[0].end_token)
and uni[0].length_char > 3):
rval = (1)
res = NumbersWithUnitToken._new1519(
t0, uni[len(uni) - 1].end_token, about_)
t = res.end_token.next0_
else:
return None
else:
if ((t == t0 and t0.is_hiphen and not t.is_whitespace_before)
and not t.is_whitespace_after and (num.real_value < 0)):
return None
t = num.end_token.next0_
res = NumbersWithUnitToken._new1519(t0, num.end_token, about_)
rval = num.real_value
if (uni is None):
uni = UnitToken.tryParseList(t, add_units, False)
if (uni is not None):
if ((plusminus and second and len(uni) == 1)
and uni[0].unit == UnitsHelper.UPERCENT):
res.end_token = uni[len(uni) - 1].end_token
res.plus_minus_percent = True
tt1 = uni[0].end_token.next0_
uni = UnitToken.tryParseList(tt1, add_units, False)
if (uni is not None):
res.units = uni
res.end_token = uni[len(uni) - 1].end_token
else:
res.units = uni
res.end_token = uni[len(uni) - 1].end_token
t = res.end_token.next0_
else:
res.units = uni
if (len(uni) > 1):
uni1 = UnitToken.tryParseList(t, add_units, False)
if (((uni1 is not None and uni1[0].unit == uni[0].unit and
(len(uni1) < len(uni))) and uni[len(uni1)].pow0_ == -1
and uni1[len(uni1) - 1].end_token.next0_ is not None) and
uni1[len(uni1) - 1].end_token.next0_.isCharOf("/\\")):
num2 = NumbersWithUnitToken._tryParse(
uni1[len(uni1) - 1].end_token.next0_.next0_, add_units,
False, False)
if (num2 is not None and num2.units is not None
and num2.units[0].unit == uni[len(uni1)].unit):
res.units = uni1
res.div_num = num2
res.end_token = num2.end_token
if (dty != NumbersWithUnitToken.DiapTyp.UNDEFINED):
if (dty == NumbersWithUnitToken.DiapTyp.GE
or dty == NumbersWithUnitToken.DiapTyp.FROM):
res.from_include = True
res.from_val = rval
elif (dty == NumbersWithUnitToken.DiapTyp.GT):
res.from_include = False
res.from_val = rval
elif (dty == NumbersWithUnitToken.DiapTyp.LE
or dty == NumbersWithUnitToken.DiapTyp.TO):
res.to_include = True
res.to_val = rval
elif (dty == NumbersWithUnitToken.DiapTyp.LS):
res.to_include = False
res.to_val = rval
is_second_max = False
if (not second):
iii = 0
wrapiii1522 = RefOutArgWrapper(iii)
ttt = NumbersWithUnitToken._isMinOrMax(t, wrapiii1522)
iii = wrapiii1522.value
if (ttt is not None and iii > 0):
is_second_max = True
t = ttt.next0_
next0__ = (None if second or plusminus or
((t is not None and t.is_newline_before)) else
NumbersWithUnitToken._tryParse(t, add_units, True, False))
if (next0__ is not None and
((next0__.to_val is not None or next0__.single_val is not None))
and next0__.from_val is None):
if (len(next0__.units) > 0):
if (len(res.units) == 0):
res.units = next0__.units
elif (not UnitToken.canBeEquals(res.units, next0__.units)):
next0__ = (None)
elif (len(res.units) > 0 and not unit_before
and not next0__.plus_minus_percent):
next0__ = (None)
if (next0__ is not None):
res.end_token = next0__.end_token
if (next0__ is not None and next0__.to_val is not None):
res.to_val = next0__.to_val
res.to_include = next0__.to_include
elif (next0__ is not None and next0__.single_val is not None):
if (next0__.begin_token.isCharOf("/\\")):
res.div_num = next0__
res.single_val = rval
return res
elif (next0__.plus_minus_percent):
res.single_val = rval
res.plus_minus = next0__.single_val
res.plus_minus_percent = True
res.to_include = True
else:
res.to_val = next0__.single_val
res.to_include = True
if (next0__ is not None):
if (res.from_val is None):
res.from_val = rval
res.from_include = True
return res
elif ((next0__ is not None and next0__.from_val is not None
and next0__.to_val is not None)
and next0__.to_val == (-next0__.from_val)):
if (len(next0__.units) == 1
and next0__.units[0].unit == UnitsHelper.UPERCENT
and len(res.units) > 0):
res.single_val = rval
res.plus_minus = next0__.to_val
res.plus_minus_percent = True
res.end_token = next0__.end_token
return res
if (len(next0__.units) == 0):
res.single_val = rval
res.plus_minus = next0__.to_val
res.end_token = next0__.end_token
return res
res.from_val = (next0__.from_val + rval)
res.from_include = True
res.to_val = (next0__.to_val + rval)
res.to_include = True
res.end_token = next0__.end_token
if (len(next0__.units) > 0):
res.units = next0__.units
return res
if (dty == NumbersWithUnitToken.DiapTyp.UNDEFINED):
if (plusminus and ((not res.plus_minus_percent or not second))):
res.from_include = True
res.from_val = (-rval)
res.to_include = True
res.to_val = rval
else:
res.single_val = rval
res.plus_minus_percent = plusminus
return res
def tryParseMulti(
t: 'Token',
add_units: 'TerminCollection',
can_omit_number: bool = False,
not0__: bool = False) -> typing.List['NumbersWithUnitToken']:
if (t is None or (isinstance(t, ReferentToken))):
return None
if (t.isChar('(')):
res0 = NumbersWithUnitToken.tryParseMulti(t.next0_, add_units,
False, can_omit_number)
if (res0 is not None
and res0[len(res0) - 1].end_token.next0_ is not None
and res0[len(res0) - 1].end_token.next0_.isChar(')')):
res0[len(res0) - 1].end_token = res0[len(res0) -
1].end_token.next0_
return res0
mt = NumbersWithUnitToken.tryParse(t, add_units, can_omit_number,
not0__)
if (mt is None):
return None
res = list()
if ((mt.whitespaces_after_count < 2)
and MeasureHelper.isMultChar(mt.end_token.next0_)):
mt2 = NumbersWithUnitToken.tryParse(mt.end_token.next0_.next0_,
add_units, not0__, False)
if (mt2 is not None):
mt3 = None
if ((mt2.whitespaces_after_count < 2)
and MeasureHelper.isMultChar(mt2.end_token.next0_)):
mt3 = NumbersWithUnitToken.tryParse(
mt2.end_token.next0_.next0_, add_units, False, False)
if (mt3 is None):
tt2 = mt2.end_token.next0_
if (tt2 is not None and not tt2.is_whitespace_before):
if (not tt2.isCharOf(",.;")):
return None
if (mt3 is not None and len(mt3.units) > 0):
if (len(mt2.units) == 0):
mt2.units = mt3.units
res.append(mt)
if (mt2 is not None):
if (len(mt2.units) > 0 and len(mt.units) == 0):
mt.units = mt2.units
res.append(mt2)
if (mt3 is not None):
res.append(mt3)
return res
if ((not mt.is_whitespace_after
and MeasureHelper.isMultCharEnd(mt.end_token.next0_) and
(isinstance(mt.end_token.next0_.next0_, NumberToken)))
and len(mt.units) == 0):
utxt = (mt.end_token.next0_).term
utxt = utxt[0:0 + len(utxt) - 1]
terms = UnitsHelper.TERMINS.tryAttachStr(utxt, None)
if (terms is not None and len(terms) > 0):
mt.units.append(
UnitToken._new1517(
mt.end_token.next0_, mt.end_token.next0_,
Utils.asObjectOrNull(terms[0].tag, Unit)))
mt.end_token = mt.end_token.next0_
res1 = NumbersWithUnitToken.tryParseMulti(
mt.end_token.next0_, add_units, False, False)
if (res1 is not None):
res1.insert(0, mt)
return res1
res.append(mt)
return res