python-statemachine 3.2.0__py3-none-any.whl → 3.2.2__py3-none-any.whl

statemachine/spec_parser.py

@@ -19,6 +19,15 @@ comparison_repr = {
 }
 
 
+class UnsupportedExpression(ValueError):
+    """The expression contains a structure that is not on the parser allowlist.
+
+    Distinguishes a rejected expression from errors raised by the ``variable_hook``
+    while resolving names, so callers can report each one properly. Inherits from
+    ``ValueError`` to keep the previous behavior for callers catching it.
+    """
+
+
 def _unique_key(left, right, operator) -> str:
     left_key = getattr(left, "unique_key", "")
     right_key = getattr(right, "unique_key", "")
@@ -128,7 +137,7 @@ class Functions:
     def get(cls, func_id):
         func_id = func_id.lower()
         if func_id not in cls.registry:
-            raise ValueError(f"Unsupported function: {func_id}")
+            raise UnsupportedExpression(f"Unsupported function: {func_id}")
         return cls.registry[func_id]
 
 
@@ -195,7 +204,9 @@ def build_unaryop(op_fn, operand: Callable) -> Callable:
 
 def build_collection(factory, item_exprs: "list[Callable]") -> Callable:
     def decorated(*args, **kwargs):
-        return factory(item(*args, **kwargs) for item in item_exprs)
+        items = [item(*args, **kwargs) for item in item_exprs]
+        _check_value_size(items, "collection")
+        return factory(items)
 
     decorated.__name__ = f"{factory.__name__}(...)"
     return decorated
@@ -203,10 +214,12 @@ def build_collection(factory, item_exprs: "list[Callable]") -> Callable:
 
 def build_dict(key_exprs: "list[Callable]", value_exprs: "list[Callable]") -> Callable:
     def decorated(*args, **kwargs):
-        return {
-            key(*args, **kwargs): value(*args, **kwargs)
+        items = [
+            (key(*args, **kwargs), value(*args, **kwargs))
             for key, value in zip(key_exprs, value_exprs, strict=True)
-        }
+        ]
+        _check_value_size(items, "dict")
+        return dict(items)
 
     decorated.__name__ = "dict(...)"
     return decorated
@@ -231,7 +244,7 @@ def build_attribute(value_expr: Callable, attr: str) -> Callable:
 def build_expression(  # noqa: C901
     node, variable_hook, operator_mapping, allow_value_nodes: bool = False
 ):
-    """Build a callable from an AST node using a whitelist of allowed structures.
+    """Build a callable from an AST node using an allowlist of allowed structures.
 
     Args:
         allow_value_nodes: when ``True``, value-producing structures (arithmetic,
@@ -265,7 +278,7 @@ def build_expression(  # noqa: C901
                 expressions.append(expression)
             return reduce(custom_and, expressions)
         case ast.Call(func=ast.Name(id=func_id)):
-            # Only whitelisted functions from the registry (e.g. ``In(...)``) are
+            # Only allowlisted functions from the registry (e.g. ``In(...)``) are
             # callable. Method calls (``obj.method()``) have an ``ast.Attribute``
             # func and fall through to the ``case _`` guard below — this prevents
             # using calls as a sandbox-escape vector.
@@ -276,10 +289,13 @@ def build_expression(  # noqa: C901
             return operator_mapping[type(node.op)](recurse(node.operand))
         case ast.UnaryOp(op=(ast.USub() | ast.UAdd())) if allow_value_nodes:
             return build_unaryop(unary_operators[type(node.op)], recurse(node.operand))
-        case ast.BinOp() if allow_value_nodes and type(node.op) in binary_operators:
-            return build_binop(
-                binary_operators[type(node.op)], recurse(node.left), recurse(node.right)
-            )
+        case ast.BinOp() if allow_value_nodes:
+            op_type = type(node.op)
+            if op_type not in binary_operators:
+                # e.g. bitwise ``^``/``|``/``<<`` are outside the allowlist. (``**`` and ``*``
+                # are allowed but magnitude-capped, see ``binary_operators``.)
+                raise ValueError(f"Binary operator '{op_type.__name__}' is not allowed")
+            return build_binop(binary_operators[op_type], recurse(node.left), recurse(node.right))
         case ast.List(elts=elts) if allow_value_nodes:
             return build_collection(list, [recurse(e) for e in elts])
         case ast.Tuple(elts=elts) if allow_value_nodes:
@@ -300,14 +316,16 @@ def build_expression(  # noqa: C901
             # without underscore-attribute access or method calls, it cannot reach
             # type objects.
             if attr.startswith("_"):
-                raise ValueError(f"Attribute access to '{attr}' is not allowed")
+                raise UnsupportedExpression(f"Attribute access to '{attr}' is not allowed")
             return build_attribute(recurse(node.value), attr)
         case ast.Name(id=name):
             return variable_hook(name)
         case ast.Constant(value=value):
             return build_constant(value)
         case _:
-            raise ValueError(f"Unsupported expression structure: {node.__class__.__name__}")
+            raise UnsupportedExpression(
+                f"Unsupported expression structure: {node.__class__.__name__}"
+            )
 
 
 def parse_boolean_expr(expr, variable_hook, operator_mapping):
@@ -315,16 +333,27 @@ def parse_boolean_expr(expr, variable_hook, operator_mapping):
     if expr.strip() == "":
         raise SyntaxError("Empty expression")
 
-    # Optimization trying to avoid parsing the expression if not needed
-    if "!" not in expr and " " not in expr and "In(" not in expr:
+    # Optimization: a lone identifier can only be a variable name, so there is
+    # nothing to parse. Anything else (operators, comparisons, spaces, calls)
+    # goes through the parser.
+    if expr.isidentifier():
         return variable_hook(expr)
     expr = replace_operators(expr)
     tree = ast.parse(expr, mode="eval")
     return build_expression(tree.body, variable_hook, operator_mapping)
 
 
+def names_in_boolean_expr(expr: str) -> "set[str]":
+    """Variable names that :func:`parse_boolean_expr` would resolve in ``expr``."""
+    try:
+        tree = ast.parse(replace_operators(expr), mode="eval")
+    except SyntaxError:
+        return set()
+    return {node.id for node in ast.walk(tree) if isinstance(node, ast.Name)}
+
+
 def parse_expr(expr: str, variable_hook: Callable) -> Callable:
-    """Parse a value expression into a callable using the restricted AST whitelist.
+    """Parse a value expression into a callable using the restricted AST allowlist.
 
     Unlike :func:`parse_boolean_expr`, this does not apply the DSL operator
     replacement (``!``/``^``/``v``) and does not coerce the top-level result to
@@ -333,7 +362,7 @@ def parse_expr(expr: str, variable_hook: Callable) -> Callable:
     without :func:`eval`.
 
     Raises:
-        ValueError: if the expression uses a structure outside the whitelist
+        ValueError: if the expression uses a structure outside the allowlist
             (e.g. attribute access to dunders, method calls, lambdas).
         SyntaxError: if the expression is empty or not valid Python.
     """
@@ -358,14 +387,115 @@ operator_mapping = {
     ast.NotEq: build_custom_operator(operator.ne),
 }
 
+# Result-size caps for the values an expression can build cheaply. Ordinary arithmetic and
+# collections are well under these; the caps only reject the denial-of-service forms (giant
+# bignums, giant or deeply shared sequences and collections).
+_MAX_POW_RESULT_BITS = 4096
+_MAX_VALUE_SIZE = 1_000_000
+
+_TEXT_TYPES = (str, bytes, bytearray)
+_SEQUENCE_TYPES = (*_TEXT_TYPES, list, tuple)
+_CONTAINER_TYPES = (list, tuple, set, frozenset)
+
+
+def _value_size(value) -> int:
+    """Size of ``value`` counting a shared reference every time it appears.
+
+    ``[[0] * 1000] * 1000`` holds a thousand references to one list, so it is cheap to build,
+    but comparing, hashing or printing it walks a million elements. That walked size is what
+    is measured here, in elements, characters or bytes, memoized by identity so the
+    measurement itself stays cheap.
+    """
+    memo: "dict[int, int]" = {}
+
+    def size(item) -> int:
+        key = id(item)
+        if key in memo:
+            return memo[key]
+        memo[key] = 1
+        if isinstance(item, _TEXT_TYPES):
+            total = len(item)
+        elif isinstance(item, int):
+            total = item.bit_length() // 8
+        elif isinstance(item, dict):
+            total = sum(size(k) + size(v) for k, v in item.items())
+        elif isinstance(item, _CONTAINER_TYPES):
+            total = sum(size(element) for element in item)
+        else:
+            total = 1
+        memo[key] = max(total, 1)
+        return memo[key]
+
+    return size(value)
+
+
+def _check_value_size(value, what: str):
+    if _value_size(value) > _MAX_VALUE_SIZE:
+        raise ValueError(f"{what} is too large for the restricted evaluator")
+
+
+def _guarded_pow(base, exp):
+    """``**`` with a magnitude cap (GHSA-r8gj-366q-cgvj).
+
+    ``int ** int`` can allocate a giant bignum from a tiny expression (``9**9**9`` is a
+    ~370-million-digit number). The result size is estimated *before* computing, so the
+    allocation never happens. Non-integer operands (floats overflow to ``inf`` instead of
+    growing without bound) are passed straight through.
+    """
+    if isinstance(base, int) and isinstance(exp, int) and exp > 0 and base not in (0, 1, -1):
+        if base.bit_length() * exp > _MAX_POW_RESULT_BITS:
+            raise ValueError("'**' result is too large for the restricted evaluator")
+    return operator.pow(base, exp)
+
+
+def _guarded_mul(a, b):
+    """``*`` with a result-size cap (GHSA-r8gj-366q-cgvj).
+
+    ``seq * n`` (list/str/bytes/tuple times an int) can allocate an enormous object from a
+    12-character expression (``[0]*20000000``), and repeatedly squaring an ``int`` doubles its
+    size every time. The result size is checked *before* allocating. Other operands (floats)
+    are passed straight through.
+    """
+    if isinstance(a, int) and isinstance(b, int):
+        if a.bit_length() + b.bit_length() > _MAX_POW_RESULT_BITS:
+            raise ValueError("'*' result is too large for the restricted evaluator")
+    for seq, n in ((a, b), (b, a)):
+        if isinstance(seq, _SEQUENCE_TYPES) and isinstance(n, int):
+            if n > 0 and n * _value_size(seq) > _MAX_VALUE_SIZE:
+                raise ValueError("'*' repetition is too large for the restricted evaluator")
+    return operator.mul(a, b)
+
+
+def _guarded_add(a, b):
+    """``+`` with a sequence-length cap: repeated ``x + x`` doubles a sequence every time."""
+    sizes = [_value_size(x) for x in (a, b) if isinstance(x, _SEQUENCE_TYPES)]
+    if len(sizes) == 2 and sum(sizes) > _MAX_VALUE_SIZE:
+        raise ValueError("'+' result is too large for the restricted evaluator")
+    return operator.add(a, b)
+
+
+def _guarded_mod(a, b):
+    """``%`` restricted to numbers.
+
+    printf-style formatting (``'%2000000000d' % 0``) allocates whatever field width the
+    expression asks for, so it is rejected on ``str``/``bytes`` operands.
+    """
+    if isinstance(a, _TEXT_TYPES):
+        raise ValueError("'%' string formatting is not allowed by the restricted evaluator")
+    return operator.mod(a, b)
+
+
+# ``**``, ``*``, ``+`` and ``%`` stay available for ordinary arithmetic but are wrapped so a
+# tiny untrusted expression cannot exhaust CPU/memory (GHSA-r8gj-366q-cgvj). ``trusted=True``
+# uses the full Python evaluator instead, without these caps.
 binary_operators = {
-    ast.Add: operator.add,
+    ast.Add: _guarded_add,
     ast.Sub: operator.sub,
-    ast.Mult: operator.mul,
+    ast.Mult: _guarded_mul,
     ast.Div: operator.truediv,
     ast.FloorDiv: operator.floordiv,
-    ast.Mod: operator.mod,
-    ast.Pow: operator.pow,
+    ast.Mod: _guarded_mod,
+    ast.Pow: _guarded_pow,
 }
 
 unary_operators = {

statemachine/state.py

@@ -1,4 +1,5 @@
 from collections.abc import Generator
+from collections.abc import Mapping
 from enum import Enum
 from typing import TYPE_CHECKING
 from typing import Any
@@ -8,6 +9,7 @@ from weakref import ref
 from .callbacks import CallbackGroup
 from .callbacks import CallbackPriority
 from .callbacks import CallbackSpecList
+from .event import Event
 from .event import _expand_event_id
 from .exceptions import InvalidDefinition
 from .i18n import _
@@ -56,7 +58,7 @@ class _FromState(_TransitionBuilder):
 
 
 class NestedStateFactory(type):
-    def __new__(  # type: ignore [misc]
+    def __new__(  # type: ignore [misc]  # noqa: C901
         cls, classname, bases, attrs, name="", **kwargs
     ) -> "State":
         if not bases:
@@ -76,6 +78,8 @@ class NestedStateFactory(type):
         states = []
         history = []
         callbacks = {}
+        # Order is significant: a ``HistoryState`` is a ``State``, and an ``Event`` is a
+        # callable ``str``, so both would be captured by a later branch.
         for key, value in attrs.items():
             if isinstance(value, States):
                 for state_id, state in value.items():
@@ -88,7 +92,27 @@ class NestedStateFactory(type):
                 value._set_id(key)
                 states.append(value)
             elif isinstance(value, TransitionList):
-                value.add_event(_expand_event_id(key))
+                for event_id in _expand_event_id(key):
+                    value.add_event(event_id)
+            elif isinstance(value, Event):
+                event_ids = [value.id] if value._has_real_id else _expand_event_id(key)
+                events = [
+                    Event(
+                        id=event_id,
+                        name=value.name,
+                        delay=value.delay,
+                        internal=value.internal,
+                    )
+                    for event_id in event_ids
+                ]
+                if value._transitions is not None:
+                    for event in events:
+                        value._transitions.add_event(event)
+            elif getattr(value, "attr_name", None):
+                if value.is_event:
+                    for event_id in _expand_event_id(key):
+                        value._transitions.add_event(event_id)
+                callbacks[value.attr_name] = value
             elif callable(value):
                 callbacks[key] = value
 
@@ -296,7 +320,7 @@ class State:
         )
 
     def __str__(self):
-        return self.name
+        return str(self.name)
 
     @property
     def id(self) -> str:
@@ -308,7 +332,7 @@ class State:
             self.value = id
         if not self.name:
             self.name = humanize_id(self._id)
-        self._hash = hash((self.name, self._id))
+        self._hash = hash((str(self.name), self._id))
 
         return self
 
@@ -366,14 +390,18 @@ class InstanceState(State):
         self,
         state: State,
         machine: "StateChart",
+        instance_states: "Mapping[Any, State]",
     ):
         self._state = state
         self._machine = ref(machine)
+        self._instance_states = instance_states
         self._hash = hash(state)
-        self._init_states()
+        # No _init_states(): it would rebind the shared children's ``parent`` to this proxy.
 
     def __getattr__(self, name: str):
         value = getattr(self._state, name)
+        if isinstance(value, State):
+            value = self._instance_states.get(value.value, value)
         self.__dict__[name] = value
         return value
 
@@ -416,13 +444,24 @@ class AnyState(State):
     until the state machine class is evaluated.
     """
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._copies: dict[tuple[int, int], Transition] = {}
+        """Transition copied onto each state, keyed by ``(id(transition), id(state))``, so an
+        attribute that declares several ids adds them all to one copy."""
+
     def _on_event_defined(self, event: str, transition: Transition, states: list[State]):
         for state in states:
             if state.final:
                 continue
-            new_transition = transition._copy_with_args(source=state, event=event)
-
-            state.transitions.add_transitions(new_transition)
+            key = (id(transition), id(state))
+            copy = self._copies.get(key)
+            if copy is None:
+                copy = transition._copy_with_args(source=state, event=event)
+                self._copies[key] = copy
+                state.transitions.add_transitions(copy)
+            else:
+                copy.add_event(event)
 
 
 class HistoryType(str, Enum):

statemachine/statemachine.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING
 from typing import Any
 from typing import Generic
 from typing import TypeVar
+from typing import cast
 
 from statemachine.orderedset import OrderedSet
 
@@ -146,7 +147,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         listeners: "list[object] | None" = None,
         **kwargs: Any,
     ):
-        self.model: TModel = model if model is not None else Model()  # type: ignore[assignment]
+        self.model: TModel = model if model is not None else cast(TModel, Model())
         """The external model object that holds domain state, or an internal
         :class:`Model` instance when none is provided.  See :ref:`domain models`."""
 
@@ -207,7 +208,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         instance_states: dict[Any, Any] = {}
         events = self.__class__._events
         for state in self.states_map.values():
-            ist = InstanceState(state, self)
+            ist = InstanceState(state, self, instance_states)
             instance_states[state.value] = ist
             if state.id not in events:
                 vars(self)[state.id] = ist
@@ -225,7 +226,11 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         return run_async_from_sync(result)
 
     def _processing_loop(self, caller_future: "Any | None" = None) -> Any:
-        result = self._engine.processing_loop(caller_future)
+        # Only the async engine gives an event a future, for its caller to await the result by.
+        if isinstance(self._engine, AsyncEngine):
+            result = self._engine.processing_loop(caller_future)
+        else:
+            result = self._engine.processing_loop()
         if not isawaitable(result):
             return result
         return run_async_from_sync(result)
@@ -259,7 +264,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
 
     def __setstate__(self, state: dict[str, Any]) -> None:
         listeners = state.pop("_listeners")
-        self.__dict__.update(state)  # type: ignore[attr-defined]
+        vars(self).update(state)
         self._callbacks = CallbacksRegistry()
         self._config = self._build_configuration()
         self._listeners = {}
@@ -273,11 +278,11 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         self._engine.start()
 
     def _get_initial_configuration(self):
-        initial_state_values = (
-            self.start_configuration_values
-            if self.start_configuration_values
-            else [self.initial_state.value]  # type: ignore[union-attr]
-        )
+        initial_state_values = self.start_configuration_values
+        if not initial_state_values:
+            # Only a machine with no states has no initial state, and none can be created.
+            assert self.initial_state is not None
+            initial_state_values = [self.initial_state.value]
         try:
             return [self.states_map[value] for value in initial_state_values]
         except KeyError as err:
@@ -362,7 +367,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         return f'<div class="statemachine">{self._repr_svg_()}</div>'
 
     def _repr_svg_(self):
-        return self._graph().create_svg().decode()  # type: ignore[attr-defined]
+        return format(self, "svg")
 
     def _graph(self):
         from .contrib.diagram import DotGraphMachine
@@ -460,18 +465,23 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         self,
         event: str,
         *args,
-        delay: float = 0,
+        delay: "float | None" = None,
         send_id: "str | None" = None,
-        internal: bool = False,
+        internal: "bool | None" = None,
         **kwargs,
     ) -> Any:
         """Send an :ref:`Event` to the state machine.
 
         :param event: The trigger for the state machine, specified as an event id string.
         :param args: Additional positional arguments to pass to the event.
-        :param delay: A time delay in milliseconds to process the event. Default is 0.
+        :param delay: A time delay in milliseconds to process the event. Defaults to the
+            event's declaration, or 0. An explicit ``0`` overrides a declared delay.
         :param send_id: An identifier for the event, used with ``cancel_event()`` to cancel
             delayed events.
+        :param internal: Put the event on the internal queue, so it runs within the current
+            macrostep. Defaults to the event's declaration. Honored from a callback; sent from
+            outside a step, the event goes to the external queue and its result is returned.
+            Cannot be combined with ``delay``.
         :param kwargs: Additional keyword arguments to pass to the event.
 
         .. seealso::
@@ -480,9 +490,10 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         """
         know_event = getattr(self, event, None)
         event_name = know_event.name if know_event else event
-        delay = (
-            delay if delay else know_event and know_event.delay or 0
-        )  # first the param, then the event, or 0
+        if delay is None:
+            delay = cast(float, know_event.delay if know_event else 0)
+        if internal is None:
+            internal = bool(know_event and know_event.internal)
         event_instance = BoundEvent(
             id=event, name=event_name, delay=delay, internal=internal, _sm=self
         )
@@ -492,13 +503,22 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         return run_async_from_sync(result)
 
     def raise_(
-        self, event: str, *args, delay: float = 0, send_id: "str | None" = None, **kwargs
+        self,
+        event: str,
+        *args,
+        delay: "float | None" = None,
+        send_id: "str | None" = None,
+        **kwargs,
     ) -> Any:
         """Send an :ref:`Event` to the state machine in the internal event queue.
 
         Events on the internal queue are processed immediately within the current
         macrostep, before any pending external events. This is equivalent to calling
-        ``send(..., internal=True)``.
+        ``send(..., internal=True)``: called from outside a callback, there is no macrostep
+        to join, so the event goes to the external queue and its result is returned. A
+        ``delay`` other than 0, given or declared on the event, is an
+        :class:`~statemachine.exceptions.InvalidDefinition`; pass ``delay=0`` to override a
+        declared one.
 
         .. seealso::
 
@@ -507,7 +527,10 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         return self.send(event, *args, delay=delay, send_id=send_id, internal=True, **kwargs)
 
     def cancel_event(self, send_id: str):
-        """Cancel all the delayed events with the given ``send_id``."""
+        """Cancel all the delayed events with the given ``send_id``.
+
+        A caller awaiting one of them gets ``None``.
+        """
         self._engine.cancel_event(send_id)
 
     @property

python_statemachine-3.2.0.dist-info/RECORD

@@ -1,72 +0,0 @@
-statemachine/__init__.py,sha256=QiHL_KGtaPxEuPtKCpwb6DssApC1jcalKYrkfNgMKc4,445
-statemachine/callbacks.py,sha256=LKX9GnDhN64yYh2EvDEYNJg0-N61Kmyd0aqTZKxujM4,14526
-statemachine/configuration.py,sha256=MblvaBwEOyooYc4Vzo-qeryF9sEmx9mdtZDY0Gf_uRU,5991
-statemachine/dispatcher.py,sha256=DyRqwgr7gXom312BIPsNZiueq5n8jNp1dBDExm7mG_g,8109
-statemachine/event.py,sha256=hYVvsNpsY0-OSebwDEpxdLXadoJS_G5pmDe34hRqnFk,7645
-statemachine/event_data.py,sha256=7_hoE0cp-0uW71Kk3erO3eYM6anTT5X3slGMcehIGIo,3111
-statemachine/events.py,sha256=11GyX8GYpsSwvW0v1b4zHUGhzKRoqNjQYtuDj8NvqOM,1212
-statemachine/exceptions.py,sha256=N6iTrin-uMyw31mbXbO6FUj0V5WGvfKaNZe6L2pV0IE,1314
-statemachine/factory.py,sha256=qIgDxBwa5xa0lgvTaV4QPqdYqqkXZCzlSq0sX4TjZvo,14640
-statemachine/graph.py,sha256=ngQ31YAetfQLQvdBU5cHwLQcD-wJL92axPJ2sUeCu1g,1999
-statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
-statemachine/invoke.py,sha256=5B7XNvBFnQaKByoYM1VbRlJvJyEwXn1C0QKUCaRjmpU,24908
-statemachine/mixins.py,sha256=8qxZZfBwVdFcr3oPFVWHGzgmAubH6VgQus5x3c6VEE0,1706
-statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
-statemachine/orderedset.py,sha256=7y4Hu6vVD0LHTSJ5iTB9F-faRw0326EubR3AOrpZAHE,2570
-statemachine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/registry.py,sha256=TmHfVU7HgaG43slG5lh8EL-8237Fm8r2UkwDj8u-t0c,700
-statemachine/signature.py,sha256=-IiRYJScx4cDKny3ictQvHwQBbaCyxWpRKSgQksMT0E,9834
-statemachine/spec_parser.py,sha256=fjiUjtzTAk6UliNsdbeInqrnp38cfHeYVlgMrbqrzxc,13450
-statemachine/state.py,sha256=kSHeJh1BlSpeDPxMKCCpwIJqzx4MPdXYZ1S24kki4os,15426
-statemachine/statemachine.py,sha256=27TRypjsh3lwlAGZAwqrt-Cnka65uBoaxMWrU27gg6M,19941
-statemachine/states.py,sha256=NRHtATtb-2Ac2nwzSn5OfHwzOSxI2FLeNR8o1v84USs,4827
-statemachine/transition.py,sha256=JtGABHJ6inZrneI70bgu4ir2BZ2YQagcYX9l6TcsHSc,6912
-statemachine/transition_list.py,sha256=zZuGWB86fL2ux-orIE7CdeCcnhaS5p2njIy8h2SuyVY,4361
-statemachine/transition_mixin.py,sha256=i9ZLDGPgE2zIkTn7IAEMjscn1gnI-HJMtxX-YG447tY,3002
-statemachine/utils.py,sha256=taCgrsRDcQQLweyq607AVZyI0NMukRP-HGpO8TiVNgk,1527
-statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/contrib/timeout.py,sha256=VXkdLpxNeUKihkbtLv8XTWdG-meQlSFtxJfcxXgV8Uw,2251
-statemachine/contrib/weighted.py,sha256=lzcopcY0EzjJb-N4APJJc7AlgZIPtthTbBizKaDtOIk,6787
-statemachine/contrib/diagram/__init__.py,sha256=mvTluFDnhE2OzTeOhyU7aQebl79LIOsvOiNFAVIldww,7730
-statemachine/contrib/diagram/__main__.py,sha256=iPpiz09xKqtAjrhONS99OYp6R2dQ6Anbhw1qPIN8ELo,80
-statemachine/contrib/diagram/extract.py,sha256=oNy67KToH7zxgEIPavOvgbpoYTSkM3iWB-Zas1_lcqY,9854
-statemachine/contrib/diagram/formatter.py,sha256=lYdBGO3VSZnM9OipyNsuA6StMEEjrRdnksm9MmzKXBA,4724
-statemachine/contrib/diagram/model.py,sha256=pn7dzrt8U8TOn4A-Jg1Rc3b1UUlTgs75WfR2x-xtEuc,1451
-statemachine/contrib/diagram/sphinx_ext.py,sha256=HcEXU-aYz8da02XPkZKpF5HDF0XPBGGg9FCz8MtI1C8,10338
-statemachine/contrib/diagram/renderers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/contrib/diagram/renderers/dot.py,sha256=VkWMVP1DLl1YUEUZVmBVSNQVbAG516v3hQcK4PePWD8,19772
-statemachine/contrib/diagram/renderers/mermaid.py,sha256=3N1z0klonL768exBcWp3WLMuWUgCpRso2UhpdnvHYhY,13424
-statemachine/contrib/diagram/renderers/table.py,sha256=PLVfwTIZHtv7uK3smAfN1owAOEunkBRHyEkh5ygVcfw,3711
-statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/engines/async_.py,sha256=_n7x5IDu6bucBjE7PFdHBzYwrEcPd-iRxDfMc4FE9HI,22537
-statemachine/engines/base.py,sha256=kAgpDu8iTejPBXp_4casK_rQuHkL_G3Njph8iuXzDiw,37954
-statemachine/engines/sync.py,sha256=F_bt4z1KLLcFCP77E9SNWDJMWiMTexE0iOU2XAd_x5A,9153
-statemachine/io/__init__.py,sha256=i5rGVI1ETu1hH0W8qtQMqK0WrFCYLPdV-s5VXh9vOSo,2062
-statemachine/io/actions.py,sha256=FmRjPFJkcQwtxSEaOXbvu3S5vETai2j5r8mC_4eZ8Og,18624
-statemachine/io/builder.py,sha256=yNaQrtFfbs55uRd-loZ-Vs5061liwM-np-B_2ZuJO1I,8350
-statemachine/io/class_factory.py,sha256=H8zxsfrjLw7L_X2g2hoXb2CjpHxTftsoBmPBWIcen-4,9557
-statemachine/io/evaluators.py,sha256=tMcovIr6dhysLRaxUjYbNmPu3jvOzpHOZDjevUnGEMU,10640
-statemachine/io/interpreter.py,sha256=FQUXUlt1PSPzFHyixiLNXcN-7KYBM_i5RAFPRPLu6TE,5567
-statemachine/io/invoke.py,sha256=wbeSJSlDLEvS7hXSznpMT7wd8GDcVsQSXGgFr67zVrI,9877
-statemachine/io/loader.py,sha256=GbCF0MoLxcRa84zZOZPsJpdIUeodFGcsFoWE_Wk4bqQ,6442
-statemachine/io/model.py,sha256=mTJvlbDJndX78pHfyDdEaqc9zTBWVA-OFA5xzVZbz6Y,8695
-statemachine/io/native.py,sha256=HjIOKDQIGExLMglcm8VGbga71Y1Zw-pBbKYWP-y_oiY,13758
-statemachine/io/ports.py,sha256=XoIAQfMujkEnH38t4iu766yiHycb89TNrA3owtBJU2U,2956
-statemachine/io/system_variables.py,sha256=7skuJgBL8giqzaNEyWd783xOZtVRSUHF6ETwt9fVcd4,6223
-statemachine/io/validation.py,sha256=6qiDx0gMkPAehSxJu_mrW4nEF_sebHwa5Dr_njclRcw,1662
-statemachine/io/json/__init__.py,sha256=tFWoOrD9RuKEqkOpI0XifNRP7rguSGY4k-RaSCV_GnM,38
-statemachine/io/json/reader.py,sha256=40V5T-yB1i0Qg-MkK00KHRi7eDQQk4ajfzmKtKXylHs,789
-statemachine/io/schemas/statechart.schema.json,sha256=5yNIS4M7OV6GE2doAWMk_Jct-qDyb5kQ-Dq95Es9KbM,7862
-statemachine/io/scxml/__init__.py,sha256=iGS763p9fZ6A7NVuEVpDVOS303q0dr5N4kVfOZ37jsk,660
-statemachine/io/scxml/processor.py,sha256=Ru_YQAA1OVXNS9AqfN2myL5POq-C4kI1Vpef-eO7k2M,1532
-statemachine/io/scxml/reader.py,sha256=CNUI9ARDJswRZDKqJSBY98Uoa5rQJsIU-kS9Uu5cmzg,17057
-statemachine/io/yaml/__init__.py,sha256=oMapUmquV7hb5qIGMfjDZmDHNq2fqqjJw6LOgGNKeC4,79
-statemachine/io/yaml/reader.py,sha256=mf2FaBttxQuCniSM-vHhSYDGaNLQdzRLoMUHO2kZ0xA,2208
-statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=_HrrNLQK1krOb56x5Pf1S6LihwaPwhN9_T0PUvumRA0,5338
-statemachine/locale/hi_IN/LC_MESSAGES/statemachine.po,sha256=O15jEhCNATAu6O2WhQ9RhQISB6Ueje2xbbTfEotnVSc,7948
-statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=X6-fU4JfK7VPFCRuLQ-4J-YUMF9N_RwhZ1DdCUvn74Y,5814
-statemachine/locale/zh_CN/LC_MESSAGES/statemachine.po,sha256=0_54wD7bl3RBMlYyokNFUdgMCx_1MbKzclxBUwmCNEs,5363
-python_statemachine-3.2.0.dist-info/METADATA,sha256=Vdy46mBCvmA04ruIBaTS9XklmK72ip3yycmrzgCWu48,12642
-python_statemachine-3.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-python_statemachine-3.2.0.dist-info/licenses/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
-python_statemachine-3.2.0.dist-info/RECORD,,