rule-engine 5.0.2__tar.gz → 5.2.0__tar.gz

{rule_engine-5.0.2 → rule_engine-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rule-engine
-Version: 5.0.2
+Version: 5.2.0
 Summary: A lightweight, optionally typed expression language with a custom grammar for matching arbitrary Python objects.
 Author-email: Spencer McIntyre <zeroSteiner@gmail.com>
 Maintainer-email: Spencer McIntyre <zeroSteiner@gmail.com>
@@ -45,6 +45,7 @@ Python with some inspiration from Ruby. Some features of this language includes:
 - Compound datatypes (equivalents for Python dict, list and set types)
 - Data attributes
 - Thread safety
+- Rule chains that return the value of the first matching rule
 
 Example Usage
 -------------

{rule_engine-5.0.2 → rule_engine-5.2.0}/README.rst

@@ -22,6 +22,7 @@ Python with some inspiration from Ruby. Some features of this language includes:
 - Compound datatypes (equivalents for Python dict, list and set types)
 - Data attributes
 - Thread safety
+- Rule chains that return the value of the first matching rule
 
 Example Usage
 -------------

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/__init__.py

@@ -30,17 +30,19 @@
 #  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
-__version__ = '5.0.2'
+__version__ = '5.2.0'
 
 from .engine import resolve_attribute
 from .engine import resolve_item
 from .engine import type_resolver_from_dataclass
 from .engine import type_resolver_from_dict
 from .engine import type_resolver_from_sqlalchemy
+from .engine import Chain
 from .engine import Context
 from .engine import Rule
 
 from .errors import AttributeResolutionError
+from .errors import ChainExhaustedError
 from .errors import EngineError
 from .errors import EvaluationError
 from .errors import RuleSyntaxError
@@ -50,6 +52,8 @@ from .types import DataType
 
 __all__ = (
     'AttributeResolutionError',
+    'Chain',
+    'ChainExhaustedError',
     'Context',
     'DataType',
     'EngineError',

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/ast/base.py

@@ -247,7 +247,7 @@ class ExpressionBase(ASTNodeBase):
 
     def _new_value(self, *args: Any, **kwargs: Any) -> Any:
         # perform a context aware load of value
-        value = coerce_value(*args, **kwargs)
+        value = coerce_value(*args, int_max_digits=self.context.int_max_digits, **kwargs)
         if isinstance(value, datetime.datetime) and value.tzinfo is None:
             value = value.replace(tzinfo=self.context.default_timezone)
         return value
@@ -295,7 +295,7 @@ class LiteralExpressionBase(ExpressionBase):
             elif DataType.is_type(datatype, DataType.MAPPING):
                 value = tuple((cls.from_value(context, k), cls.from_value(context, v)) for k, v in value.items())
         else:
-            value = coerce_value(value)
+            value = coerce_value(value, int_max_digits=context.int_max_digits)
         return subclass(context, value)
 
     def evaluate(self, thing: Any) -> Any:

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/ast/binary/arithmetic.py

@@ -38,6 +38,7 @@ from typing import Any, Callable
 from ... import errors
 from ...types import DataType, coerce_value
 from ...types import _DataTypeDef
+from ...types.coercion import _assert_int_bit_length
 
 from ..base import _assert_is_bytes, _assert_is_natural_number, _assert_is_numeric, _assert_is_string, _assert_not_nullable, _is_reduced
 from .base import BinaryExpressionBase
@@ -190,7 +191,16 @@ class BitwiseExpression(BinaryExpressionBase):
         _assert_is_natural_number(left)
         right = self.right.evaluate(thing)
         _assert_is_natural_number(right)
-        return coerce_value(op(int(left), int(right)))
+        left, right = int(left), int(right)
+        int_max_digits = self.context.int_max_digits
+        if op is operator.lshift and left:
+            # check the size of the result before shifting to avoid allocating an integer that is too large to convert
+            _assert_int_bit_length(left.bit_length() + right, int_max_digits)
+        try:
+            result = op(left, right)
+        except OverflowError:
+            raise errors.ArithmeticError('arithmetic error') from None
+        return coerce_value(result, int_max_digits=int_max_digits)
 
     def _op_bitwise_set(self, op: Callable[[Any, Any], Any], thing: Any, left: Any) -> Any:
         right = self.right.evaluate(thing)

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/ast/binary/base.py

@@ -46,7 +46,7 @@ class BinaryExpressionBase(ExpressionBase):
     A base class for representing complex expressions composed of a left side and a right side, separated by an
     operator.
     """
-    compatible_types: tuple[_DataTypeDef, ...] = (DataType.ARRAY, DataType.BOOLEAN, DataType.DATETIME, DataType.TIMEDELTA, DataType.FLOAT, DataType.MAPPING, DataType.NULL, DataType.SET, DataType.STRING)
+    compatible_types: tuple[_DataTypeDef, ...] = (DataType.ARRAY, DataType.BOOLEAN, DataType.BYTES, DataType.DATETIME, DataType.TIMEDELTA, DataType.FLOAT, DataType.FUNCTION, DataType.MAPPING, DataType.NULL, DataType.OBJECT, DataType.SET, DataType.STRING)
     """
     A tuple containing the compatible data types that the left and right expressions must return. This can for example
     be used to indicate that arithmetic operations are compatible with :py:attr:`~.DataType.FLOAT` but not

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/ast/binary/comparison.py

@@ -53,7 +53,6 @@ class LogicExpression(BinaryExpressionBase):
 
 class ComparisonExpression(BinaryExpressionBase):
     """A class for representing comparison expressions from the grammar text such as equality checks."""
-    compatible_types: tuple[_DataTypeDef, ...] = BinaryExpressionBase.compatible_types + (DataType.OBJECT,)
     def _op_eq(self, thing: Any) -> bool:
         left_value = self.left.evaluate(thing)
         right_value = self.right.evaluate(thing)

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/ast/expression/access.py

@@ -175,7 +175,7 @@ class GetAttributeExpression(ExpressionBase):
             return resolved_obj
         if resolved_obj is None and DataType.is_type(self.object.result_type, DataType.NULLABLE):
             raise errors.EvaluationError(
-                    "attribute access on a null value (use ?. to safely navigate a NULLABLE expression)"
+                    "attribute access on a null value (use &. to safely navigate a NULLABLE expression)"
             )
 
         if self._object_type is not None:
@@ -417,7 +417,7 @@ class GetSliceExpression(ExpressionBase):
             _assert_is_integer_number(resolved_stop)
             resolved_stop = int(resolved_stop)
         value = operator.getitem(resolved_obj, slice(resolved_start, resolved_stop))
-        return coerce_value(value, verify_type=False)
+        return coerce_value(value, verify_type=False, int_max_digits=self.context.int_max_digits)
 
     def reduce(self) -> ExpressionBase:
         if not _is_reduced(self.container, self.start, self.stop):

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/ast/expression/resolution.py

@@ -30,8 +30,10 @@
 #  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
+import collections.abc
 from typing import TYPE_CHECKING, Any, Iterable
 
+from ... import builtins as _builtins
 from ... import errors
 from ...types import DataType
 from ...types import _CollectionDataTypeDef, _DataTypeDef, _FunctionDataTypeDef, _MappingDataTypeDef
@@ -41,12 +43,90 @@ from ..base import ExpressionBase, LiteralExpressionBase, _is_reduced
 if TYPE_CHECKING:
     from ...engine.context import Context
 
+def _null_allowed(member_type: _DataTypeDef) -> bool:
+    """Whether a member slot of *member_type* may hold ``None``."""
+    return member_type == DataType.UNDEFINED or member_type == DataType.NULL or DataType.is_type(member_type, DataType.NULLABLE)
+
+_NullMemberPlan = tuple[bool, tuple[tuple[str, _DataTypeDef, bool, '_NullMemberPlan | None'], ...]]
+
+# the containers that DataType.from_value treats as an ARRAY or a SET
+_COLLECTION_TYPES = (collections.abc.Sequence, collections.abc.Set)
+_NOT_COLLECTION_TYPES = (str, bytes, bytearray)
+
+def _null_member_plan(declared: _DataTypeDef) -> '_NullMemberPlan | None':
+    """
+    Precompute where a value of the compound type *declared* may hold a ``None`` that its member type doesn't allow,
+    for :py:func:`_find_null_member`. Each slot is a kind of member (``'key'``, ``'value'`` or ``'member'``), its
+    declared type, whether that type allows ``None`` and the plan for its own members.
+
+    :return: Whether the value is a mapping and the slots to check, or ``None`` when there is nothing to check.
+    """
+    declared = DataType.NULLABLE.unwrap(declared)
+    slots: tuple[tuple[str, _DataTypeDef], ...]
+    if isinstance(declared, _MappingDataTypeDef):
+        is_mapping = True
+        slots = (('key', declared.key_type), ('value', declared.value_type))
+    elif isinstance(declared, _CollectionDataTypeDef):
+        is_mapping = False
+        slots = (('member', declared.value_type),)
+    else:
+        return None
+    plan = []
+    for kind, member_type in slots:
+        null_allowed = _null_allowed(member_type)
+        nested = _null_member_plan(member_type)
+        if null_allowed and nested is None:
+            continue
+        plan.append((kind, member_type, null_allowed, nested))
+    if not plan:
+        return None
+    return is_mapping, tuple(plan)
+
+def _find_null_member(plan: _NullMemberPlan, value: Any) -> tuple[str, _DataTypeDef] | None:
+    """
+    Find a ``None`` member of *value* in a slot that doesn't allow one, including nested members, following a plan from
+    :py:func:`_null_member_plan`. :py:attr:`~DataType.MAPPING` keys are checked against the key type and values against
+    the value type.
+
+    :return: The kind of member (``'key'``, ``'value'`` or ``'member'``) and its declared type, or ``None``.
+    """
+    is_mapping, slots = plan
+    if is_mapping:
+        if not isinstance(value, collections.abc.Mapping):
+            return None
+    elif type(value) not in (tuple, set) and (not isinstance(value, _COLLECTION_TYPES) or isinstance(value, _NOT_COLLECTION_TYPES)):
+        return None
+    container_value: Any = value
+    members: Iterable[Any]
+    for kind, member_type, null_allowed, nested in slots:
+        if kind == 'key':
+            members = container_value.keys()
+        elif kind == 'value':
+            members = container_value.values()
+        else:
+            members = container_value
+        if nested is None:
+            # null_allowed is False, otherwise the slot would have been skipped
+            for member in members:
+                if member is None:
+                    return kind, member_type
+            continue
+        for member in members:
+            if member is None:
+                if not null_allowed:
+                    return kind, member_type
+            else:
+                found = _find_null_member(nested, member)
+                if found is not None:
+                    return found
+    return None
+
 class SymbolExpression(ExpressionBase):
     """
     A class representing a symbol name to be resolved at evaluation time with the help of a
     :py:class:`~rule_engine.engine.Context` object.
     """
-    __slots__ = ('name', 'result_type', 'scope')
+    __slots__ = ('name', 'result_type', 'scope', '_null_plan_cache')
     def __init__(self, context: 'Context', name: str, scope: str | None = None) -> None:
         """
         :param context: The context to use for evaluating the expression.
@@ -62,6 +142,8 @@ class SymbolExpression(ExpressionBase):
         if type_hint is not None:
             self.result_type = type_hint
         self.scope = scope
+        # the type the cached plan was made for and the plan, see _accept_members
+        self._null_plan_cache: tuple[_DataTypeDef, _NullMemberPlan | None] | None = None
 
     def __repr__(self) -> str:
         return "<{0} name={1!r} >".format(self.__class__.__name__, self.name)
@@ -104,19 +186,56 @@ class SymbolExpression(ExpressionBase):
             assert isinstance(effective_type, (_CollectionDataTypeDef, _MappingDataTypeDef))
             assert isinstance(value_type, (_CollectionDataTypeDef, _MappingDataTypeDef))
             if effective_type.value_type == DataType.UNDEFINED:
-                return value
+                return self._accept_members(effective_type, value)
             if value_type.value_type == DataType.UNDEFINED:
-                return value
-            if effective_type.value_type != DataType.NULL and not effective_type.value_type_nullable and any(v is None for v in value):
-                raise errors.SymbolTypeError(self.name, is_value=value, is_type=value_type, expected_type=self.result_type)
+                return self._accept_members(effective_type, value)
+            if not self._is_re_groups(effective_type):
+                if effective_type.value_type != DataType.NULL and not effective_type.value_type_nullable:
+                    # for a MAPPING this checks the keys, not the values; a None key is fine when the key type allows
+                    # it, but a None value found alongside it stays an error
+                    has_null = any(v is None for v in value)
+                    if has_null and isinstance(effective_type, _MappingDataTypeDef) and _null_allowed(effective_type.key_type):
+                        has_null = any(v is None for v in value.values())
+                    if has_null:
+                        raise errors.SymbolTypeError(
+                                self.name,
+                                is_value=value,
+                                is_type=_with_null_members(value_type, value),
+                                expected_type=self.result_type
+                        )
             if DataType.is_compatible(effective_type.value_type, value_type.value_type):
-                return value
+                return self._accept_members(effective_type, value)
 
         # if the type is null, return the value (treat null as a special case)
         if value_type == DataType.NULL:
             return value
 
-        raise errors.SymbolTypeError(self.name, is_value=value, is_type=value_type, expected_type=self.result_type)
+        raise errors.SymbolTypeError(
+                self.name,
+                is_value=value,
+                is_type=_with_null_members(value_type, value),
+                expected_type=self.result_type
+        )
+
+    def _is_re_groups(self, effective_type: _DataTypeDef) -> bool:
+        # $re_groups holds None for groups that did not participate in the match (see _RE_GROUPS_TYPE); the type object
+        # can be passed on to other symbols (e.g. comprehension variables) so check the symbol site too
+        return self.scope == _builtins.Builtins.scope_name and effective_type is _builtins._RE_GROUPS_TYPE
+
+    def _accept_members(self, effective_type: _DataTypeDef, value: Any) -> Any:
+        # accept a compound value whose members passed the checks above, but warn about a None member where the member
+        # type doesn't allow one because v6.0 will raise SymbolTypeError for it
+        if (self.scope, self.name) in self.context._null_member_warned or self._is_re_groups(effective_type):
+            return value
+        cache = self._null_plan_cache
+        if cache is None or cache[0] is not effective_type:
+            cache = self._null_plan_cache = (effective_type, _null_member_plan(effective_type))
+        plan = cache[1]
+        found = None if plan is None else _find_null_member(plan, value)
+        # a variable assigned by an expression (e.g. a comprehension) holds a value that was checked where it came from
+        if found is not None and not (self.scope is None and self.context._is_assigned(self.name)):
+            self.context._warn_null_member(self.name, self.scope, *found)
+        return value
 
     def to_graphviz(self, digraph: Any, *args: Any, **kwargs: Any) -> None:
         digraph.node(str(id(self)), "{}\nname={!r}".format(self.__class__.__name__, self.name))
@@ -218,3 +337,13 @@ class FunctionCallExpression(ExpressionBase):
         for idx, argument in enumerate(self.arguments, 1):
             argument.to_graphviz(digraph, *args, **kwargs)
             digraph.edge(str(id(self)), str(id(argument)), label="argument #{}".format(idx))
+
+def _with_null_members(value_type: _DataTypeDef, value: Any) -> _DataTypeDef:
+    """
+    Wrap the member type of the ARRAY or SET type *value_type* that was inferred from *value* in NULLABLE when *value*
+    has null members, which the inferred member type leaves out.
+    """
+    if isinstance(value_type, _CollectionDataTypeDef) and value_type.value_type != DataType.UNDEFINED:
+        if any(member is None for member in value):
+            return value_type(DataType.NULLABLE(value_type.value_type))
+    return value_type

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/ast/literal.py

@@ -109,12 +109,12 @@ class FloatExpression(LiteralExpressionBase):
     """Literal float expressions representing numerical values."""
     result_type: _DataTypeDef = DataType.FLOAT
     def __init__(self, context: 'Context', value: Any, **kwargs: Any) -> None:
-        value = coerce_value(value)
+        value = coerce_value(value, int_max_digits=context.int_max_digits)
         super(FloatExpression, self).__init__(context, value, **kwargs)
 
     @classmethod
     def from_string(cls, context: 'Context', string: str) -> 'FloatExpression':
-        return cls(context, parse_float(string))
+        return cls(context, parse_float(string, int_max_digits=context.int_max_digits))
 
 class FunctionExpression(LiteralExpressionBase):
     """Literal mapping expression representing a function."""

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/builtins.py

@@ -41,7 +41,7 @@ from typing import Any, Callable, Iterable, Iterator, Mapping
 
 from . import errors
 from . import types
-from .parser.utilities import parse_datetime, parse_float, parse_timedelta
+from .parser.utilities import _parse_float, parse_datetime, parse_timedelta
 
 import dateutil.tz
 
@@ -92,6 +92,11 @@ def _builtins_split(string: str, sep: str | None = None, maxsplit: Any = None) -
         raise errors.FunctionCallError('argument #3 (maxsplit) must be a natural number')
     return tuple(string.split(sep=sep, maxsplit=maxsplit))
 
+# The type of the $re_groups symbol that Context provides. A group that did not participate in the match is None, but
+# the members are typed as STRING rather than NULLABLE(STRING) so that rules using them as strings (e.g.
+# $re_groups[0] =~ "...") keep parsing. SymbolExpression checks for this exact object and allows None members for it.
+_RE_GROUPS_TYPE = types.DataType.ARRAY(types.DataType.STRING)
+
 class BuiltinValueGenerator(object):
     """
     A class used as a wrapper for builtin values to differentiate between a value that is a function and a value that
@@ -191,7 +196,8 @@ class Builtins(collections.abc.Mapping):
                 'min': min,
                 'filter': _builtin_filter,
                 'parse_datetime': BuiltinValueGenerator(_builtin_parse_datetime_generator),
-                'parse_float': parse_float,
+                # an int result is converted using the context's int_max_digits like other function results
+                'parse_float': _parse_float,
                 'parse_timedelta': parse_timedelta,
                 'random': _builtin_random,
                 'range': _builtin_range,

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/engine/__init__.py

@@ -32,3 +32,4 @@
 
 from .context import resolve_attribute, resolve_item, type_resolver_from_dataclass, type_resolver_from_dict, type_resolver_from_sqlalchemy, Context
 from .rule import Rule, DebugRule
+from .chain import Chain, ChainEntry

{rule_engine-5.0.2 → rule_engine-5.2.0}/lib/rule_engine/engine/_attribute_resolver.py

@@ -37,17 +37,25 @@ import decimal
 import functools
 import math
 import re
-from typing import Any, Callable, Iterable, Sequence, Sized
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Sequence, Sized
 
 from .. import errors
 from .. import parser
 from .. import types
 from ..suggestions import suggest_symbol
 from ..types import _CollectionDataTypeDef, _DataTypeDef
+from ..types.coercion import _assert_int_digits
 
-def _float_op(value: decimal.Decimal, op: Callable[[decimal.Decimal], Any]) -> Any:
+if TYPE_CHECKING:
+    from .context import Context
+
+def _float_op(value: decimal.Decimal, op: Callable[[decimal.Decimal], Any], int_max_digits: int | None = None) -> Any:
     if value.is_nan() or value.is_infinite():
         return value
+    if not value.is_zero():
+        # the integer result has at least adjusted() + 1 digits, check that before creating it because converting a
+        # Decimal to an integer takes time that grows quadratically with its size
+        _assert_int_digits(value.adjusted() + 1, int_max_digits)
     return op(value)
 
 def _value_to_ary_result_type(object_type: _DataTypeDef) -> _DataTypeDef:
@@ -70,15 +78,17 @@ def _value_with_result_type(name: str, object_type: _DataTypeDef) -> _DataTypeDe
     return types.DataType.FUNCTION(name, argument_types=(object_type,), return_type=types.DataType.BOOLEAN)
 
 class _AttributeResolverFunction(object):
-    __slots__ = ('function', 'type_resolver')
+    __slots__ = ('function', 'type_resolver', 'needs_context')
     def __init__(
             self,
             function: Callable[..., Any],
             *,
             result_type: _DataTypeDef,
-            type_resolver: Callable[[_DataTypeDef], _DataTypeDef] | Any
+            type_resolver: Callable[[_DataTypeDef], _DataTypeDef] | Any,
+            needs_context: bool = False
     ) -> None:
         self.function = function
+        self.needs_context = needs_context
         if result_type and result_type is not types.DataType.UNDEFINED:
             if not types.DataType.is_definition(result_type):
                 raise TypeError('result_type must be a types.DataType definition')
@@ -98,34 +108,46 @@ class _AttributeResolverFunction(object):
 
 class _AttributeResolver(object):
     class attribute(object):
-        __slots__ = ('types', 'name', 'result_type', 'type_resolver')
+        __slots__ = ('types', 'name', 'result_type', 'type_resolver', 'needs_context')
         type_map: dict[_DataTypeDef, dict[str, _AttributeResolverFunction]] = collections.defaultdict(dict)
         def __init__(
                 self,
                 name: str,
                 *data_types: _DataTypeDef,
                 result_type: _DataTypeDef = types.DataType.UNDEFINED,
-                type_resolver: Callable[[_DataTypeDef], _DataTypeDef] | Any = errors.UNDEFINED
+                type_resolver: Callable[[_DataTypeDef], _DataTypeDef] | Any = errors.UNDEFINED,
+                needs_context: bool = False
         ) -> None:
             self.types = data_types
             self.name = name
             self.result_type = result_type
             self.type_resolver = type_resolver
+            # whether the function takes the context that the attribute is being resolved in as the context keyword
+            # argument
+            self.needs_context = needs_context
 
         def __call__(self, function: Callable[..., Any]) -> Callable[..., Any]:
             for type_ in self.types:
-                self.type_map[type_][self.name] = _AttributeResolverFunction(function, result_type=self.result_type, type_resolver=self.type_resolver)
+                self.type_map[type_][self.name] = _AttributeResolverFunction(
+                        function,
+                        result_type=self.result_type,
+                        type_resolver=self.type_resolver,
+                        needs_context=self.needs_context
+                )
             return function
 
-    def __call__(self, thing: Any, object_: Any, name: str) -> Any:
+    def __call__(self, thing: Any, object_: Any, name: str, *, context: 'Context') -> Any:
         try:
             object_type = types.DataType.from_value(object_)
         except TypeError:
             # if the object can't be mapped to a supported type, raise a resolution error
             raise errors.AttributeResolutionError(name, object_, thing=thing) from None
         resolver = self._get_resolver(object_type, name, thing=thing)
-        value = resolver.function(self, object_)
-        value = types.coerce_value(value)
+        if resolver.needs_context:
+            value = resolver.function(self, object_, context=context)
+        else:
+            value = resolver.function(self, object_)
+        value = types.coerce_value(value, int_max_digits=context.int_max_digits)
         value_type = types.DataType.from_value(value)
         expected_value_type = resolver.resolve_type(value_type)
         if types.DataType.is_compatible(expected_value_type, value_type):
@@ -218,13 +240,13 @@ class _AttributeResolver(object):
     def datetime_zone_name(self, value: datetime.datetime) -> str | None:
         return value.tzname()
 
-    @attribute('ceiling', types.DataType.FLOAT, result_type=types.DataType.FLOAT)
-    def float_ceiling(self, value: decimal.Decimal) -> decimal.Decimal | int:
-        return _float_op(value, math.ceil)
+    @attribute('ceiling', types.DataType.FLOAT, result_type=types.DataType.FLOAT, needs_context=True)
+    def float_ceiling(self, value: decimal.Decimal, *, context: 'Context') -> decimal.Decimal | int:
+        return _float_op(value, math.ceil, context.int_max_digits)
 
-    @attribute('floor', types.DataType.FLOAT, result_type=types.DataType.FLOAT)
-    def float_floor(self, value: decimal.Decimal) -> decimal.Decimal | int:
-        return _float_op(value, math.floor)
+    @attribute('floor', types.DataType.FLOAT, result_type=types.DataType.FLOAT, needs_context=True)
+    def float_floor(self, value: decimal.Decimal, *, context: 'Context') -> decimal.Decimal | int:
+        return _float_op(value, math.floor, context.int_max_digits)
 
     @attribute('is_nan', types.DataType.FLOAT, result_type=types.DataType.BOOLEAN)
     def float_is_nan(self, value: decimal.Decimal) -> bool:
@@ -283,7 +305,12 @@ class _AttributeResolver(object):
         match = re.match(r'^(' + parser.Parser.get_token_regex('FLOAT') + ')$', value)
         if match is None:
             return decimal.Decimal('nan')
-        return parser.literal_eval(match.group(0))
+        literal = match.group(0)
+        if literal.isdigit():
+            # python doesn't allow leading zeros in decimal integers but they are allowed here, like they are in the
+            # forms with a decimal point or exponent (e.g. 01.5 and 01e5)
+            literal = literal.lstrip('0') or '0'
+        return parser.literal_eval(literal)
 
     @attribute('to_int', types.DataType.STRING, result_type=types.DataType.FLOAT)
     def string_to_int(self, value: str) -> decimal.Decimal: