larksuite/cli · error · ValueError

expected finite {type_name}

Error message

expected finite {type_name}

What it means

This ValueError is raised by builtin_scalar_value when a double/decimal value converts to a Decimal but float(number) is not finite (inf or overflow to infinity). XSD requires finite values even for xsd:double in this validator, so literals like 1e999 that overflow to float inf are rejected with 'expected finite double/decimal'.

Source

Thrown at skills/lark-slides/scripts/sxsd_validator.py:512

        number = Decimal(value)
        if type_name == "positiveInteger" and number <= 0:
            raise ArithmeticError("expected positive integer")
        if type_name == "nonNegativeInteger" and number < 0:
            raise ArithmeticError("expected non-negative integer")
        return number
    if type_name in {"double", "decimal"}:
        lexical_value = value.strip(" \t\n\r")
        decimal_pattern = r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)"
        double_pattern = decimal_pattern + r"(?:[eE][+-]?[0-9]+)?"
        expected_pattern = double_pattern if type_name == "double" else decimal_pattern
        if re.fullmatch(expected_pattern, lexical_value) is None:
            raise ValueError(f"expected {type_name}")
        try:
            number = Decimal(lexical_value)
        except InvalidOperation as error:
            raise ValueError(f"expected {type_name}") from error
        if not math.isfinite(float(number)):
            raise ValueError(f"expected finite {type_name}")
        return number
    return value


def scalar_value_for_type(
    type_name: str,
    value: str,
    model: SchemaModel,
    resolving: set[str] | None = None,
) -> Decimal | str | bool:
    resolving = resolving or set()
    if type_name in resolving:
        return value
    rule = model.simple_types.get(type_name)
    if rule is None or rule.base is None:
        return builtin_scalar_value(type_name, value)
    resolving.add(type_name)
    try:

View on GitHub (pinned to 7fd6ef3c07)

Solutions

1. Replace the value with a finite number within double range (e.g. cap at 1.7976931348623157e308 or a sane domain limit).
2. Fix the producer to clamp/scale computed values before serialization.
3. If huge magnitudes are required, retype the field in the schema or store it as a string.
4. Re-run the validator to confirm.

Example fix

// before
<zoom level="1e999"/>
// after
<zoom level="1e300"/>

import math

def is_finite_xsd_number(text):
    try:
        return math.isfinite(float(text))
    except (ValueError, OverflowError):
        return False

assert is_finite_xsd_number('1e300')
assert not is_finite_xsd_number('1e999')

def finite_float(text):
    import math
    try:
        f = float(text)
    except (ValueError, OverflowError):
        return None
    return f if math.isfinite(f) else None

try:
    value = scalar_value_for_type('double', raw)
except ValueError as e:
    print(f'value overflows to infinity, clamp it: {e}')

When it happens

Trigger: Validating a value like '1e999', '-1e400', or an extremely long mantissa where float() overflows to infinity while checking an xsd:double or xsd:decimal typed value.

Common situations: Auto-generated XML with absurd magnitudes (division results not guarded), data corrupted by unit-conversion bugs, or scientific computation output dumped verbatim into slides XML.

Related errors

• expected positive integer
• expected non-negative integer
• expected {type_name}
• unsupported complemented XSD character class \{escaped} insi
• --header-scan-rows must be at least 1

AI-assisted analysis of larksuite/cli@7fd6ef3c07 (2026-09-04). Data as JSON: /api/errors/76f38a0b5237887a. Report an issue: GitHub.