python-statemachine 2.3.0__py3-none-any.whl → 2.3.2__py3-none-any.whl

statemachine/transition.py

@@ -1,15 +1,10 @@
-from typing import TYPE_CHECKING
-
-from .callbacks import BoolCallbackMeta
-from .callbacks import CallbackMetaList
+from .callbacks import CallbackGroup
 from .callbacks import CallbackPriority
+from .callbacks import CallbackSpecList
 from .event import same_event_cond_builder
 from .events import Events
 from .exceptions import InvalidDefinition
 
-if TYPE_CHECKING:
-    from .event_data import EventData
-
 
 class Transition:
     """A transition holds reference to the source and target state.
@@ -57,13 +52,20 @@ class Transition:
             raise InvalidDefinition("Internal transitions should be self-transitions.")
 
         self._events = Events().add(event)
-        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._specs = CallbackSpecList()
+        self.validators = self._specs.grouper(CallbackGroup.VALIDATOR).add(
+            validators, priority=CallbackPriority.INLINE
+        )
+        self.before = self._specs.grouper(CallbackGroup.BEFORE).add(
+            before, priority=CallbackPriority.INLINE
+        )
+        self.on = self._specs.grouper(CallbackGroup.ON).add(on, priority=CallbackPriority.INLINE)
+        self.after = self._specs.grouper(CallbackGroup.AFTER).add(
+            after, priority=CallbackPriority.INLINE
+        )
         self.cond = (
-            CallbackMetaList(factory=BoolCallbackMeta)
-            .add(cond, priority=CallbackPriority.INLINE)
+            self._specs.grouper(CallbackGroup.COND)
+            .add(cond, priority=CallbackPriority.INLINE, expected_value=True)
             .add(unless, priority=CallbackPriority.INLINE, expected_value=False)
         )
 
@@ -81,51 +83,37 @@ class Transition:
         on = self.on.add
         after = self.after.add
 
-        before("before_transition", priority=CallbackPriority.GENERIC, suppress_errors=True)
-        on("on_transition", priority=CallbackPriority.GENERIC, suppress_errors=True)
+        before("before_transition", priority=CallbackPriority.GENERIC, is_convention=True)
+        on("on_transition", priority=CallbackPriority.GENERIC, is_convention=True)
 
         for event in self._events:
             same_event_cond = same_event_cond_builder(event)
             before(
                 f"before_{event}",
                 priority=CallbackPriority.NAMING,
-                suppress_errors=True,
+                is_convention=True,
                 cond=same_event_cond,
             )
             on(
                 f"on_{event}",
                 priority=CallbackPriority.NAMING,
-                suppress_errors=True,
+                is_convention=True,
                 cond=same_event_cond,
             )
             after(
                 f"after_{event}",
                 priority=CallbackPriority.NAMING,
-                suppress_errors=True,
+                is_convention=True,
                 cond=same_event_cond,
             )
 
         after(
             "after_transition",
             priority=CallbackPriority.AFTER,
-            suppress_errors=True,
+            is_convention=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):
+    def match(self, event: str):
         return self._events.match(event)
 
     @property
@@ -138,14 +126,3 @@ class Transition:
 
     def add_event(self, value):
         self._events.add(value)
-
-    async def execute(self, event_data: "EventData"):
-        machine = event_data.machine
-        args, kwargs = event_data.args, event_data.extended_kwargs
-        await machine._callbacks_registry[self.validators].call(*args, **kwargs)
-        if not await machine._callbacks_registry[self.cond].all(*args, **kwargs):
-            return False
-
-        result = await machine._activate(event_data)
-        event_data.result = result
-        return True

statemachine/transition_list.py

@@ -1,25 +1,22 @@
-from typing import TYPE_CHECKING
 from typing import Callable
 from typing import Iterable
 from typing import List
 
+from .transition import Transition
 from .utils import ensure_iterable
 
-if TYPE_CHECKING:
-    from .transition import Transition
-
 
 class TransitionList:
     """A list-like container of :ref:`transitions` with callback functions."""
 
-    def __init__(self, transitions: "Iterable | None" = None):
+    def __init__(self, transitions: "Iterable[Transition] | None" = None):
         """
         Args:
             transitions: An iterable of `Transition` objects.
                 Defaults to `None`.
 
         """
-        self.transitions = list(transitions) if transitions else []
+        self.transitions: List[Transition] = list(transitions) if transitions else []
 
     def __repr__(self):
         """Return a string representation of the :ref:`TransitionList`."""
@@ -53,11 +50,12 @@ class TransitionList:
         transitions = ensure_iterable(transition)
 
         for transition in transitions:
+            assert isinstance(transition, Transition)  # makes mypy happy
             self.transitions.append(transition)
 
         return self
 
-    def __getitem__(self, index: int):
+    def __getitem__(self, index: int) -> "Transition":
         """Returns the :ref:`transition` at the specified ``index``.
 
         Args:
@@ -136,7 +134,7 @@ class TransitionList:
         Returns:
             The `f` callable.
         """
-        return self._add_callback(f, "cond")
+        return self._add_callback(f, "cond", expected_value=True)
 
     def unless(self, f: Callable):
         """Adds a ``unless`` :ref:`guards` callback with expected value ``False`` to every

statemachine/utils.py

@@ -1,4 +1,8 @@
 import asyncio
+import threading
+
+_cached_loop = threading.local()
+"""Loop that will be used when the SM is running in a synchronous context. One loop per thread."""
 
 
 def qualname(cls):
@@ -23,11 +27,13 @@ def ensure_iterable(obj):
 
 def run_async_from_sync(coroutine):
     """
-    Run an async coroutine from a synchronous context.
+    Compatibility layer to run an async coroutine from a synchronous context.
     """
+    global _cached_loop
     try:
-        loop = asyncio.get_running_loop()
-        return asyncio.ensure_future(coroutine)
+        asyncio.get_running_loop()
+        return coroutine
     except RuntimeError:
-        loop = asyncio.get_event_loop()
-        return loop.run_until_complete(coroutine)
+        if not hasattr(_cached_loop, "loop"):
+            _cached_loop.loop = asyncio.new_event_loop()
+        return _cached_loop.loop.run_until_complete(coroutine)

python_statemachine-2.3.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-statemachine/__init__.py,sha256=Omi4-IXrTE0oLfO3oF75OqMYBI9TrbZeBzZIkt-F0rU,192
-statemachine/callbacks.py,sha256=D1mb3Ky18S1jk0-ursuJljqDv63WZShnMvMK_S1Hi9k,8846
-statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/contrib/diagram.py,sha256=CTlNRtAHEzCCzRUlxkiyzJOCOp1CohihdD0_7pHrx4c,7004
-statemachine/dispatcher.py,sha256=Zizr_Qaj2BfuHu5VbbnNh1giT_pUVLe4mekHj6Ca2dk,5075
-statemachine/event.py,sha256=lfJUSvkDQTnk1COueuV--xQD4o6GeaI94Y8tTOmiS6s,2304
-statemachine/event_data.py,sha256=nxOfypngK-78A77gj4pS-oxLx9zl1S9wnSt_rTiCyZA,2257
-statemachine/events.py,sha256=rUbiTX-QGoo7zzmQMEeWeLrIVnp9zhicdRIm34CoAVI,731
-statemachine/exceptions.py,sha256=RWq1vTjajxt8CzfYCD4DfI2nrgkfCPBL0DjRDOzKkQI,1086
-statemachine/factory.py,sha256=pAfRUuO474FekxrUZkKr8NkQqQ59vOu4dRHSD8Dr9rI,7982
-statemachine/graph.py,sha256=KtwB1CYckaLjTgQD9tEeuaEzJje9q3fPVpBViW5TgSk,487
-statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
-statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=zJYaV2DxrHdPngDOt1bji8-lPOZMSDjWG83Ypru5DOI,2126
-statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=SPrt-KaCBCKQq7PoOMtyyqU1bihrw_3MPL_NbqZzTVs,3214
-statemachine/mixins.py,sha256=B8WB3EGyZpMWAQg4Nw3kUMCfswgmLCChDpOQdxR28eE,1017
-statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
-statemachine/registry.py,sha256=RnVBRS3I_6Tm2OMgXMB_ewX7zQaslqEfhXFOhbqIkG4,959
-statemachine/signature.py,sha256=aGoKxC36mTO60GGICVlyduhhB2nKVOXOOHepcBG2Uws,7809
-statemachine/state.py,sha256=bZki0DyemZa-aVAfollQCmpXxesWONzUmE28eDfqz3o,8315
-statemachine/statemachine.py,sha256=5r8vtbMFQtOq9W8UmaWBN_SIzOHkO-4JfPysHfdoB8w,13827
-statemachine/states.py,sha256=gdGemJYF9k-cifs9Tk0Pe_-1u1Lanf3l08o0t8wAMgg,4203
-statemachine/transition.py,sha256=fo6B-XlHDqU8TNrDXBSn4GStdGUrZbcfbEgtsdESmrk,5412
-statemachine/transition_list.py,sha256=DatsmMWgK0YK30Nrj-josVvlTgeGapKutzYur9-puF8,5949
-statemachine/utils.py,sha256=FVtvT1lBSP3mRrYM-wxsX2pV_NZwSDsoBW4syIpACeE,798
-python_statemachine-2.3.0.dist-info/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
-python_statemachine-2.3.0.dist-info/METADATA,sha256=ubb6vnMCYaYyz486RJW5r1dKKu_emWD7Rwc4x2S7lyY,14361
-python_statemachine-2.3.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-python_statemachine-2.3.0.dist-info/RECORD,,