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

statemachine/contrib/diagram/renderers/mermaid.py

@@ -1,8 +1,4 @@
 from dataclasses import dataclass
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Set
 
 from ..model import ActionType
 from ..model import DiagramAction
@@ -34,14 +30,14 @@ class MermaidRenderer:
     Compound states outside parallel regions are left unchanged.
     """
 
-    def __init__(self, config: Optional[MermaidRendererConfig] = None):
+    def __init__(self, config: MermaidRendererConfig | None = None):
         self.config = config or MermaidRendererConfig()
-        self._active_ids: List[str] = []
-        self._rendered_transitions: Set[tuple] = set()
-        self._compound_ids: Set[str] = set()
-        self._initial_child_map: Dict[str, str] = {}
-        self._parallel_descendant_ids: Set[str] = set()
-        self._all_descendants_map: Dict[str, Set[str]] = {}
+        self._active_ids: list[str] = []
+        self._rendered_transitions: set[tuple] = set()
+        self._compound_ids: set[str] = set()
+        self._initial_child_map: dict[str, str] = {}
+        self._parallel_descendant_ids: set[str] = set()
+        self._all_descendants_map: dict[str, set[str]] = {}
 
     def render(self, graph: DiagramGraph) -> str:
         """Render a DiagramGraph to a Mermaid stateDiagram-v2 string."""
@@ -52,7 +48,7 @@ class MermaidRenderer:
         self._parallel_descendant_ids = self._collect_parallel_descendants(graph.states)
         self._all_descendants_map = self._build_all_descendants_map(graph.states)
 
-        lines: List[str] = []
+        lines: list[str] = []
         lines.append("stateDiagram-v2")
         lines.append(f"    direction {self.config.direction}")
 
@@ -70,9 +66,9 @@ class MermaidRenderer:
 
         return "\n".join(lines) + "\n"
 
-    def _build_initial_child_map(self, states: List[DiagramState]) -> Dict[str, str]:
+    def _build_initial_child_map(self, states: list[DiagramState]) -> dict[str, str]:
         """Build a map from compound state ID to its initial child ID (recursive)."""
-        result: Dict[str, str] = {}
+        result: dict[str, str] = {}
         for state in states:
             if state.children:
                 initial = next((c for c in state.children if c.is_initial), None)
@@ -83,11 +79,11 @@ class MermaidRenderer:
 
     @staticmethod
     def _collect_parallel_descendants(
-        states: List[DiagramState],
+        states: list[DiagramState],
         inside_parallel: bool = False,
-    ) -> Set[str]:
+    ) -> set[str]:
         """Collect IDs of all states that are descendants of a parallel state."""
-        result: Set[str] = set()
+        result: set[str] = set()
         for state in states:
             if inside_parallel:
                 result.add(state.id)
@@ -97,9 +93,9 @@ class MermaidRenderer:
             )
         return result
 
-    def _build_all_descendants_map(self, states: List[DiagramState]) -> Dict[str, Set[str]]:
+    def _build_all_descendants_map(self, states: list[DiagramState]) -> dict[str, set[str]]:
         """Map each compound state ID to the set of all its descendant IDs."""
-        result: Dict[str, Set[str]] = {}
+        result: dict[str, set[str]] = {}
         for state in states:
             if state.children:
                 result[state.id] = self._collect_recursive_descendants(state.children)
@@ -107,9 +103,9 @@ class MermaidRenderer:
         return result
 
     @staticmethod
-    def _collect_recursive_descendants(states: List[DiagramState]) -> Set[str]:
+    def _collect_recursive_descendants(states: list[DiagramState]) -> set[str]:
         """Collect all state IDs in a subtree recursively."""
-        ids: Set[str] = set()
+        ids: set[str] = set()
         for s in states:
             ids.add(s.id)
             ids.update(MermaidRenderer._collect_recursive_descendants(s.children))
@@ -132,9 +128,9 @@ class MermaidRenderer:
 
     def _render_states(
         self,
-        states: List[DiagramState],
-        transitions: List[DiagramTransition],
-        lines: List[str],
+        states: list[DiagramState],
+        transitions: list[DiagramTransition],
+        lines: list[str],
         indent: int,
     ) -> None:
         for state in states:
@@ -167,7 +163,7 @@ class MermaidRenderer:
     def _render_atomic_state(
         self,
         state: DiagramState,
-        lines: List[str],
+        lines: list[str],
         indent: int,
     ) -> None:
         pad = "    " * indent
@@ -186,8 +182,8 @@ class MermaidRenderer:
     def _render_compound_state(
         self,
         state: DiagramState,
-        transitions: List[DiagramTransition],
-        lines: List[str],
+        transitions: list[DiagramTransition],
+        lines: list[str],
         indent: int,
     ) -> None:
         pad = "    " * indent
@@ -227,18 +223,18 @@ class MermaidRenderer:
         if state.is_active:
             self._active_ids.append(state.id)
 
-    def _collect_all_descendant_ids(self, states: List[DiagramState]) -> Set[str]:
+    def _collect_all_descendant_ids(self, states: list[DiagramState]) -> set[str]:
         """Collect all state IDs in a subtree (direct children only for scope)."""
-        ids: Set[str] = set()
+        ids: set[str] = set()
         for s in states:
             ids.add(s.id)
         return ids
 
     def _render_scope_transitions(
         self,
-        transitions: List[DiagramTransition],
-        scope_ids: Set[str],
-        lines: List[str],
+        transitions: list[DiagramTransition],
+        scope_ids: set[str],
+        lines: list[str],
         indent: int,
     ) -> None:
         """Render transitions that belong to this scope level.
@@ -257,8 +253,8 @@ class MermaidRenderer:
         are redirected to the compound's initial child via ``_resolve_endpoint``.
         """
         # Build the descendant sets for compounds in this scope
-        compound_descendants: Dict[str, Set[str]] = {}
-        expanded: Set[str] = set(scope_ids)
+        compound_descendants: dict[str, set[str]] = {}
+        expanded: set[str] = set(scope_ids)
         for sid in scope_ids:
             if sid in self._all_descendants_map:
                 compound_descendants[sid] = self._all_descendants_map[sid]
@@ -295,8 +291,8 @@ class MermaidRenderer:
     @staticmethod
     def _is_fully_internal(
         source: str,
-        targets: List[str],
-        compound_descendants: Dict[str, Set[str]],
+        targets: list[str],
+        compound_descendants: dict[str, set[str]],
     ) -> bool:
         """Check if all endpoints belong to the same compound's descendants."""
         for descendants in compound_descendants.values():
@@ -309,11 +305,11 @@ class MermaidRenderer:
         transition: DiagramTransition,
         source: str,
         target: str,
-        lines: List[str],
+        lines: list[str],
         indent: int,
     ) -> None:
         pad = "    " * indent
-        label_parts: List[str] = []
+        label_parts: list[str] = []
         if transition.event:
             label_parts.append(transition.event)
         if transition.guards:
@@ -333,8 +329,8 @@ class MermaidRenderer:
 
     def _render_initial_and_final(
         self,
-        states: List[DiagramState],
-        lines: List[str],
+        states: list[DiagramState],
+        lines: list[str],
         indent: int,
     ) -> None:
         """Render top-level [*] --> initial and final --> [*] arrows."""

statemachine/contrib/diagram/renderers/table.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ..model import DiagramGraph
 from ..model import DiagramState
 from ..model import DiagramTransition
@@ -26,11 +24,11 @@ class TransitionTableRenderer:
 
     def _collect_rows(
         self,
-        states: List[DiagramState],
-        transitions: List[DiagramTransition],
-    ) -> "List[tuple[str, str, str, str]]":
+        states: list[DiagramState],
+        transitions: list[DiagramTransition],
+    ) -> "list[tuple[str, str, str, str]]":
         """Collect (State, Event, Guard, Target) tuples from the IR."""
-        rows: List[tuple[str, str, str, str]] = []
+        rows: list[tuple[str, str, str, str]] = []
         state_names = self._build_state_name_map(states)
 
         for t in transitions:
@@ -50,7 +48,7 @@ class TransitionTableRenderer:
 
         return rows
 
-    def _build_state_name_map(self, states: List[DiagramState]) -> dict:
+    def _build_state_name_map(self, states: list[DiagramState]) -> dict:
         """Build a mapping from state ID to display name, recursively."""
         result: dict = {}
         for state in states:
@@ -59,7 +57,7 @@ class TransitionTableRenderer:
                 result.update(self._build_state_name_map(state.children))
         return result
 
-    def _render_md(self, rows: "List[tuple[str, str, str, str]]") -> str:
+    def _render_md(self, rows: "list[tuple[str, str, str, str]]") -> str:
         """Render as a markdown table."""
         headers = ("State", "Event", "Guard", "Target")
         col_widths = [len(h) for h in headers]
@@ -79,7 +77,7 @@ class TransitionTableRenderer:
 
         return "\n".join(lines) + "\n"
 
-    def _render_rst(self, rows: "List[tuple[str, str, str, str]]") -> str:
+    def _render_rst(self, rows: "list[tuple[str, str, str, str]]") -> str:
         """Render as an RST grid table."""
         headers = ("State", "Event", "Guard", "Target")
         col_widths = [len(h) for h in headers]

statemachine/contrib/weighted.py

@@ -1,10 +1,7 @@
 import random
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Tuple
-from typing import Union
+from typing import TypeAlias
 
 from statemachine.callbacks import CallbackPriority
 from statemachine.transition_list import TransitionList
@@ -20,7 +17,7 @@ class _WeightedGroup:
     the selected index. Subsequent conds check against the cache.
     """
 
-    def __init__(self, weights: List[float], seed: "int | float | str | None" = None):
+    def __init__(self, weights: list[float], seed: "int | float | str | None" = None):
         self.weights = weights
         self.rng = random.Random(seed)
         self._selected: "int | None" = None
@@ -60,10 +57,9 @@ def _make_weighted_cond(index: int, group: _WeightedGroup, weight: float, total_
 
 # Type alias for a weighted destination:
 #   (target, weight)  or  (target, weight, kwargs_dict)
-_WeightedDest = Union[
-    Tuple["State", Union[int, float]],
-    Tuple["State", Union[int, float], Dict[str, Any]],
-]
+_WeightedDest: TypeAlias = (
+    tuple["State", int | float] | tuple["State", int | float, dict[str, Any]]
+)
 
 
 def to(target: "State", weight: "int | float", **kwargs: Any) -> _WeightedDest:
@@ -97,7 +93,7 @@ def to(target: "State", weight: "int | float", **kwargs: Any) -> _WeightedDest:
     return (target, weight, kwargs)
 
 
-def _validate_dest(i: int, item: Any) -> "Tuple[State, float, Dict[str, Any]]":
+def _validate_dest(i: int, item: Any) -> "tuple[State, float, dict[str, Any]]":
     """Validate and normalize a single ``(target, weight[, kwargs])`` tuple."""
     from statemachine.state import State
 
@@ -109,7 +105,7 @@ def _validate_dest(i: int, item: Any) -> "Tuple[State, float, Dict[str, Any]]":
 
     if len(item) == 2:
         target, weight = item
-        kwargs: Dict[str, Any] = {}
+        kwargs: dict[str, Any] = {}
     else:
         target, weight, kwargs = item
         if not isinstance(kwargs, dict):

statemachine/dispatcher.py

@@ -1,14 +1,11 @@
+from collections.abc import Callable
+from collections.abc import Iterable
 from dataclasses import dataclass
 from functools import partial
 from functools import reduce
 from operator import attrgetter
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Callable
-from typing import Iterable
-from typing import List
-from typing import Set
-from typing import Tuple
 
 from .callbacks import SPECS_ALL
 from .callbacks import SpecReference
@@ -37,7 +34,7 @@ class Listener:
     """
 
     obj: object
-    all_attrs: Set[str]
+    all_attrs: set[str]
     resolver_id: str
 
     @classmethod
@@ -58,8 +55,8 @@ class Listener:
 class Listeners:
     """Listeners that provides attributes to be used as callbacks."""
 
-    items: Tuple[Listener, ...]
-    all_attrs: Set[str]
+    items: tuple[Listener, ...]
+    all_attrs: set[str]
 
     @classmethod
     def from_listeners(cls, listeners: Iterable["Listener"]) -> "Listeners":
@@ -86,7 +83,7 @@ class Listeners:
                 executor.add(key, spec, builder)
 
     def _take_callback(self, name: str, names_not_found_handler: Callable) -> Callable:
-        callbacks: List[Callable] = []
+        callbacks: list[Callable] = []
         for key, builder in self.search_name(name):
             callback = builder()
             callback.unique_key = key  # type: ignore[attr-defined]
@@ -114,7 +111,7 @@ class Listeners:
 
         # Resolves boolean expressions
 
-        names_not_found: Set[str] = set()
+        names_not_found: set[str] = set()
         take_callback_partial = partial(
             self._take_callback, names_not_found_handler=names_not_found.add
         )
@@ -162,7 +159,11 @@ class Listeners:
         if not spec.is_bounded:
             for listener in self.items:
                 func = getattr(listener.obj, spec.attr_name, None)
-                if func is not None and func.__func__ is spec.func:
+                # ``getattr`` may return a non-method that happens to share the name
+                # (e.g. a model attribute named like a compiled guard); it is not the
+                # unbounded method we are rebinding, so skip it instead of accessing
+                # ``__func__`` (which would raise on a plain value).
+                if getattr(func, "__func__", None) is spec.func:
                     yield listener.build_key(spec.attr_name), partial(callable_method, func)
                     return
 
@@ -228,5 +229,5 @@ def event_method(func) -> Callable:
     return method
 
 
-def resolver_factory_from_objects(*objects: Tuple[Any, ...]):
+def resolver_factory_from_objects(*objects: tuple[Any, ...]):
     return Listeners.from_listeners(Listener.from_obj(o) for o in objects)

statemachine/engines/async_.py

@@ -1,10 +1,9 @@
 import asyncio
 import contextvars
+from collections.abc import Callable
 from itertools import chain
 from time import time
 from typing import TYPE_CHECKING
-from typing import Callable
-from typing import List
 
 from ..event_data import EventData
 from ..event_data import TriggerData
@@ -143,7 +142,7 @@ class AsyncEngine(BaseEngine):
 
     async def _execute_transition_content(
         self,
-        enabled_transitions: "List[Transition]",
+        enabled_transitions: "list[Transition]",
         trigger_data: TriggerData,
         get_key: "Callable[[Transition], str]",
         set_target_as_state: bool = False,
@@ -164,7 +163,7 @@ class AsyncEngine(BaseEngine):
         return result
 
     async def _exit_states(  # type: ignore[override]
-        self, enabled_transitions: "List[Transition]", trigger_data: TriggerData
+        self, enabled_transitions: "list[Transition]", trigger_data: TriggerData
     ) -> "OrderedSet[State]":
         ordered_states, result = self._prepare_exit_states(enabled_transitions)
         on_error = self._on_error_handler()
@@ -188,7 +187,7 @@ class AsyncEngine(BaseEngine):
 
     async def _enter_states(  # noqa: C901
         self,
-        enabled_transitions: "List[Transition]",
+        enabled_transitions: "list[Transition]",
         trigger_data: TriggerData,
         states_to_exit: "OrderedSet[State]",
         previous_configuration: "OrderedSet[State]",
@@ -270,7 +269,7 @@ class AsyncEngine(BaseEngine):
 
         return result
 
-    async def microstep(self, transitions: "List[Transition]", trigger_data: TriggerData):
+    async def microstep(self, transitions: "list[Transition]", trigger_data: TriggerData):
         self._microstep_count += 1
         self._debug(
             "%s macro:%d micro:%d transitions: %s",

statemachine/engines/base.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass
 from dataclasses import field
 from itertools import chain
@@ -7,9 +8,6 @@ from queue import Queue
 from threading import Lock
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Callable
-from typing import Dict
-from typing import List
 from typing import cast
 
 from ..event import BoundEvent
@@ -91,7 +89,7 @@ class BaseEngine:
         self._sentinel = object()
         self.running = True
         self._processing = Lock()
-        self._cache: Dict = {}  # Cache for _get_args_kwargs results
+        self._cache: dict = {}  # Cache for _get_args_kwargs results
         self._invoke_manager = InvokeManager(self)
         self._macrostep_count: int = 0
         self._microstep_count: int = 0
@@ -243,7 +241,7 @@ class BaseEngine:
 
         return filtered_transitions
 
-    def _compute_exit_set(self, transitions: List[Transition]) -> OrderedSet[StateTransition]:
+    def _compute_exit_set(self, transitions: list[Transition]) -> OrderedSet[StateTransition]:
         """Compute the exit set for a transition."""
 
         states_to_exit = OrderedSet[StateTransition]()
@@ -286,7 +284,7 @@ class BaseEngine:
             return self.find_lcca([transition.source] + list(states))
 
     @staticmethod
-    def find_lcca(states: List[State]) -> "State | None":
+    def find_lcca(states: list[State]) -> "State | None":
         """
         Find the Least Common Compound Ancestor (LCCA) of the given list of states.
 
@@ -371,7 +369,7 @@ class BaseEngine:
 
         return self._filter_conflicting_transitions(enabled_transitions)
 
-    def microstep(self, transitions: List[Transition], trigger_data: TriggerData):
+    def microstep(self, transitions: list[Transition], trigger_data: TriggerData):
         """Process a single set of transitions in a 'lock step'.
         This includes exiting states, executing transition content, and entering states.
         """
@@ -454,7 +452,7 @@ class BaseEngine:
 
     def _prepare_exit_states(
         self,
-        enabled_transitions: List[Transition],
+        enabled_transitions: list[Transition],
     ) -> "tuple[list[StateTransition], OrderedSet[State]]":
         """Compute exit set, sort, and update history. Pure computation, no callbacks."""
         states_to_exit = self._compute_exit_set(enabled_transitions)
@@ -491,7 +489,7 @@ class BaseEngine:
             self.sm._config.discard(state)
 
     def _exit_states(
-        self, enabled_transitions: List[Transition], trigger_data: TriggerData
+        self, enabled_transitions: list[Transition], trigger_data: TriggerData
     ) -> OrderedSet[State]:
         """Compute and process the states to exit for the given transitions."""
         ordered_states, result = self._prepare_exit_states(enabled_transitions)
@@ -515,7 +513,7 @@ class BaseEngine:
 
     def _execute_transition_content(
         self,
-        enabled_transitions: List[Transition],
+        enabled_transitions: list[Transition],
         trigger_data: TriggerData,
         get_key: Callable[[Transition], str],
         set_target_as_state: bool = False,
@@ -537,10 +535,10 @@ class BaseEngine:
 
     def _prepare_entry_states(
         self,
-        enabled_transitions: List[Transition],
+        enabled_transitions: list[Transition],
         states_to_exit: OrderedSet[State],
         previous_configuration: OrderedSet[State],
-    ) -> "tuple[list[StateTransition], OrderedSet[StateTransition], Dict[str, Any], OrderedSet[State]]":  # noqa: E501
+    ) -> "tuple[list[StateTransition], OrderedSet[StateTransition], dict[str, Any], OrderedSet[State]]":  # noqa: E501
         """Compute entry set, ordering, and new configuration. Pure computation, no callbacks.
 
         Returns:
@@ -548,7 +546,7 @@ class BaseEngine:
         """
         states_to_enter = OrderedSet[StateTransition]()
         states_for_default_entry = OrderedSet[StateTransition]()
-        default_history_content: Dict[str, Any] = {}
+        default_history_content: dict[str, Any] = {}
 
         self.compute_entry_set(
             enabled_transitions, states_to_enter, states_for_default_entry, default_history_content
@@ -626,7 +624,7 @@ class BaseEngine:
 
     def _enter_states(  # noqa: C901
         self,
-        enabled_transitions: List[Transition],
+        enabled_transitions: list[Transition],
         trigger_data: TriggerData,
         states_to_exit: OrderedSet[State],
         previous_configuration: OrderedSet[State],

statemachine/event.py

@@ -1,6 +1,5 @@
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import List
 from typing import cast
 from uuid import uuid4
 
@@ -189,7 +188,7 @@ class Event(AddCallbacksMixin, str):
 
     def split(  # type: ignore[override]
         self, sep: "str | None" = None, maxsplit: int = -1
-    ) -> List["Event"]:
+    ) -> list["Event"]:
         result = super().split(sep, maxsplit)
         if len(result) == 1:
             return [self]

statemachine/exceptions.py

@@ -1,5 +1,5 @@
+from collections.abc import MutableSet
 from typing import TYPE_CHECKING
-from typing import MutableSet
 
 from .i18n import _
 

statemachine/factory.py

@@ -1,9 +1,5 @@
 import re
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
 
 from . import registry
 from .callbacks import CallbackGroup
@@ -39,8 +35,8 @@ class StateMachineMetaclass(type):
     def __init__(
         cls,
         name: str,
-        bases: Tuple[type],
-        attrs: Dict[str, Any],
+        bases: tuple[type],
+        attrs: dict[str, Any],
     ) -> None:
         super().__init__(name, bases, attrs)
         registry.register(cls)
@@ -49,13 +45,13 @@ class StateMachineMetaclass(type):
         # TODO: Experiment with the IDEA of a root state
         # cls.root = State(id=cls.id, name=cls.name)
         cls.states: States = States()
-        cls.states_map: Dict[Any, State] = {}
+        cls.states_map: dict[Any, State] = {}
         """Map of ``state.value`` to the corresponding :ref:`state`."""
 
         cls._abstract = True
-        cls._events: Dict[Event, None] = {}  # used Dict to preserve order and avoid duplicates
+        cls._events: dict[Event, None] = {}  # used Dict to preserve order and avoid duplicates
         cls._protected_attrs: set = set()
-        cls._events_to_update: Dict[Event, Optional[Event]] = {}
+        cls._events_to_update: dict[Event, Event | None] = {}
         cls._specs = CallbackSpecList()
         cls.prepare = cls._specs.grouper(CallbackGroup.PREPARE).add(
             "prepare_event", priority=CallbackPriority.GENERIC, is_convention=True
@@ -88,7 +84,7 @@ class StateMachineMetaclass(type):
         else:  # pragma: no cover
             cls.initial_state = None
 
-        cls.final_states: List[State] = [state for state in cls.states if state.final]
+        cls.final_states: list[State] = [state for state in cls.states if state.final]
 
         cls._check()
         cls._setup()
@@ -99,7 +95,7 @@ class StateMachineMetaclass(type):
     def _expand_docstring(cls) -> None:
         """Replace ``{statechart:FORMAT}`` placeholders in the class docstring."""
         doc = cls.__doc__
-        if not doc:
+        if not doc or not cls._STATECHART_RE.search(doc):
             return
 
         from .contrib.diagram.formatter import formatter
@@ -130,10 +126,10 @@ class StateMachineMetaclass(type):
         return formatter.render(cls, fmt)  # type: ignore[arg-type]
 
     def _initials_by_document_order(  # noqa: C901
-        cls, states: List[State], parent: "State | None" = None, order: int = 1
+        cls, states: list[State], parent: "State | None" = None, order: int = 1
     ):
         """Set initial state by document order if no explicit initial state is set"""
-        initials: List[State] = []
+        initials: list[State] = []
         for s in states:
             s.document_order = order
             order += 1
@@ -272,13 +268,13 @@ class StateMachineMetaclass(type):
             "send",
         } | {s.id for s in cls.states}
 
-    def _collect_class_listeners(cls, attrs: Dict[str, Any], bases: Tuple[type]):
+    def _collect_class_listeners(cls, attrs: dict[str, Any], bases: tuple[type]):
         """Collect class-level listener declarations from attrs and MRO.
 
         Listeners declared on parent classes are prepended (MRO order),
         unless the child sets ``listeners_inherit = False``.
         """
-        class_listeners: List[Any] = []
+        class_listeners: list[Any] = []
         if attrs.get("listeners_inherit", True):
             for base in reversed(bases):
                 class_listeners.extend(getattr(base, "_class_listeners", []))
@@ -291,7 +287,7 @@ class StateMachineMetaclass(type):
                     ).format(entry)
                 )
             class_listeners.append(entry)
-        cls._class_listeners: List[Any] = class_listeners
+        cls._class_listeners: list[Any] = class_listeners
 
     def add_inherited(cls, bases):
         for base in bases:

statemachine/graph.py

@@ -1,7 +1,7 @@
 from collections import deque
+from collections.abc import Iterable
+from collections.abc import MutableSet
 from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import MutableSet
 
 if TYPE_CHECKING:
     from .state import State