python-statemachine 2.1.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

{python_statemachine-2.1.2.dist-info → python_statemachine-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-statemachine
-Version: 2.1.2
+Version: 2.2.0
 Summary: Python Finite State Machines made easy.
 Home-page: https://github.com/fgmacedo/python-statemachine
 License: MIT
@@ -8,17 +8,17 @@ Author: Fernando Macedo
 Author-email: fgmacedo@gmail.com
 Maintainer: Fernando Macedo
 Maintainer-email: fgmacedo@gmail.com
-Requires-Python: >=3.7,<3.13
+Requires-Python: >=3.9,<3.13
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Software Development :: Libraries
 Provides-Extra: diagrams
 Description-Content-Type: text/markdown

python_statemachine-2.2.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+statemachine/__init__.py,sha256=nhqSQwRfWBVrcn4h-aLlxLbzeSsjt6lE_SSFnFWK0FY,192
+statemachine/callbacks.py,sha256=QMh564YuNVNV74VxlIyvlF_eW6njsmV9VHauQH9JR1U,8704
+statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/contrib/diagram.py,sha256=CTlNRtAHEzCCzRUlxkiyzJOCOp1CohihdD0_7pHrx4c,7004
+statemachine/dispatcher.py,sha256=i9ChhdomQpVbTg9vNS3xoCHUAw3Z32B0UPzK47nb1-A,4924
+statemachine/event.py,sha256=fvWxyFcrbPVxNW94p66rGJ5I1UZUK9mDJz68udkz2JI,2106
+statemachine/event_data.py,sha256=nxOfypngK-78A77gj4pS-oxLx9zl1S9wnSt_rTiCyZA,2257
+statemachine/events.py,sha256=rUbiTX-QGoo7zzmQMEeWeLrIVnp9zhicdRIm34CoAVI,731
+statemachine/exceptions.py,sha256=uzvDbHkzCZkmFI_02L0yC9gd6d0SBn9GmsI8ekc0Hjk,952
+statemachine/factory.py,sha256=m2TeJ19eDIymoGADDp0G0ItrrcCRgIJoJYFJ5lzqmWE,8015
+statemachine/graph.py,sha256=KtwB1CYckaLjTgQD9tEeuaEzJje9q3fPVpBViW5TgSk,487
+statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
+statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=MfODCwzML6DzhOpHbno2Pdhsb26AWboR5Ka1JCNvJIA,1685
+statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=KsR9rlnhw17EZG-IbVx3F0wJAJSK0B-OByGmUmDHDUM,2375
+statemachine/mixins.py,sha256=B8WB3EGyZpMWAQg4Nw3kUMCfswgmLCChDpOQdxR28eE,1017
+statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
+statemachine/registry.py,sha256=RnVBRS3I_6Tm2OMgXMB_ewX7zQaslqEfhXFOhbqIkG4,959
+statemachine/signature.py,sha256=9KItptchQlP2VpNmBiIFXLNAWNWY3Bs_ymUd7OOgDD4,7507
+statemachine/state.py,sha256=bZki0DyemZa-aVAfollQCmpXxesWONzUmE28eDfqz3o,8315
+statemachine/statemachine.py,sha256=U0rLIUhvsCivth1uNb0pt2xWVUnDbzhXF982yJH-bg0,11659
+statemachine/states.py,sha256=gdGemJYF9k-cifs9Tk0Pe_-1u1Lanf3l08o0t8wAMgg,4203
+statemachine/transition.py,sha256=ebRhJsjOoLya7oYZVjRAKvjq1EsC9ImpExgHANekVMA,5388
+statemachine/transition_list.py,sha256=DatsmMWgK0YK30Nrj-josVvlTgeGapKutzYur9-puF8,5949
+statemachine/utils.py,sha256=fV-Hz1gnyl4tAs9nPr2u9I9zfxq62mokPV8mUpIJc1k,458
+python_statemachine-2.2.0.dist-info/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
+python_statemachine-2.2.0.dist-info/METADATA,sha256=qH4SxonFNJStkKVocZABu-RLiYD54DcON2gNGjBPGGQ,11454
+python_statemachine-2.2.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+python_statemachine-2.2.0.dist-info/RECORD,,

statemachine/__init__.py

@@ -3,6 +3,6 @@ from .statemachine import StateMachine
 
 __author__ = """Fernando Macedo"""
 __email__ = "fgmacedo@gmail.com"
-__version__ = "2.1.2"
+__version__ = "2.2.0"
 
 __all__ = ["StateMachine", "State"]

statemachine/callbacks.py

@@ -1,7 +1,10 @@
+from bisect import insort
 from collections import defaultdict
 from collections import deque
+from enum import IntEnum
 from typing import Callable
 from typing import Dict
+from typing import Generator
 from typing import List
 
 from .exceptions import AttrNotFound
@@ -9,27 +12,42 @@ from .i18n import _
 from .utils import ensure_iterable
 
 
+class CallbackPriority(IntEnum):
+    GENERIC = 0
+    INLINE = 10
+    DECORATOR = 20
+    NAMING = 30
+    AFTER = 40
+
+
+def allways_true(*args, **kwargs):
+    return True
+
+
 class CallbackWrapper:
     def __init__(
         self,
         callback: Callable,
         condition: Callable,
+        meta: "CallbackMeta",
         unique_key: str,
-        expected_value: "bool | None" = None,
     ) -> None:
         self._callback = callback
         self.condition = condition
+        self.meta = meta
         self.unique_key = unique_key
-        self.expected_value = expected_value
 
     def __repr__(self):
         return f"{type(self).__name__}({self.unique_key})"
 
+    def __str__(self):
+        return str(self.meta)
+
+    def __lt__(self, other):
+        return self.meta.priority < other.meta.priority
+
     def __call__(self, *args, **kwargs):
-        result = self._callback(*args, **kwargs)
-        if self.expected_value is not None:
-            return bool(result) == self.expected_value
-        return result
+        return self._callback(*args, **kwargs)
 
 
 class CallbackMeta:
@@ -42,14 +60,22 @@ class CallbackMeta:
     call is performed, to allow the proper callback resolution.
     """
 
-    def __init__(self, func, suppress_errors=False, cond=None, expected_value=None):
+    def __init__(
+        self,
+        func,
+        suppress_errors=False,
+        cond=None,
+        priority: CallbackPriority = CallbackPriority.NAMING,
+        expected_value=None,
+    ):
         self.func = func
         self.suppress_errors = suppress_errors
-        self.cond = CallbackMetaList().add(cond)
+        self.cond = cond
         self.expected_value = expected_value
+        self.priority = priority
 
     def __repr__(self):
-        return f"{type(self).__name__}({self.func!r})"
+        return f"{type(self).__name__}({self.func!r}, suppress_errors={self.suppress_errors!r})"
 
     def __str__(self):
         return getattr(self.func, "__name__", self.func)
@@ -63,7 +89,10 @@ class CallbackMeta:
     def _update_func(self, func):
         self.func = func
 
-    def build(self, resolver) -> "CallbackWrapper | None":
+    def _wrap_callable(self, func, _expected_value):
+        return func
+
+    def build(self, resolver) -> Generator["CallbackWrapper", None, None]:
         """
         Resolves the `func` into a usable callable.
 
@@ -71,25 +100,14 @@ class CallbackMeta:
             resolver (callable): A method responsible to build and return a valid callable that
                 can receive arbitrary parameters like `*args, **kwargs`.
         """
-        callback = resolver(self.func)
-        if not callback.is_empty:
-            conditions = CallbacksExecutor()
-            conditions.add(self.cond, resolver)
-
-            return CallbackWrapper(
-                callback=callback,
-                condition=conditions.all,
+        for callback in resolver(self.func):
+            condition = next(resolver(self.cond)) if self.cond is not None else allways_true
+            yield CallbackWrapper(
+                callback=self._wrap_callable(callback, self.expected_value),
+                condition=condition,
+                meta=self,
                 unique_key=callback.unique_key,
-                expected_value=self.expected_value,
-            )
-
-        if not self.suppress_errors:
-            raise AttrNotFound(
-                _("Did not found name '{}' from model or statemachine").format(
-                    self.func
-                )
             )
-        return None
 
 
 class BoolCallbackMeta(CallbackMeta):
@@ -102,18 +120,32 @@ class BoolCallbackMeta(CallbackMeta):
     call is performed, to allow the proper callback resolution.
     """
 
-    def __init__(self, func, suppress_errors=False, cond=None, expected_value=True):
-        self.func = func
-        self.suppress_errors = suppress_errors
-        self.cond = CallbackMetaList().add(cond)
-        self.expected_value = expected_value
+    def __init__(
+        self,
+        func,
+        suppress_errors=False,
+        cond=None,
+        priority: CallbackPriority = CallbackPriority.NAMING,
+        expected_value=True,
+    ):
+        super().__init__(
+            func, suppress_errors, cond, priority=priority, expected_value=expected_value
+        )
 
     def __str__(self):
         name = super().__str__()
         return name if self.expected_value else f"!{name}"
 
+    def _wrap_callable(self, func, expected_value):
+        def bool_wrapper(*args, **kwargs):
+            return bool(func(*args, **kwargs)) == expected_value
+
+        return bool_wrapper
+
 
 class CallbackMetaList:
+    """List of `CallbackMeta` instances"""
+
     def __init__(self, factory=CallbackMeta):
         self.items: List[CallbackMeta] = []
         self.factory = factory
@@ -157,6 +189,7 @@ class CallbackMetaList:
         return func
 
     def __call__(self, callback):
+        """Allows usage of the callback list as a decorator."""
         return self._add_unbounded_callback(callback)
 
     def __iter__(self):
@@ -165,18 +198,13 @@ class CallbackMetaList:
     def clear(self):
         self.items = []
 
-    def _add(self, func, registry=None, prepend=False, **kwargs):
+    def _add(self, func, **kwargs):
         meta = self.factory(func, **kwargs)
-        if registry is not None and not registry(self, meta, prepend=prepend):
-            return
 
         if meta in self.items:
             return
 
-        if prepend:
-            self.items.insert(0, meta)
-        else:
-            self.items.append(meta)
+        self.items.append(meta)
         return meta
 
     def add(self, callbacks, **kwargs):
@@ -191,6 +219,8 @@ class CallbackMetaList:
 
 
 class CallbacksExecutor:
+    """A list of callbacks that can be executed in order."""
+
     def __init__(self):
         self.items: List[CallbackWrapper] = deque()
         self.items_already_seen = set()
@@ -201,34 +231,26 @@ class CallbacksExecutor:
     def __repr__(self):
         return f"{type(self).__name__}({self.items!r})"
 
-    def add_one(
-        self, callback_info: CallbackMeta, resolver: Callable, prepend: bool = False
-    ) -> "CallbackWrapper | None":
-        callback = callback_info.build(resolver)
-        if callback is None:
-            return None
+    def __str__(self):
+        return ", ".join(str(c) for c in self)
 
-        if callback.unique_key in self.items_already_seen:
-            return None
+    def _add(self, callback_meta: CallbackMeta, resolver: Callable):
+        for callback in callback_meta.build(resolver):
+            if callback.unique_key in self.items_already_seen:
+                continue
 
-        self.items_already_seen.add(callback.unique_key)
-        if prepend:
-            self.items.insert(0, callback)
-        else:
-            self.items.append(callback)
-        return callback
+            self.items_already_seen.add(callback.unique_key)
+            insort(self.items, callback)
 
     def add(self, items: CallbackMetaList, resolver: Callable):
         """Validate configurations"""
         for item in items:
-            self.add_one(item, resolver)
+            self._add(item, resolver)
         return self
 
     def call(self, *args, **kwargs):
         return [
-            callback(*args, **kwargs)
-            for callback in self
-            if callback.condition(*args, **kwargs)
+            callback(*args, **kwargs) for callback in self if callback.condition(*args, **kwargs)
         ]
 
     def all(self, *args, **kwargs):
@@ -237,24 +259,27 @@ class CallbacksExecutor:
 
 class CallbacksRegistry:
     def __init__(self) -> None:
-        self._registry: Dict[CallbackMetaList, CallbacksExecutor] = defaultdict(
-            CallbacksExecutor
-        )
+        self._registry: Dict[CallbackMetaList, CallbacksExecutor] = defaultdict(CallbacksExecutor)
 
-    def register(self, callbacks: CallbackMetaList, resolver):
-        executor_list = self[callbacks]
-        executor_list.add(callbacks, resolver)
+    def register(self, meta_list: CallbackMetaList, resolver):
+        executor_list = self[meta_list]
+        executor_list.add(meta_list, resolver)
         return executor_list
 
-    def __getitem__(self, callbacks: CallbackMetaList) -> CallbacksExecutor:
-        return self._registry[callbacks]
+    def clear(self):
+        self._registry.clear()
+
+    def __getitem__(self, meta_list: CallbackMetaList) -> CallbacksExecutor:
+        return self._registry[meta_list]
 
-    def build_register_function_for_resolver(self, resolver):
-        def register(
-            meta_list: CallbackMetaList,
-            meta: CallbackMeta,
-            prepend: bool = False,
-        ):
-            return self[meta_list].add_one(meta, resolver, prepend=prepend)
+    def check(self, meta_list: CallbackMetaList):
+        executor = self[meta_list]
+        for meta in meta_list:
+            if meta.suppress_errors:
+                continue
 
-        return register
+            if any(callback for callback in executor if callback.meta == meta):
+                continue
+            raise AttrNotFound(
+                _("Did not found name '{}' from model or statemachine").format(meta.func)
+            )

statemachine/contrib/diagram.py

@@ -66,21 +66,35 @@ class DotGraphMachine:
             fontsize=self.transition_font_size,
         )
 
+    def _actions_getter(self):
+        if isinstance(self.machine, StateMachine):
+
+            def getter(x):
+                return self.machine._callbacks(x)
+        else:
+
+            def getter(x):
+                return x
+
+        return getter
+
     def _state_actions(self, state):
-        entry = ", ".join([str(action) for action in state.enter])
-        exit = ", ".join([str(action) for action in state.exit])
+        getter = self._actions_getter()
+
+        entry = str(getter(state.enter))
+        exit_ = str(getter(state.exit))
         internal = ", ".join(
-            f"{transition.event} / {transition.on!s}"
+            f"{transition.event} / {str(getter(transition.on))}"
             for transition in state.transitions
             if transition.internal
         )
 
         if entry:
             entry = f"entry / {entry}"
-        if exit:
-            exit = f"exit / {exit}"
+        if exit_:
+            exit_ = f"exit / {exit_}"
 
-        actions = "\n".join(x for x in [entry, exit, internal] if x)
+        actions = "\n".join(x for x in [entry, exit_, internal] if x)
 
         if actions:
             actions = f"\n{actions}"

statemachine/dispatcher.py

@@ -1,6 +1,7 @@
 from collections import namedtuple
 from operator import attrgetter
 from typing import Any
+from typing import Generator
 
 from .signature import SignatureAdapter
 
@@ -18,17 +19,10 @@ class ObjectConfig(namedtuple("ObjectConfig", "obj skip_attrs resolver_id")):
         if isinstance(obj, ObjectConfig):
             return obj
         else:
-            return cls(obj, set(skip_attrs) if skip_attrs else set(), str(id(obj)))
-
-    def getattr(self, attr):
-        if attr in self.skip_attrs:
-            return
-        return getattr(self.obj, attr, None)
+            return cls(obj, skip_attrs or set(), str(id(obj)))
 
 
 class WrapSearchResult:
-    is_empty = False
-
     def __init__(self, attribute, resolver_id) -> None:
         self.attribute = attribute
         self.resolver_id = resolver_id
@@ -48,10 +42,6 @@ class WrapSearchResult:
         return self._cache(*args, **kwds)
 
 
-class EmptyWrapSearchResult(WrapSearchResult):
-    is_empty = True
-
-
 class CallableSearchResult(WrapSearchResult):
     def __init__(self, attribute, a_callable, resolver_id) -> None:
         self.a_callable = a_callable
@@ -93,32 +83,74 @@ class EventSearchResult(WrapSearchResult):
         return wrapper
 
 
-def search_callable(attr, *configs) -> WrapSearchResult:
-    if callable(attr) or isinstance(attr, property):
-        return CallableSearchResult(attr, attr, None)
+def _search_callable_attr_is_property(
+    attr, configs: tuple[ObjectConfig]
+) -> "WrapSearchResult | None":
+    # if the attr is a property, we'll try to find the object that has the
+    # property on the configs
+    attr_name = attr.fget.__name__
+    for obj, _skip_attrs, resolver_id in configs:
+        func = getattr(type(obj), attr_name, None)
+        if func is not None and func is attr:
+            return AttributeCallableSearchResult(attr_name, obj, resolver_id)
+    return None
 
-    for config in configs:
-        func = config.getattr(attr)
-        if func is not None:
-            if not callable(func):
-                return AttributeCallableSearchResult(
-                    attr, config.obj, config.resolver_id
-                )
 
-            if getattr(func, "_is_sm_event", False):
-                return EventSearchResult(attr, func, config.resolver_id)
+def _search_callable_attr_is_callable(attr, configs: tuple[ObjectConfig]) -> WrapSearchResult:
+    # if the attr is an unbounded method, we'll try to find the bounded method
+    # on the configs
+    if not hasattr(attr, "__self__"):
+        for obj, _skip_attrs, resolver_id in configs:
+            func = getattr(obj, attr.__name__, None)
+            if func is not None and func.__func__ is attr:
+                return CallableSearchResult(attr.__name__, func, resolver_id)
 
-            return CallableSearchResult(attr, func, config.resolver_id)
+    return CallableSearchResult(attr, attr, None)
 
-    return EmptyWrapSearchResult(attr, None)
 
+def _search_callable_in_configs(
+    attr, configs: tuple[ObjectConfig]
+) -> Generator[WrapSearchResult, None, None]:
+    for obj, skip_attrs, resolver_id in configs:
+        if attr in skip_attrs:
+            continue
 
-def resolver_factory(*objects):
-    """Factory that returns a configured resolver."""
+        if not hasattr(obj, attr):
+            continue
+
+        func = getattr(obj, attr)
+        if not callable(func):
+            yield AttributeCallableSearchResult(attr, obj, resolver_id)
+
+        if getattr(func, "_is_sm_event", False):
+            yield EventSearchResult(attr, func, resolver_id)
+
+        yield CallableSearchResult(attr, func, resolver_id)
 
-    objects = [ObjectConfig.from_obj(obj) for obj in objects]
 
-    def wrapper(attr):
-        return search_callable(attr, *objects)
+def search_callable(attr, configs: tuple) -> Generator[WrapSearchResult, None, None]:  # noqa: C901
+    if isinstance(attr, property):
+        result = _search_callable_attr_is_property(attr, configs)
+        if result is not None:
+            yield result
+        return
+
+    if callable(attr):
+        yield _search_callable_attr_is_callable(attr, configs)
+        return
+
+    yield from _search_callable_in_configs(attr, configs)
+
+
+def resolver_factory(objects: tuple[ObjectConfig]):
+    """Factory that returns a configured resolver."""
+
+    def wrapper(attr) -> Generator[WrapSearchResult, None, None]:
+        yield from search_callable(attr, objects)
 
     return wrapper
+
+
+def resolver_factory_from_objects(*objects: tuple[Any]):
+    configs = tuple(ObjectConfig.from_obj(o) for o in objects)
+    return resolver_factory(configs)

statemachine/factory.py

@@ -1,3 +1,4 @@
+import warnings
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Dict
@@ -9,6 +10,7 @@ from . import registry
 from .event import Event
 from .event import trigger_event_factory
 from .exceptions import InvalidDefinition
+from .graph import iterate_states_and_transitions
 from .graph import visit_connected_states
 from .i18n import _
 from .state import State
@@ -18,7 +20,15 @@ from .transition_list import TransitionList
 
 
 class StateMachineMetaclass(type):
-    def __init__(cls, name: str, bases: Tuple[type], attrs: Dict[str, Any]):
+    "Metaclass for constructing StateMachine classes"
+
+    def __init__(
+        cls,
+        name: str,
+        bases: Tuple[type],
+        attrs: Dict[str, Any],
+        strict_states: bool = False,
+    ) -> None:
         super().__init__(name, bases, attrs)
         registry.register(cls)
         cls.name = cls.__name__
@@ -27,7 +37,9 @@ class StateMachineMetaclass(type):
         """Map of ``state.value`` to the corresponding :ref:`state`."""
 
         cls._abstract = True
+        cls._strict_states = strict_states
         cls._events: Dict[str, Event] = {}
+        cls._protected_attrs: set = set()
 
         cls.add_inherited(bases)
         cls.add_from_attributes(attrs)
@@ -40,12 +52,12 @@ class StateMachineMetaclass(type):
         cls.final_states: List[State] = [state for state in cls.states if state.final]
 
         cls._check()
+        cls._setup()
 
     if TYPE_CHECKING:
         """Makes mypy happy with dynamic created attributes"""
 
-        def __getattr__(self, attribute: str) -> Any:
-            ...
+        def __getattr__(self, attribute: str) -> Any: ...
 
     def _check(cls):
         has_states = bool(cls.states)
@@ -66,6 +78,8 @@ class StateMachineMetaclass(type):
         cls._check_initial_state()
         cls._check_final_states()
         cls._check_disconnected_state()
+        cls._check_trap_states()
+        cls._check_reachable_final_states()
 
     def _check_initial_state(cls):
         initials = [s for s in cls.states if s.initial]
@@ -73,7 +87,7 @@ class StateMachineMetaclass(type):
             raise InvalidDefinition(
                 _(
                     "There should be one and only one initial state. "
-                    "Your currently have these: {!r}"
+                    "You currently have these: {!r}"
                 ).format([s.id for s in initials])
             )
 
@@ -84,11 +98,44 @@ class StateMachineMetaclass(type):
 
         if final_state_with_invalid_transitions:
             raise InvalidDefinition(
-                _(
-                    "Cannot declare transitions from final state. Invalid state(s): {}"
-                ).format([s.id for s in final_state_with_invalid_transitions])
+                _("Cannot declare transitions from final state. Invalid state(s): {}").format(
+                    [s.id for s in final_state_with_invalid_transitions]
+                )
             )
 
+    def _check_trap_states(cls):
+        trap_states = [s for s in cls.states if not s.final and not s.transitions]
+        if trap_states:
+            message = _(
+                "All non-final states should have at least one outgoing transition. "
+                "These states have no outgoing transition: {!r}"
+            ).format([s.id for s in trap_states])
+            if cls._strict_states:
+                raise InvalidDefinition(message)
+            else:
+                warnings.warn(message, UserWarning, stacklevel=4)
+
+    def _check_reachable_final_states(cls):
+        if not any(s.final for s in cls.states):
+            return  # No need to check final reachability
+        disconnected_states = cls._states_without_path_to_final_states()
+        if disconnected_states:
+            message = _(
+                "All non-final states should have at least one path to a final state. "
+                "These states have no path to a final state: {!r}"
+            ).format([s.id for s in disconnected_states])
+            if cls._strict_states:
+                raise InvalidDefinition(message)
+            else:
+                warnings.warn(message, UserWarning, stacklevel=1)
+
+    def _states_without_path_to_final_states(cls):
+        return [
+            state
+            for state in cls.states
+            if not state.final and not any(s.final for s in visit_connected_states(state))
+        ]
+
     def _disconnected_states(cls, starting_state):
         visitable_states = set(visit_connected_states(starting_state))
         return set(cls.states) - visitable_states
@@ -104,6 +151,23 @@ class StateMachineMetaclass(type):
                 ).format([s.id for s in disconnected_states])
             )
 
+    def _setup(cls):
+        for visited in iterate_states_and_transitions(cls.states):
+            visited._setup()
+
+        cls._protected_attrs = {
+            "_abstract",
+            "model",
+            "state_field",
+            "start_value",
+            "initial_state",
+            "final_states",
+            "states",
+            "_events",
+            "states_map",
+            "send",
+        } | {s.id for s in cls.states}
+
     def add_inherited(cls, bases):
         for base in bases:
             for state in getattr(base, "states", []):

statemachine/graph.py

@@ -12,3 +12,9 @@ def visit_connected_states(state):
         already_visited.add(state)
         yield state
         visit.extend(t.target for t in state.transitions)
+
+
+def iterate_states_and_transitions(states):
+    for state in states:
+        yield state
+        yield from state.transitions

statemachine/mixins.py

@@ -20,9 +20,7 @@ class MachineMixin:
         super().__init__(*args, **kwargs)
         if not self.state_machine_name:
             raise ValueError(
-                _("{!r} is not a valid state machine name.").format(
-                    self.state_machine_name
-                )
+                _("{!r} is not a valid state machine name.").format(self.state_machine_name)
             )
         machine_cls = registry.get_machine_cls(self.state_machine_name)
         setattr(

statemachine/signature.py

@@ -9,6 +9,7 @@ from typing import Any
 
 def _make_key(method):
     method = method.func if isinstance(method, partial) else method
+    method = method.fget if isinstance(method, property) else method
     if isinstance(method, MethodType):
         return hash(
             (
@@ -22,7 +23,6 @@ def _make_key(method):
 
 
 def signature_cache(user_function):
-
     cache = {}
     cache_get = cache.get
 
@@ -113,8 +113,7 @@ class SignatureAdapter(Signature):
                         parameters_ex = (param,)
                         break
                     elif (
-                        param.kind == Parameter.VAR_KEYWORD
-                        or param.default is not Parameter.empty
+                        param.kind == Parameter.VAR_KEYWORD or param.default is not Parameter.empty
                     ):
                         # That's fine too - we have a default value for this
                         # parameter.  So, lets start parsing `kwargs`, starting

statemachine/state.py

@@ -4,6 +4,7 @@ from typing import Dict
 from weakref import ref
 
 from .callbacks import CallbackMetaList
+from .callbacks import CallbackPriority
 from .exceptions import StateMachineError
 from .i18n import _
 from .transition import Transition
@@ -107,31 +108,30 @@ class State:
         self._final = final
         self._id: str = ""
         self.transitions = TransitionList()
-        self.enter = CallbackMetaList().add(enter)
-        self.exit = CallbackMetaList().add(exit)
+        self.enter = CallbackMetaList().add(enter, priority=CallbackPriority.INLINE)
+        self.exit = CallbackMetaList().add(exit, priority=CallbackPriority.INLINE)
 
     def __eq__(self, other):
-        return (
-            isinstance(other, State) and self.name == other.name and self.id == other.id
-        )
+        return isinstance(other, State) and self.name == other.name and self.id == other.id
 
     def __hash__(self):
         return hash(repr(self))
 
-    def _setup(self, register):
+    def _setup(self):
+        self.enter.add("on_enter_state", priority=CallbackPriority.GENERIC, suppress_errors=True)
+        self.enter.add(
+            f"on_enter_{self.id}", priority=CallbackPriority.NAMING, suppress_errors=True
+        )
+        self.exit.add("on_exit_state", priority=CallbackPriority.GENERIC, suppress_errors=True)
+        self.exit.add(f"on_exit_{self.id}", priority=CallbackPriority.NAMING, suppress_errors=True)
+
+    def _add_observer(self, register):
         register(self.enter)
         register(self.exit)
-        return self
 
-    def _add_observer(self, registry):
-        self.enter.add(
-            "on_enter_state", registry=registry, prepend=True, suppress_errors=True
-        )
-        self.enter.add(f"on_enter_{self.id}", registry=registry, suppress_errors=True)
-        self.exit.add(
-            "on_exit_state", registry=registry, prepend=True, suppress_errors=True
-        )
-        self.exit.add(f"on_exit_{self.id}", registry=registry, suppress_errors=True)
+    def _check_callbacks(self, check):
+        check(self.enter)
+        check(self.exit)
 
     def __repr__(self):
         return (
@@ -139,6 +139,9 @@ class State:
             f"initial={self.initial!r}, final={self.final!r})"
         )
 
+    def __str__(self):
+        return self.name
+
     def __get__(self, machine, owner):
         if machine is None:
             return self
@@ -146,14 +149,10 @@ class State:
 
     def __set__(self, instance, value):
         raise StateMachineError(
-            _("State overriding is not allowed. Trying to add '{}' to {}").format(
-                value, self.id
-            )
+            _("State overriding is not allowed. Trying to add '{}' to {}").format(value, self.id)
         )
 
-    def for_instance(
-        self, machine: "StateMachine", cache: Dict["State", "State"]
-    ) -> "State":
+    def for_instance(self, machine: "StateMachine", cache: Dict["State", "State"]) -> "State":
         if self not in cache:
             cache[self] = InstanceState(self, machine)
 
@@ -171,9 +170,7 @@ class State:
             self.name = self._id.replace("_", " ").capitalize()
 
     def _to_(self, *states: "State", **kwargs):
-        transitions = TransitionList(
-            Transition(self, state, **kwargs) for state in states
-        )
+        transitions = TransitionList(Transition(self, state, **kwargs) for state in states)
         self.transitions.add_transitions(transitions)
         return transitions
 

statemachine/statemachine.py

@@ -1,9 +1,14 @@
 from collections import deque
+from copy import deepcopy
 from functools import partial
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Dict
 
+from statemachine.graph import iterate_states_and_transitions
+
+from .callbacks import CallbackMetaList
+from .callbacks import CallbacksExecutor
 from .callbacks import CallbacksRegistry
 from .dispatcher import ObjectConfig
 from .dispatcher import resolver_factory
@@ -73,22 +78,22 @@ class StateMachine(metaclass=StateMachineMetaclass):
         self._external_queue: deque = deque()
         self._callbacks_registry = CallbacksRegistry()
         self._states_for_instance: Dict["State", "State"] = {}
+        self._observers: Dict[Any, Any] = {}
 
-        assert hasattr(self, "_abstract")
         if self._abstract:
             raise InvalidDefinition(_("There are no states or transitions."))
 
-        initial_transition = Transition(
-            None, self._get_initial_state(), event="__initial__"
-        )
-        self._setup(initial_transition)
-        self._activate_initial_state(initial_transition)
+        self._register_callbacks()
+        self._activate_initial_state()
+
+    def __init_subclass__(cls, strict_states: bool = False):
+        cls._strict_states = strict_states
+        super().__init_subclass__()
 
     if TYPE_CHECKING:
         """Makes mypy happy with dynamic created attributes"""
 
-        def __getattr__(self, attribute: str) -> Any:
-            ...
+        def __getattr__(self, attribute: str) -> Any: ...
 
     def __repr__(self):
         current_state_id = self.current_state.id if self.current_state_value else None
@@ -97,19 +102,31 @@ class StateMachine(metaclass=StateMachineMetaclass):
             f"current_state={current_state_id!r})"
         )
 
+    def __deepcopy__(self, memo):
+        deepcopy_method = self.__deepcopy__
+        self.__deepcopy__ = None
+        try:
+            cp = deepcopy(self, memo)
+        finally:
+            self.__deepcopy__ = deepcopy_method
+            cp.__deepcopy__ = deepcopy_method
+        cp._callbacks_registry.clear()
+        cp._register_callbacks()
+        cp.add_observer(*cp._observers.keys())
+        return cp
+
     def _get_initial_state(self):
-        current_state_value = (
-            self.start_value if self.start_value else self.initial_state.value
-        )
+        current_state_value = self.start_value if self.start_value else self.initial_state.value
         try:
             return self.states_map[current_state_value]
         except KeyError as err:
             raise InvalidStateValue(current_state_value) from err
 
-    def _activate_initial_state(self, initial_transition):
+    def _activate_initial_state(self):
         if self.current_state_value is None:
             # send an one-time event `__initial__` to enter the current state.
             # current_state = self.current_state
+            initial_transition = Transition(None, self._get_initial_state(), event="__initial__")
             initial_transition.before.clear()
             initial_transition.on.clear()
             initial_transition.after.clear()
@@ -123,63 +140,29 @@ class StateMachine(metaclass=StateMachineMetaclass):
             )
             self._activate(event_data)
 
-    def _get_protected_attrs(self):
-        return {
-            "_abstract",
-            "model",
-            "state_field",
-            "start_value",
-            "initial_state",
-            "final_states",
-            "states",
-            "_events",
-            "states_map",
-            "send",
-        } | {s.id for s in self.states}
-
-    def _visit_states_and_transitions(self, visitor):
-        for state in self.states:
-            visitor(state)
-            for transition in state.transitions:
-                visitor(transition)
-
-    def _setup(self, initial_transition: Transition):
-        """
-        Args:
-            initial_transition: A special :ref:`transition` that triggers the enter on the
-                `initial` :ref:`State`.
-        """
-        machine = ObjectConfig.from_obj(self, skip_attrs=self._get_protected_attrs())
-        model = ObjectConfig.from_obj(self.model, skip_attrs={self.state_field})
-        default_resolver = resolver_factory(machine, model)
-
-        register = partial(self._callbacks_registry.register, resolver=default_resolver)
-
-        observer_visitor = self._build_observers_visitor(machine, model)
-
-        def setup_visitor(visited):
-            visited._setup(register)
-            observer_visitor(visited)
-
-        self._visit_states_and_transitions(setup_visitor)
-
-        initial_transition._setup(register)
-
-    def _build_observers_visitor(self, *observers):
-        registry_callbacks = [
+    def _register_callbacks(self):
+        self._add_observer(
             (
-                self._callbacks_registry.build_register_function_for_resolver(
-                    resolver_factory(observer)
-                )
+                ObjectConfig.from_obj(self, skip_attrs=self._protected_attrs),
+                ObjectConfig.from_obj(self.model, skip_attrs={self.state_field}),
             )
-            for observer in observers
-        ]
+        )
 
-        def _add_observer_for_resolver(visited):
-            for register in registry_callbacks:
-                visited._add_observer(register)
+        check_callbacks = self._callbacks_registry.check
+        for visited in iterate_states_and_transitions(self.states):
+            try:
+                visited._check_callbacks(check_callbacks)
+            except Exception as err:
+                raise InvalidDefinition(
+                    f"Error on {visited!s} when resolving callbacks: {err}"
+                ) from err
 
-        return _add_observer_for_resolver
+    def _add_observer(self, observers):
+        register = partial(self._callbacks_registry.register, resolver=resolver_factory(observers))
+        for visited in iterate_states_and_transitions(self.states):
+            visited._add_observer(register)
+
+        return self
 
     def add_observer(self, *observers):
         """Add an observer.
@@ -191,10 +174,8 @@ class StateMachine(metaclass=StateMachineMetaclass):
 
             :ref:`observers`.
         """
-
-        visitor = self._build_observers_visitor(*observers)
-        self._visit_states_and_transitions(visitor)
-        return self
+        self._observers.update({o: None for o in observers})
+        return self._add_observer(tuple(ObjectConfig.from_obj(o) for o in observers))
 
     def _repr_html_(self):
         return f'<div class="statemachine">{self._repr_svg_()}</div>'
@@ -248,10 +229,7 @@ class StateMachine(metaclass=StateMachineMetaclass):
     @property
     def allowed_events(self):
         """List of the current allowed events."""
-        return [
-            getattr(self, event)
-            for event in self.current_state.transitions.unique_events
-        ]
+        return [getattr(self, event) for event in self.current_state.transitions.unique_events]
 
     def _process(self, trigger):
         """Process event triggers.
@@ -317,15 +295,13 @@ class StateMachine(metaclass=StateMachineMetaclass):
         source = event_data.state
         target = transition.target
 
-        result = self._callbacks_registry[transition.before].call(
+        result = self._callbacks(transition.before).call(
             *event_data.args, **event_data.extended_kwargs
         )
         if source is not None and not transition.internal:
-            self._callbacks_registry[source.exit].call(
-                *event_data.args, **event_data.extended_kwargs
-            )
+            self._callbacks(source.exit).call(*event_data.args, **event_data.extended_kwargs)
 
-        result += self._callbacks_registry[transition.on].call(
+        result += self._callbacks(transition.on).call(
             *event_data.args, **event_data.extended_kwargs
         )
 
@@ -333,12 +309,8 @@ class StateMachine(metaclass=StateMachineMetaclass):
         event_data.state = target
 
         if not transition.internal:
-            self._callbacks_registry[target.enter].call(
-                *event_data.args, **event_data.extended_kwargs
-            )
-        self._callbacks_registry[transition.after].call(
-            *event_data.args, **event_data.extended_kwargs
-        )
+            self._callbacks(target.enter).call(*event_data.args, **event_data.extended_kwargs)
+        self._callbacks(transition.after).call(*event_data.args, **event_data.extended_kwargs)
 
         if len(result) == 0:
             result = None
@@ -357,3 +329,6 @@ class StateMachine(metaclass=StateMachineMetaclass):
         """
         event = Event(event)
         return event.trigger(self, *args, **kwargs)
+
+    def _callbacks(self, meta_list: CallbackMetaList) -> CallbacksExecutor:
+        return self._callbacks_registry[meta_list]

statemachine/states.py

@@ -15,21 +15,23 @@ class States:
     Helps creating :ref:`StateMachine`'s :ref:`state` definitions from other
     sources, like an ``Enum`` class, using :meth:`States.from_enum`.
 
+    >>> states_def = [('open', {'initial': True}), ('closed', {'final': True})]
+
     >>> from statemachine import StateMachine
     >>> class SM(StateMachine):
     ...
     ...     states = States({
-    ...         name: State(initial=idx == 0) for idx, name in enumerate(["initial", "final"])
+    ...         name: State(**params) for name, params in states_def
     ...     })
     ...
-    ...     finish = states.initial.to(states.final)
+    ...     close = states.open.to(states.closed)
 
     And states can be used as usual.
 
     >>> sm = SM()
-    >>> sm.send("finish")
+    >>> sm.send("close")
     >>> sm.current_state.id
-    'final'
+    'closed'
 
     """
 

statemachine/transition.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING
 
 from .callbacks import BoolCallbackMeta
 from .callbacks import CallbackMetaList
+from .callbacks import CallbackPriority
 from .event import same_event_cond_builder
 from .events import Events
 from .exceptions import InvalidDefinition
@@ -48,7 +49,6 @@ class Transition:
         before=None,
         after=None,
     ):
-
         self.source = source
         self.target = target
         self.internal = internal
@@ -57,14 +57,14 @@ class Transition:
             raise InvalidDefinition("Internal transitions should be self-transitions.")
 
         self._events = Events().add(event)
-        self.validators = CallbackMetaList().add(validators)
-        self.before = CallbackMetaList().add(before)
-        self.on = CallbackMetaList().add(on)
-        self.after = CallbackMetaList().add(after)
+        self.validators = CallbackMetaList().add(validators, priority=CallbackPriority.INLINE)
+        self.before = CallbackMetaList().add(before, priority=CallbackPriority.INLINE)
+        self.on = CallbackMetaList().add(on, priority=CallbackPriority.INLINE)
+        self.after = CallbackMetaList().add(after, priority=CallbackPriority.INLINE)
         self.cond = (
             CallbackMetaList(factory=BoolCallbackMeta)
-            .add(cond)
-            .add(unless, expected_value=False)
+            .add(cond, priority=CallbackPriority.INLINE)
+            .add(unless, priority=CallbackPriority.INLINE, expected_value=False)
         )
 
     def __repr__(self):
@@ -73,49 +73,58 @@ class Transition:
             f"internal={self.internal!r})"
         )
 
-    def _setup(self, register):
-        register(self.validators)
-        register(self.cond)
-        register(self.before)
-        register(self.on)
-        register(self.after)
+    def __str__(self):
+        return f"transition {self.event!s} from {self.source!s} to {self.target!s}"
 
-    def _add_observer(self, registry):
+    def _setup(self):
         before = self.before.add
         on = self.on.add
         after = self.after.add
-        before(
-            "before_transition", registry=registry, suppress_errors=True, prepend=True
-        )
-        on("on_transition", registry=registry, suppress_errors=True, prepend=True)
+
+        before("before_transition", priority=CallbackPriority.GENERIC, suppress_errors=True)
+        on("on_transition", priority=CallbackPriority.GENERIC, suppress_errors=True)
 
         for event in self._events:
             same_event_cond = same_event_cond_builder(event)
             before(
                 f"before_{event}",
-                registry=registry,
+                priority=CallbackPriority.NAMING,
                 suppress_errors=True,
                 cond=same_event_cond,
             )
             on(
                 f"on_{event}",
-                registry=registry,
+                priority=CallbackPriority.NAMING,
                 suppress_errors=True,
                 cond=same_event_cond,
             )
             after(
                 f"after_{event}",
-                registry=registry,
+                priority=CallbackPriority.NAMING,
                 suppress_errors=True,
                 cond=same_event_cond,
             )
 
         after(
             "after_transition",
-            registry=registry,
+            priority=CallbackPriority.AFTER,
             suppress_errors=True,
         )
 
+    def _add_observer(self, register):
+        register(self.validators)
+        register(self.cond)
+        register(self.before)
+        register(self.on)
+        register(self.after)
+
+    def _check_callbacks(self, check):
+        check(self.validators)
+        check(self.cond)
+        check(self.before)
+        check(self.on)
+        check(self.after)
+
     def match(self, event):
         return self._events.match(event)
 

statemachine/utils.py

@@ -6,6 +6,10 @@ def qualname(cls):
 
 
 def ensure_iterable(obj):
+    """
+    Returns an iterator if obj is not an instance of string or if it
+    encounters type error, otherwise it returns a list.
+    """
     if isinstance(obj, str):
         return [obj]
     try:

python_statemachine-2.1.2.dist-info/RECORD

@@ -1,30 +0,0 @@
-statemachine/__init__.py,sha256=Bx88FyKa4Gm2RZxCWmYSxlefw0hVvOJMdWcqpsEiCgc,192
-statemachine/callbacks.py,sha256=_tmx5AZlhn_f3zhtUNAKBwfkkOKQLPBfSByhDUdFCeo,8265
-statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/contrib/diagram.py,sha256=_UxkX0ycOhzCAuvV_b3hrvZ6V_VOUFmbBigI3oz4PCA,6748
-statemachine/dispatcher.py,sha256=GMAwivNTz_m8X9szPqKD9O0cV2XoWhPkBE8d3btsFHY,3598
-statemachine/event.py,sha256=fvWxyFcrbPVxNW94p66rGJ5I1UZUK9mDJz68udkz2JI,2106
-statemachine/event_data.py,sha256=nxOfypngK-78A77gj4pS-oxLx9zl1S9wnSt_rTiCyZA,2257
-statemachine/events.py,sha256=rUbiTX-QGoo7zzmQMEeWeLrIVnp9zhicdRIm34CoAVI,731
-statemachine/exceptions.py,sha256=uzvDbHkzCZkmFI_02L0yC9gd6d0SBn9GmsI8ekc0Hjk,952
-statemachine/factory.py,sha256=KGAa3rSnxTFyPSD1UXDgkGtBpg95A5vFISq3YCyvccQ,5779
-statemachine/graph.py,sha256=QTNlEmEYCq6NfX6yiKrjfEY8bpbGASgV-M1g5TNR7YM,359
-statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
-statemachine/locale/en/LC_MESSAGES/statemachine.mo,sha256=aGIvF2G_OISexcLv3ZsudPfAkVIvL33zaEGeXJM47-I,452
-statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=MfODCwzML6DzhOpHbno2Pdhsb26AWboR5Ka1JCNvJIA,1685
-statemachine/locale/pt_BR/LC_MESSAGES/statemachine.mo,sha256=wTh7ge52cALzWScvS1wdjT-QO5ZhrsvodiI-dscYZhI,1914
-statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=KsR9rlnhw17EZG-IbVx3F0wJAJSK0B-OByGmUmDHDUM,2375
-statemachine/mixins.py,sha256=54aOvLZh9TyAIrqwfufGNmo1K4gaJR_dzhPdzisGPMk,1055
-statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
-statemachine/registry.py,sha256=RnVBRS3I_6Tm2OMgXMB_ewX7zQaslqEfhXFOhbqIkG4,959
-statemachine/signature.py,sha256=o8HLzhysMSnH_yy8qWG7aW5jVMOWdJM47OMnMyGVfC4,7463
-statemachine/state.py,sha256=YJ6NxsYi6KYxMTH8wp_jf4yZL2FSYN_HZmcqJXmch1w,8175
-statemachine/statemachine.py,sha256=rol4RKXG7R0hsibLCkcQMs7v3__v069IJc7xtFZuhRc,11998
-statemachine/states.py,sha256=gK-_csTDatvX4DYJcHUB45Ealv4FnfVz1Bj7IAS5nn0,4151
-statemachine/transition.py,sha256=7UO6Kjb73tsF7nHfaYM94J-FsByZJN81k_KtCBB_1vY,4833
-statemachine/transition_list.py,sha256=DatsmMWgK0YK30Nrj-josVvlTgeGapKutzYur9-puF8,5949
-statemachine/utils.py,sha256=hY72gKE7VT9dn3xW5ffjKZosVblGbga8G9sKLEh5ZFg,317
-python_statemachine-2.1.2.dist-info/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
-python_statemachine-2.1.2.dist-info/METADATA,sha256=3KLowdmDsCjT4zMeeFpan_7g-HVlLGoCgiiLzwzRybA,11454
-python_statemachine-2.1.2.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-python_statemachine-2.1.2.dist-info/RECORD,,