python-statemachine 3.1.2__py3-none-any.whl → 3.2.1__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
@@ -17,6 +14,7 @@ from .event import Event
 from .exceptions import InvalidDefinition
 from .i18n import _
 from .signature import SignatureAdapter
+from .spec_parser import UnsupportedExpression
 from .spec_parser import custom_and
 from .spec_parser import operator_mapping
 from .spec_parser import parse_boolean_expr
@@ -37,7 +35,7 @@ class Listener:
     """
 
     obj: object
-    all_attrs: Set[str]
+    all_attrs: set[str]
     resolver_id: str
 
     @classmethod
@@ -58,8 +56,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 +84,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,14 +112,17 @@ 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
         )
 
         try:
             expression = parse_boolean_expr(spec.func, take_callback_partial, operator_mapping)
-        except SyntaxError as err:
+        except (SyntaxError, UnsupportedExpression) as err:
+            # ``UnsupportedExpression`` comes from the AST allowlist rejecting a node
+            # kind that cannot appear in a boolean expression (e.g. ``"user.age"``).
+            # Errors raised while resolving names are not parse errors and propagate.
             raise InvalidDefinition(
                 _("Failed to parse boolean expression '{}'").format(spec.func)
             ) from err
@@ -162,7 +163,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 +233,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
@@ -72,17 +71,27 @@ class AsyncEngine(BaseEngine):
     # --- Callback dispatch overrides (async versions of BaseEngine methods) ---
 
     async def _get_args_kwargs(
-        self, transition: "Transition", trigger_data: TriggerData, target: "State | None" = None
+        self,
+        transition: "Transition",
+        trigger_data: TriggerData,
+        target: "State | None" = None,
+        source: "State | None" = None,
     ):
-        cache_key = (id(transition), id(trigger_data), id(target))
+        cache_key = (id(transition), id(trigger_data), id(target), id(source))
 
         if cache_key in self._cache:
             return self._cache[cache_key]
 
         event_data = EventData(trigger_data=trigger_data, transition=transition)
+        # See the sync engine for the rationale: bind `state`/`target` to the
+        # entered state and `state`/`source` to the exited state, keeping the
+        # generic enter/exit callbacks symmetric across compound boundaries.
         if target:
             event_data.state = target
             event_data.target = target
+        if source:
+            event_data.state = source
+            event_data.source = source
 
         args, kwargs = event_data.args, event_data.extended_kwargs
 
@@ -143,7 +152,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 +173,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()
@@ -174,7 +183,9 @@ class AsyncEngine(BaseEngine):
             if info.state is not None:  # pragma: no branch
                 self._invoke_manager.cancel_for_state(info.state)
 
-            args, kwargs = await self._get_args_kwargs(info.transition, trigger_data)
+            args, kwargs = await self._get_args_kwargs(
+                info.transition, trigger_data, source=info.state
+            )
 
             if info.state is not None:  # pragma: no branch
                 self._debug("%s Exiting state: %s", self._log_id, info.state)
@@ -188,7 +199,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 +281,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.
         """
@@ -421,19 +419,30 @@ class BaseEngine:
         return result
 
     def _get_args_kwargs(
-        self, transition: Transition, trigger_data: TriggerData, target: "State | None" = None
+        self,
+        transition: Transition,
+        trigger_data: TriggerData,
+        target: "State | None" = None,
+        source: "State | None" = None,
     ):
         # Generate a unique key for the cache, the cache is invalidated once per loop
-        cache_key = (id(transition), id(trigger_data), id(target))
+        cache_key = (id(transition), id(trigger_data), id(target), id(source))
 
         # Check the cache for existing results
         if cache_key in self._cache:
             return self._cache[cache_key]
 
         event_data = EventData(trigger_data=trigger_data, transition=transition)
+        # Bind `state`/`target` to the individual state being entered, and
+        # `state`/`source` to the individual state being exited, so the generic
+        # `on_enter_state`/`on_exit_state` callbacks stay symmetric when crossing
+        # compound state boundaries (the transition only knows its own endpoints).
         if target:
             event_data.state = target
             event_data.target = target
+        if source:
+            event_data.state = source
+            event_data.source = source
 
         args, kwargs = event_data.args, event_data.extended_kwargs
 
@@ -454,7 +463,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 +500,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)
@@ -502,7 +511,7 @@ class BaseEngine:
             if info.state is not None:  # pragma: no branch
                 self._invoke_manager.cancel_for_state(info.state)
 
-            args, kwargs = self._get_args_kwargs(info.transition, trigger_data)
+            args, kwargs = self._get_args_kwargs(info.transition, trigger_data, source=info.state)
 
             # Execute `onexit` handlers — same per-block error isolation as onentry.
             if info.state is not None:  # pragma: no branch
@@ -515,7 +524,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 +546,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 +557,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 +635,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 _
 
@@ -36,7 +36,7 @@ class TransitionNotAllowed(StateMachineError):
     def __init__(self, event: "Event | None", configuration: MutableSet["State"]):
         self.event = event
         self.configuration = configuration
-        name = ", ".join([s.name for s in configuration])
+        name = ", ".join(str(s.name) for s in configuration)
         msg = _("Can't {} when in {}.").format(
             self.event and self.event.name or "transition", name
         )