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

statemachine/spec_parser.py

@@ -1,10 +1,9 @@
 import ast
 import operator
 import re
+from collections.abc import Callable
 from functools import reduce
 from inspect import isawaitable
-from typing import Callable
-from typing import Dict
 
 replacements = {"!": "not ", "^": " and ", "v": " or "}
 
@@ -115,7 +114,7 @@ def build_constant(constant) -> Callable:
 
 
 class Functions:
-    registry: Dict[str, Callable] = {}
+    registry: dict[str, Callable] = {}
 
     @classmethod
     def register(cls, id) -> Callable:
@@ -178,45 +177,137 @@ def build_custom_operator(operator) -> Callable:
     return custom_comparator
 
 
-def build_expression(node, variable_hook, operator_mapping):  # noqa: C901
-    if isinstance(node, ast.BoolOp):
-        # Handle `and` / `or` operations
-        operator_fn = operator_mapping[type(node.op)]
-        left_expr = build_expression(node.values[0], variable_hook, operator_mapping)
-        for right in node.values[1:]:
-            right_expr = build_expression(right, variable_hook, operator_mapping)
-            left_expr = operator_fn(left_expr, right_expr)
-        return left_expr
-    elif isinstance(node, ast.Compare):
-        # Handle `==` / `!=` / `>` / `<` / `>=` / `<=` operations
-        expressions = []
-        left_expr = build_expression(node.left, variable_hook, operator_mapping)
-        for right_op, right in zip(node.ops, node.comparators):  # noqa: B905  # strict=True requires 3.10+
-            right_expr = build_expression(right, variable_hook, operator_mapping)
-            operator_fn = operator_mapping[type(right_op)]
-            expression = operator_fn(left_expr, right_expr)
-            left_expr = right_expr
-            expressions.append(expression)
-
-        return reduce(custom_and, expressions)
-    elif isinstance(node, ast.Call):
-        # Handle function calls
-        assert isinstance(node.func, ast.Name)
-        constructor = Functions.get(node.func.id)
-        params = [arg.value for arg in node.args if isinstance(arg, ast.Constant)]
-        return constructor(*params)
-    elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
-        # Handle `not` operation
-        operand_expr = build_expression(node.operand, variable_hook, operator_mapping)
-        return operator_mapping[type(node.op)](operand_expr)
-    elif isinstance(node, ast.Name):
-        # Handle variables by calling the variable_hook
-        return variable_hook(node.id)
-    elif isinstance(node, ast.Constant):
-        # Handle constants by returning the value
-        return build_constant(node.value)
-    else:
-        raise ValueError(f"Unsupported expression structure: {node.__class__.__name__}")
+def build_binop(op_fn, left: Callable, right: Callable) -> Callable:
+    def decorated(*args, **kwargs):
+        return op_fn(left(*args, **kwargs), right(*args, **kwargs))
+
+    decorated.__name__ = f"({left.__name__} {op_fn.__name__} {right.__name__})"
+    return decorated
+
+
+def build_unaryop(op_fn, operand: Callable) -> Callable:
+    def decorated(*args, **kwargs):
+        return op_fn(operand(*args, **kwargs))
+
+    decorated.__name__ = f"{op_fn.__name__}({operand.__name__})"
+    return decorated
+
+
+def build_collection(factory, item_exprs: "list[Callable]") -> Callable:
+    def decorated(*args, **kwargs):
+        return factory(item(*args, **kwargs) for item in item_exprs)
+
+    decorated.__name__ = f"{factory.__name__}(...)"
+    return decorated
+
+
+def build_dict(key_exprs: "list[Callable]", value_exprs: "list[Callable]") -> Callable:
+    def decorated(*args, **kwargs):
+        return {
+            key(*args, **kwargs): value(*args, **kwargs)
+            for key, value in zip(key_exprs, value_exprs, strict=True)
+        }
+
+    decorated.__name__ = "dict(...)"
+    return decorated
+
+
+def build_subscript(value_expr: Callable, slice_expr: Callable) -> Callable:
+    def decorated(*args, **kwargs):
+        return value_expr(*args, **kwargs)[slice_expr(*args, **kwargs)]
+
+    decorated.__name__ = f"{value_expr.__name__}[{slice_expr.__name__}]"
+    return decorated
+
+
+def build_attribute(value_expr: Callable, attr: str) -> Callable:
+    def decorated(*args, **kwargs):
+        return getattr(value_expr(*args, **kwargs), attr)
+
+    decorated.__name__ = f"{value_expr.__name__}.{attr}"
+    return decorated
+
+
+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.
+
+    Args:
+        allow_value_nodes: when ``True``, value-producing structures (arithmetic,
+            collections, subscript, attribute read) are also accepted. The DSL
+            boolean-guard parser keeps this ``False`` so non-boolean expressions
+            (e.g. ``a * b``, ``{}``) remain rejected; the SCXML datamodel parser
+            (:func:`parse_expr`) sets it ``True``.
+    """
+
+    def recurse(child):
+        return build_expression(child, variable_hook, operator_mapping, allow_value_nodes)
+
+    match node:
+        case ast.BoolOp():
+            # `and` / `or` operations
+            operator_fn = operator_mapping[type(node.op)]
+            left_expr = recurse(node.values[0])
+            for right in node.values[1:]:
+                right_expr = recurse(right)
+                left_expr = operator_fn(left_expr, right_expr)
+            return left_expr
+        case ast.Compare():
+            # `==` / `!=` / `>` / `<` / `>=` / `<=` operations
+            expressions = []
+            left_expr = recurse(node.left)
+            for right_op, right in zip(node.ops, node.comparators, strict=True):
+                right_expr = recurse(right)
+                operator_fn = operator_mapping[type(right_op)]
+                expression = operator_fn(left_expr, right_expr)
+                left_expr = right_expr
+                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
+            # 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.
+            constructor = Functions.get(func_id)
+            params = [arg.value for arg in node.args if isinstance(arg, ast.Constant)]
+            return constructor(*params)
+        case ast.UnaryOp(op=ast.Not()):
+            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.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:
+            return build_collection(tuple, [recurse(e) for e in elts])
+        case ast.Set(elts=elts) if allow_value_nodes:
+            return build_collection(set, [recurse(e) for e in elts])
+        case ast.Dict(keys=keys, values=values) if allow_value_nodes and all(
+            key is not None for key in keys
+        ):
+            # ``key is not None`` rejects dict unpacking (``{**other}``), whose key
+            # node is ``None``.
+            return build_dict([recurse(key) for key in keys], [recurse(value) for value in values])
+        case ast.Subscript() if allow_value_nodes:
+            return build_subscript(recurse(node.value), recurse(node.slice))
+        case ast.Attribute(attr=attr) if allow_value_nodes:
+            # Block dunder/private attribute access (``__class__``, ``__globals__``,
+            # ...), the classic sandbox-escape chain. Subscript is allowed because,
+            # 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")
+            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__}")
 
 
 def parse_boolean_expr(expr, variable_hook, operator_mapping):
@@ -232,6 +323,29 @@ def parse_boolean_expr(expr, variable_hook, operator_mapping):
     return build_expression(tree.body, variable_hook, operator_mapping)
 
 
+def parse_expr(expr: str, variable_hook: Callable) -> Callable:
+    """Parse a value expression into a callable using the restricted AST whitelist.
+
+    Unlike :func:`parse_boolean_expr`, this does not apply the DSL operator
+    replacement (``!``/``^``/``v``) and does not coerce the top-level result to
+    ``bool`` — it returns the raw evaluated value. Used to safely evaluate SCXML
+    datamodel expressions (``<assign>``, ``<send>``, ``<foreach>``, ``<data>``)
+    without :func:`eval`.
+
+    Raises:
+        ValueError: if the expression uses a structure outside the whitelist
+            (e.g. attribute access to dunders, method calls, lambdas).
+        SyntaxError: if the expression is empty or not valid Python.
+    """
+    if expr.strip() == "":
+        raise SyntaxError("Empty expression")
+    tree = ast.parse(expr, mode="eval")
+    compiled: Callable = build_expression(
+        tree.body, variable_hook, operator_mapping, allow_value_nodes=True
+    )
+    return compiled
+
+
 operator_mapping = {
     ast.Or: custom_or,
     ast.And: custom_and,
@@ -243,3 +357,18 @@ operator_mapping = {
     ast.Eq: build_custom_operator(operator.eq),
     ast.NotEq: build_custom_operator(operator.ne),
 }
+
+binary_operators = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+}
+
+unary_operators = {
+    ast.USub: operator.neg,
+    ast.UAdd: operator.pos,
+}

statemachine/state.py

@@ -1,8 +1,7 @@
+from collections.abc import Generator
 from enum import Enum
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Generator
-from typing import List
 from typing import cast
 from weakref import ref
 
@@ -214,8 +213,8 @@ class State:
         initial: bool = False,
         final: bool = False,
         parallel: bool = False,
-        states: "List[State] | None" = None,
-        history: "List[HistoryState] | None" = None,
+        states: "list[State] | None" = None,
+        history: "list[HistoryState] | None" = None,
         enter: Any = None,
         exit: Any = None,
         invoke: Any = None,
@@ -284,7 +283,7 @@ class State:
             f"on_invoke_{self.id}", priority=CallbackPriority.NAMING, is_convention=True
         )
 
-    def _on_event_defined(self, event: str, transition: Transition, states: List["State"]):
+    def _on_event_defined(self, event: str, transition: Transition, states: list["State"]):
         """Called by statemachine factory when an event is defined having a transition
         starting from this state.
         """
@@ -417,7 +416,7 @@ class AnyState(State):
     until the state machine class is evaluated.
     """
 
-    def _on_event_defined(self, event: str, transition: Transition, states: List[State]):
+    def _on_event_defined(self, event: str, transition: Transition, states: list[State]):
         for state in states:
             if state.final:
                 continue

statemachine/statemachine.py

@@ -1,11 +1,9 @@
 import warnings
+from collections.abc import MutableSet
 from inspect import isawaitable
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Dict
 from typing import Generic
-from typing import List
-from typing import MutableSet
 from typing import TypeVar
 
 from statemachine.orderedset import OrderedSet
@@ -106,7 +104,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
     produce an ``error.execution`` internal event instead of propagating, as mandated by the
     SCXML specification. If ``False``, exceptions propagate normally."""
 
-    start_configuration_values: List[Any] = []
+    start_configuration_values: list[Any] = []
     """Default state values to be entered when the state machine starts.
 
     If empty (default), the root ``initial`` state will be used.
@@ -123,21 +121,21 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
     states: "States"
     """Collection of top-level :ref:`State` objects declared on this class."""
 
-    states_map: Dict[Any, "State"]
+    states_map: dict[Any, "State"]
     """Mapping from each state's ``value`` to the corresponding :ref:`State` instance.
     Includes states at all nesting levels (compound children, parallel regions, etc.)."""
 
     initial_state: "State | None"
     """The single top-level initial :ref:`State`, or ``None`` for abstract classes."""
 
-    final_states: "List[State]"
+    final_states: "list[State]"
     """List of top-level :ref:`State` objects marked as ``final``."""
 
     _abstract: bool
-    _events: "Dict[Event, None]"
+    _events: "dict[Event, None]"
     _protected_attrs: set
     _specs: CallbackSpecList
-    _class_listeners: List[Any]
+    _class_listeners: list[Any]
     prepare: SpecListGrouper
 
     def __init__(
@@ -145,14 +143,14 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         model: "TModel | None" = None,
         state_field: str = "state",
         start_value: Any = None,
-        listeners: "List[object] | None" = None,
+        listeners: "list[object] | None" = None,
         **kwargs: Any,
     ):
         self.model: TModel = model if model is not None else Model()  # type: ignore[assignment]
         """The external model object that holds domain state, or an internal
         :class:`Model` instance when none is provided.  See :ref:`domain models`."""
 
-        self.history_values: Dict[str, List[State]] = {}
+        self.history_values: dict[str, list[State]] = {}
         """Mapping from compound state IDs to the list of states that were active
         the last time that compound state was exited. Used by history pseudo-states
         to restore previous configurations."""
@@ -162,7 +160,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         )
         self._callbacks = CallbacksRegistry()
         self._config = self._build_configuration()
-        self._listeners: Dict[int, Any] = {}
+        self._listeners: dict[int, Any] = {}
         """Listeners that provides attributes to be used as callbacks."""
 
         if self._abstract:
@@ -184,8 +182,8 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
 
         return SyncEngine(self)
 
-    def _resolve_class_listeners(self, **kwargs: Any) -> List[object]:
-        resolved: List[object] = []
+    def _resolve_class_listeners(self, **kwargs: Any) -> list[object]:
+        resolved: list[object] = []
         for entry in self._class_listeners:
             if callable(entry):
                 instance = entry()
@@ -206,11 +204,11 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
 
     def _build_configuration(self) -> Configuration:
         """Create InstanceState entries and return a new Configuration."""
-        instance_states: Dict[str, Any] = {}
+        instance_states: dict[Any, Any] = {}
         events = self.__class__._events
         for state in self.states_map.values():
             ist = InstanceState(state, self)
-            instance_states[state.id] = ist
+            instance_states[state.value] = ist
             if state.id not in events:
                 vars(self)[state.id] = ist
         return Configuration(
@@ -259,7 +257,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         del state["_engine"]
         return state
 
-    def __setstate__(self, state: Dict[str, Any]) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         listeners = state.pop("_listeners")
         self.__dict__.update(state)  # type: ignore[attr-defined]
         self._callbacks = CallbacksRegistry()
@@ -312,7 +310,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
 
         return self
 
-    def _register_callbacks(self, listeners: List[object]):
+    def _register_callbacks(self, listeners: list[object]):
         self._listeners.update({id(listener): listener for listener in listeners})
         self._add_listener(
             Listeners.from_listeners(
@@ -336,7 +334,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         self._callbacks.async_or_sync()
 
     @property
-    def active_listeners(self) -> List[object]:
+    def active_listeners(self) -> list[object]:
         """List of all active listeners attached to this instance.
 
         Includes class-level listeners (resolved from the ``listeners`` class attribute),
@@ -423,12 +421,12 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         self.current_state_value = value.value
 
     @property
-    def events(self) -> "List[Event]":
+    def events(self) -> "list[Event]":
         """List of all :ref:`Event` instances declared on this state machine."""
         return [getattr(self, event) for event in self.__class__._events]
 
     @property
-    def allowed_events(self) -> "List[Event]":
+    def allowed_events(self) -> "list[Event]":
         """List of the current allowed events."""
         return [
             getattr(self, event)

statemachine/states.py

@@ -1,11 +1,9 @@
 from enum import Enum
-from typing import Dict  # deprecated since 3.9: https://peps.python.org/pep-0585/
-from typing import Type
 
 from .state import State
 from .utils import ensure_iterable
 
-EnumType = Type[Enum]
+EnumType = type[Enum]
 
 
 class States:
@@ -35,7 +33,7 @@ class States:
 
     """
 
-    def __init__(self, states: "Dict[str, State] | None" = None) -> None:
+    def __init__(self, states: "dict[str, State] | None" = None) -> None:
         """
         Initializes a new instance of the States class.
 
@@ -45,7 +43,7 @@ class States:
         Returns:
             None.
         """
-        self._states: Dict[str, State] = states if states is not None else {}
+        self._states: dict[str, State] = states if states is not None else {}
 
     def __repr__(self):
         return f"{list(self)}"

statemachine/transition.py

@@ -1,6 +1,5 @@
 from copy import deepcopy
 from typing import TYPE_CHECKING
-from typing import List
 
 from .callbacks import CallbackGroup
 from .callbacks import CallbackPriority
@@ -43,7 +42,7 @@ class Transition:
     def __init__(
         self,
         source: "State",
-        target: "State | List[State] | None" = None,
+        target: "State | list[State] | None" = None,
         event=None,
         internal=False,
         initial=False,
@@ -56,7 +55,7 @@ class Transition:
     ):
         self.source = source
         if isinstance(target, list):
-            self._targets: "List[State]" = target
+            self._targets: "list[State]" = target
         elif target is not None:
             self._targets = [target]
         else:
@@ -104,7 +103,7 @@ class Transition:
         return self._targets[0] if self._targets else None
 
     @property
-    def targets(self) -> "List[State]":
+    def targets(self) -> "list[State]":
         """All target states. For single-target transitions, returns a one-element list."""
         return self._targets
 

statemachine/transition_list.py

@@ -1,6 +1,5 @@
+from collections.abc import Iterable
 from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import List
 
 from .callbacks import CallbackGroup
 from .transition import Transition
@@ -22,7 +21,7 @@ class TransitionList(AddCallbacksMixin):
                 Defaults to `None`.
 
         """
-        self.transitions: List[Transition] = list(transitions) if transitions else []
+        self.transitions: list[Transition] = list(transitions) if transitions else []
 
     def __repr__(self):
         """Return a string representation of the :ref:`TransitionList`."""
@@ -42,7 +41,7 @@ class TransitionList(AddCallbacksMixin):
         """
         return TransitionList(self.transitions).add_transitions(other)
 
-    def _on_event_defined(self, event: str, states: List["State"]):
+    def _on_event_defined(self, event: str, states: list["State"]):
         self.add_event(event)
 
         for transition in self.transitions:
@@ -111,7 +110,7 @@ class TransitionList(AddCallbacksMixin):
             transition.add_event(event)
 
     @property
-    def unique_events(self) -> List["Event"]:
+    def unique_events(self) -> list["Event"]:
         """
         Returns a list of unique event names across all transitions in the :ref:`TransitionList`
         instance.

statemachine/transition_mixin.py

@@ -1,5 +1,5 @@
+from collections.abc import Callable
 from typing import Any
-from typing import Callable
 from typing import TypeVar
 
 from .callbacks import CallbackGroup

python_statemachine-3.1.2.dist-info/RECORD

@@ -1,58 +0,0 @@
-statemachine/__init__.py,sha256=yQtTMGmdCawa7KJruju803HXI20v6IWtKibPQ61tL6o,445
-statemachine/callbacks.py,sha256=mY_RAl86240vG2C94ij6AdD7CgsIM8mr0wvpSAMAPv0,14644
-statemachine/configuration.py,sha256=5tTx4-_cXnu6apxdvUfhfhDe6zym9BJynqQ-lrIxnls,6018
-statemachine/dispatcher.py,sha256=xvA1Kf1xGQivHTpaGm_HC22vqAmE_tTm9LQwyVLRWLE,7841
-statemachine/event.py,sha256=d_Ky5ph30Os305BceN4x-rftZH-h8G1U5ei34-66lnI,7669
-statemachine/event_data.py,sha256=7_hoE0cp-0uW71Kk3erO3eYM6anTT5X3slGMcehIGIo,3111
-statemachine/events.py,sha256=11GyX8GYpsSwvW0v1b4zHUGhzKRoqNjQYtuDj8NvqOM,1212
-statemachine/exceptions.py,sha256=gXFvDsEtIxKdcGrRG9mwDgXqFQDXfw8v66_VXaQgGr4,1305
-statemachine/factory.py,sha256=9uujdEe7UV0QG7ZpmRfLwqvrbrbmyzkL3afww3CVufQ,14744
-statemachine/graph.py,sha256=r-8L7jXab1_VLtVu-Ig8bpe4Szo-r6WDFTdbfcepyZM,1981
-statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
-statemachine/invoke.py,sha256=ydYBzP5pi67r9GYmDd6fT169MZkLM4lgpYcbuSyX3Ok,24874
-statemachine/mixins.py,sha256=8qxZZfBwVdFcr3oPFVWHGzgmAubH6VgQus5x3c6VEE0,1706
-statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
-statemachine/orderedset.py,sha256=PjbegcS7WPJAzC7jQ411_JrFJYEz6mmLRsAZ7aI9BWc,2543
-statemachine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/registry.py,sha256=onT8U5QgYlCSJxgxvi_TY1c1oDetHykOwnyiFk5qoN0,756
-statemachine/signature.py,sha256=N8Vt4X3YOA-NB8oidPAbYZxBgqZm6GYAiuHxBWb1l1s,9922
-statemachine/spec_parser.py,sha256=Io0J5D9s-nu2YdgUlr2cSethGfCS0pSLNmxMCXdwMqQ,8307
-statemachine/state.py,sha256=Sb25t3tAyUfUEP9B8FS7wf_kPaCugVnHeGP0OAOqZWo,15441
-statemachine/statemachine.py,sha256=K2f-MwRkvpnq_9vs7NlqeTkCaeX1eepSZl7XPAUF3V4,19977
-statemachine/states.py,sha256=kWo7y95ikXxNmcf_-J2UoMIwd3NaIdxpHMfoHr3cQ_Y,4934
-statemachine/transition.py,sha256=x9hhxIEyQ7tqsvaXkHg1bVO5hMAjemgHfZhyuypHoOY,6936
-statemachine/transition_list.py,sha256=6NAyOGEgoGOzTYiLfPM21CBVI1tPO63ZIwbaZlqOPI4,4376
-statemachine/transition_mixin.py,sha256=XGGd2J4DnFrqIpeej3QFDOuqI0CAiYwnIb8-_9DpemA,2993
-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=jcKkm25df6NnzBzuss1-ewDEasZ_CyME03xgJXrwcso,6866
-statemachine/contrib/diagram/__init__.py,sha256=mvTluFDnhE2OzTeOhyU7aQebl79LIOsvOiNFAVIldww,7730
-statemachine/contrib/diagram/__main__.py,sha256=iPpiz09xKqtAjrhONS99OYp6R2dQ6Anbhw1qPIN8ELo,80
-statemachine/contrib/diagram/extract.py,sha256=RmjsTpOkbQxwYS_m5BS1VWisef5vHtTRmmwe_Dq3wMk,9891
-statemachine/contrib/diagram/formatter.py,sha256=SeNKdt5jzKIDNUPHD0xZQ0cb_zsQbwrucoZtMVXL0og,4758
-statemachine/contrib/diagram/model.py,sha256=ZspysRy8WbJn4VDYkjoYe0mtao2dT9i6T005ehW5BxA,1498
-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=jzKBXJ_m9olnQLXu8SXbFgtdvbFyt5Ukr5uZNjXU0X8,19913
-statemachine/contrib/diagram/renderers/mermaid.py,sha256=jY6cUW9A_P8xLHISrSijx3GlpIl_Gnj3SgayspYq7DI,13526
-statemachine/contrib/diagram/renderers/table.py,sha256=iIdWnVgV7_PY8piSC-WWbEixZSksqXTOujAk6jrO7FQ,3736
-statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/engines/async_.py,sha256=Wtm3GRm2y9gWTevdPkJgnpY7RzZ97HVewWtwgDenoeU,22552
-statemachine/engines/base.py,sha256=bVPYyl_AWWzfjFWiLnDiofdOyb40pojr2qu--C4MHvQ,37993
-statemachine/engines/sync.py,sha256=F_bt4z1KLLcFCP77E9SNWDJMWiMTexE0iOU2XAd_x5A,9153
-statemachine/io/__init__.py,sha256=1J_oVSWrWmx9bLrGU-YoWyO-YYbO6T9Z6vUAnerKe3Q,8739
-statemachine/io/scxml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/io/scxml/actions.py,sha256=M1fAsuf0gJlnpMWXgoxCwpOk2MQSh8wBvtupp38T9n8,22491
-statemachine/io/scxml/invoke.py,sha256=raRStlMBOfxto6KIkCbi3jJ3UQ3QfuT0ezn4B48A670,8443
-statemachine/io/scxml/parser.py,sha256=zggZwu0rHZNWDaJTHD2XC3MrCy_bi4CNHStfWE9NHgU,16582
-statemachine/io/scxml/processor.py,sha256=_hjW4VTuzbPK2q5a7dp2kYMBcbRBZFbjz-wJKSZLI8I,9467
-statemachine/io/scxml/schema.py,sha256=xNpW_nkS2Z_hye5p1WLr8VhuM85Nic2HqRLCnoFN3ss,3927
-statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=j86vdOgdbE3vBA99RNil5JcMT7oCnyLrFBJYpLq5AxU,5338
-statemachine/locale/hi_IN/LC_MESSAGES/statemachine.po,sha256=iyDoGxxhvmOPdbNH6lSa2CnjuPC4cJ6wOuLhIKsXBDs,7948
-statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=Sm4RJe_NqBjGj1VGLOVQthW5-CBJbXhz0zbc5833Yq8,5814
-statemachine/locale/zh_CN/LC_MESSAGES/statemachine.po,sha256=y4D_bbD-bbgrkvwZuTPl6f1fGAx-panT-xiTlMZlxuQ,5363
-python_statemachine-3.1.2.dist-info/METADATA,sha256=k0pgPqHbJJtUT6oLMPjrf4zFzFwfEzzfqWFFTGkcp_s,12249
-python_statemachine-3.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_statemachine-3.1.2.dist-info/licenses/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
-python_statemachine-3.1.2.dist-info/RECORD,,