def convert_many(token):
"""Convert several values."""
values = token.group["value"]
units = as_list(token.group.get("len_units", []))
traits = []
for i, value in enumerate(values):
trait = Trait(start=token.start, end=token.end)
if i < len(units):
trait.units = units[i]
trait.units_inferred = False
else:
trait.units = units[-1] if units else None
trait.units_inferred = True
trait.value = convert_units.convert_units(to_positive_float(value),
trait.units)
if trait.value > TOO_BIG:
continue
add_flags(token, trait)
traits.append(trait)
return traits
def shorthand_length(token, measurement=""):
"""Handle shorthand length notation like 11-22-33-44:55g."""
trait = Trait(start=token.start, end=token.end)
trait.value = to_positive_float(token.group.get(measurement))
if not trait.value:
return None
trait.units = "mm_shorthand"
trait.units_inferred = False
trait.is_shorthand = True
flag = measurement.split("_")[1]
flag = f"estimated_{flag}"
trait.is_flag_in_token(token, flag, rename="estimated_value")
return trait
def compound(token):
"""Handle a pattern like: 4 ft 9 in."""
trait = Trait(start=token.start, end=token.end)
trait.units = [token.group["feet"], token.group["inches"]]
trait.units_inferred = False
trait.is_flag_missing(token, "key", rename="ambiguous_key")
fts = convert_units(to_positive_float(token.group["ft"]), "ft")
ins = [
convert_units(to_positive_float(i), "in")
for i in as_list(token.group["in"])
]
value = [round(fts + i, 2) for i in ins]
trait.value = squash(value)
add_flags(token, trait)
return trait
def compound(token):
"""Convert a compound weight like: 2 lbs. 3.1 - 4.5 oz."""
trait = Trait(start=token.start, end=token.end)
trait.units = [token.group["pounds"], token.group["ounces"]]
trait.units_inferred = False
trait.is_flag_missing(token, "key", rename="ambiguous_key")
lbs = convert_units(to_positive_float(token.group["lbs"]), "lbs")
ozs = [
convert_units(to_positive_float(oz), "ozs")
for oz in as_list(token.group["ozs"])
]
value = [round(lbs + oz, 2) for oz in ozs]
trait.value = squash(value)
add_flags(token, trait)
return trait
def fraction(token):
"""Handle fractional values like 10 3/8 inches."""
trait = Trait(start=token.start, end=token.end)
trait.units = token.group.get("units")
trait.units_inferred = not bool(trait.units)
whole = to_positive_float(token.group.get("whole", "0"))
numerator = to_positive_int(token.group["numerator"])
denominator = to_positive_int(token.group["denominator"])
try:
trait.value = whole + Fraction(numerator, denominator)
except TypeError:
print(f"Fraction error: {numerator} / {denominator}")
return None
if trait.units:
trait.value = convert_units(trait.value, trait.units)
add_flags(token, trait)
return trait
