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

{python_statemachine-2.3.1.dist-info → python_statemachine-2.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-statemachine
-Version: 2.3.1
+Version: 2.3.2
 Summary: Python Finite State Machines made easy.
 Home-page: https://github.com/fgmacedo/python-statemachine
 License: MIT
@@ -103,7 +103,7 @@ Define your state machine:
 ...         | red.to(green)
 ...     )
 ...
-...     async def before_cycle(self, event: str, source: State, target: State, message: str = ""):
+...     def before_cycle(self, event: str, source: State, target: State, message: str = ""):
 ...         message = ". " + message if message else ""
 ...         return f"Running {event} from {source.id} to {target.id}{message}"
 ...
@@ -146,26 +146,6 @@ Then start sending events to your new state machine:
 
 ```
 
-You can use the exactly same state machine from an async codebase:
-
-
-```py
->>> async def run_sm():
-...    asm = TrafficLightMachine()
-...    results = []
-...    for _i in range(4):
-...        result = await asm.send("cycle")
-...        results.append(result)
-...    return results
-
->>> asyncio.run(run_sm())
-Don't move.
-Go ahead!
-['Running cycle from green to yellow', 'Running cycle from yellow to red', ...
-
-```
-
-
 **That's it.** This is all an external object needs to know about your state machine: How to send events.
 Ideally, all states, transitions, and actions should be kept internally and not checked externally to avoid unnecessary coupling.
 
@@ -253,7 +233,7 @@ callback method.
 Note how `before_cycle` was declared:
 
 ```py
-async def before_cycle(self, event: str, source: State, target: State, message: str = ""):
+def before_cycle(self, event: str, source: State, target: State, message: str = ""):
     message = ". " + message if message else ""
     return f"Running {event} from {source.id} to {target.id}{message}"
 ```

python_statemachine-2.3.2.dist-info/RECORD

@@ -0,0 +1,31 @@
+statemachine/__init__.py,sha256=iuxPx2JXDhZXU8XQ1rhBRx_q4q1aQQOrUvRi4-k_s9Y,192
+statemachine/callbacks.py,sha256=0MX2swHpxp7yZokz2I0GnoBfUOm8dReH5IgFvrTJVos,10974
+statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/contrib/diagram.py,sha256=JJx52yZqgDNIebvcUJ82IGT4EyerXQmOcF5mR21_kao,7198
+statemachine/dispatcher.py,sha256=oYlld3gvQDn2iXRPjk9ujtd5JnqWHxcft5oV80i-jMY,5175
+statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/engines/async_.py,sha256=6t5D-mRegNcBoJv0GKVyrcafUKzogxEFMZhm80_-6tw,5548
+statemachine/engines/sync.py,sha256=SqhACkjQPNY8GPGkPPz331iOssR94EwQOITOXNSwMSQ,5499
+statemachine/event.py,sha256=LfvO-imBVyVX6krBK0Pz7q-iTRudo_5OjTFaYJpc6IQ,1556
+statemachine/event_data.py,sha256=x9m9Q2q-78kVFnJVJmOAwq6lo9zgSVxko3q4Omwjqxk,2228
+statemachine/events.py,sha256=QgXcxu25WkUaxJvonh0K7hOlYYSQlV0jbhTCAi_gpwc,736
+statemachine/exceptions.py,sha256=RWq1vTjajxt8CzfYCD4DfI2nrgkfCPBL0DjRDOzKkQI,1086
+statemachine/factory.py,sha256=8rRvDXWGjEX6v6mP7YiXOJPTCcm-GhDmuTvyotw1zoc,7948
+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=Y1fa52Cj20JaGkyNk3P7Gpqkt4cGTjJ0YyV_VQyCl0M,1231
+statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
+statemachine/registry.py,sha256=HmV9sUGkYVrNUZxJYoZo-trSUis7dIun_WcGktblgc8,922
+statemachine/signature.py,sha256=HwuyWX3p_GZwKKrGbt9wk4-bHpymqs_pgqW7OlDgGRc,7877
+statemachine/state.py,sha256=IKdkMBkXCgcvswMKQZ-hn0-739Hhf6z6q8mSEoevV7o,8262
+statemachine/statemachine.py,sha256=1G0bQmzDykHXGsPt2WYoOHQjazYgUDPm3VOJcMJXB7E,11387
+statemachine/states.py,sha256=aLo5qesqrQLtP3QkVx28mAqfU-e20qC0EHgQi0XZmiw,4247
+statemachine/transition.py,sha256=R7gfSZjqR59OIdpKePgdr66zTp5azow-tDqqYJsECR4,4711
+statemachine/transition_list.py,sha256=_tdFD1O7hw8xVAU6nRYmGrj6TCAM0SD-Sa0_DYKa88Y,6034
+statemachine/utils.py,sha256=DpcrGqlbrnT-ogh-BogG0L07EG3KirHOsKORHlspDlI,1041
+python_statemachine-2.3.2.dist-info/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
+python_statemachine-2.3.2.dist-info/METADATA,sha256=zvFK8eZfgK_ybIPxElQYQ5lmbEKvTtDLedzf7sfgC8E,13932
+python_statemachine-2.3.2.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+python_statemachine-2.3.2.dist-info/RECORD,,

statemachine/__init__.py

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

statemachine/callbacks.py

@@ -1,11 +1,18 @@
+import asyncio
 from bisect import insort
+from collections import Counter
 from collections import defaultdict
 from collections import deque
 from enum import IntEnum
+from enum import auto
+from inspect import isawaitable
+from inspect import iscoroutinefunction
 from typing import Callable
 from typing import Dict
 from typing import Generator
+from typing import Iterable
 from typing import List
+from typing import Type
 
 from .exceptions import AttrNotFound
 from .i18n import _
@@ -20,77 +27,84 @@ class CallbackPriority(IntEnum):
     AFTER = 40
 
 
-async def allways_true(*args, **kwargs):
-    return True
+class SpecReference(IntEnum):
+    NAME = 1
+    CALLABLE = 2
+    PROPERTY = 3
 
 
-class CallbackWrapper:
-    def __init__(
-        self,
-        callback: Callable,
-        condition: Callable,
-        meta: "CallbackMeta",
-        unique_key: str,
-    ) -> None:
-        self._callback = callback
-        self.condition = condition
-        self.meta = meta
-        self.unique_key = unique_key
+class CallbackGroup(IntEnum):
+    ENTER = auto()
+    EXIT = auto()
+    VALIDATOR = auto()
+    BEFORE = auto()
+    ON = auto()
+    AFTER = auto()
+    COND = auto()
 
-    def __repr__(self):
-        return f"{type(self).__name__}({self.unique_key})"
-
-    def __str__(self):
-        return str(self.meta)
+    def build_key(self, specs: "CallbackSpecList") -> str:
+        return f"{self.name}@{id(specs)}"
 
-    def __lt__(self, other):
-        return self.meta.priority < other.meta.priority
 
-    async def __call__(self, *args, **kwargs):
-        return await self._callback(*args, **kwargs)
+def allways_true(*args, **kwargs):
+    return True
 
 
-class CallbackMeta:
-    """A thin wrapper that register info about actions and guards.
+class CallbackSpec:
+    """Specs about callbacks.
 
-    At first, `func` can be a string or a callable, and even if it's already
-    a callable, his signature can mismatch.
+    At first, `func` can be a name (string), a property or a callable.
 
-    After instantiation, `.setup(resolver)` must be called before any real
-    call is performed, to allow the proper callback resolution.
+    Names, properties and unbounded callables should be resolved to a callable
+    before any real call is performed.
     """
 
     def __init__(
         self,
         func,
-        suppress_errors=False,
+        group: CallbackGroup,
+        is_convention=False,
         cond=None,
         priority: CallbackPriority = CallbackPriority.NAMING,
         expected_value=None,
     ):
         self.func = func
-        self.suppress_errors = suppress_errors
+        self.group = group
+        self.is_convention = is_convention
         self.cond = cond
         self.expected_value = expected_value
         self.priority = priority
 
+        if isinstance(func, property):
+            self.reference = SpecReference.PROPERTY
+            self.attr_name: str = func and func.fget and func.fget.__name__ or ""
+        elif callable(func):
+            self.reference = SpecReference.CALLABLE
+            self.is_bounded = hasattr(func, "__self__")
+            self.attr_name = func.__name__
+        else:
+            self.reference = SpecReference.NAME
+            self.attr_name = func
+
     def __repr__(self):
-        return f"{type(self).__name__}({self.func!r}, suppress_errors={self.suppress_errors!r})"
+        return f"{type(self).__name__}({self.func!r}, is_convention={self.is_convention!r})"
 
     def __str__(self):
-        return getattr(self.func, "__name__", self.func)
+        name = getattr(self.func, "__name__", self.func)
+        if self.expected_value is False:
+            name = f"!{name}"
+        return name
 
     def __eq__(self, other):
-        return self.func == other.func
+        return self.func == other.func and self.group == other.group
 
     def __hash__(self):
         return id(self)
 
-    def _update_func(self, func):
+    def _update_func(self, func: Callable, attr_name: str):
         self.func = func
-
-    def _wrap_callable(self, func, _expected_value):
-        return func
+        self.reference = SpecReference.CALLABLE
+        self.attr_name = attr_name
 
     def build(self, resolver) -> Generator["CallbackWrapper", None, None]:
         """
@@ -100,62 +114,57 @@ class CallbackMeta:
             resolver (callable): A method responsible to build and return a valid callable that
                 can receive arbitrary parameters like `*args, **kwargs`.
         """
-        for callback in resolver(self.func):
-            condition = next(resolver(self.cond)) if self.cond is not None else allways_true
+        for callback in resolver.search(self):
+            condition = self.cond if self.cond is not None else allways_true
             yield CallbackWrapper(
-                callback=self._wrap_callable(callback, self.expected_value),
+                callback=callback,
                 condition=condition,
                 meta=self,
                 unique_key=callback.unique_key,
             )
 
 
-class BoolCallbackMeta(CallbackMeta):
-    """A thin wrapper that register info about actions and guards.
+class SpecListGrouper:
+    def __init__(
+        self, list: "CallbackSpecList", group: CallbackGroup, factory=CallbackSpec
+    ) -> None:
+        self.list = list
+        self.group = group
+        self.factory = factory
+        self.key = group.build_key(list)
 
-    At first, `func` can be a string or a callable, and even if it's already
-    a callable, his signature can mismatch.
+    def add(self, callbacks, **kwargs):
+        self.list.add(callbacks, group=self.group, factory=self.factory, **kwargs)
+        return self
 
-    After instantiation, `.setup(resolver)` must be called before any real
-    call is performed, to allow the proper callback resolution.
-    """
+    def __call__(self, callback):
+        return self.list._add_unbounded_callback(callback, group=self.group, factory=self.factory)
 
-    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 _add_unbounded_callback(self, func, is_event=False, transitions=None, **kwargs):
+        self.list._add_unbounded_callback(
+            func,
+            is_event=is_event,
+            transitions=transitions,
+            group=self.group,
+            factory=self.factory,
+            **kwargs,
         )
 
-    def __str__(self):
-        name = super().__str__()
-        return name if self.expected_value else f"!{name}"
-
-    def _wrap_callable(self, func, expected_value):
-        async def bool_wrapper(*args, **kwargs):
-            return bool(await func(*args, **kwargs)) == expected_value
-
-        return bool_wrapper
+    def __iter__(self):
+        return (item for item in self.list if item.group == self.group)
 
 
-class CallbackMetaList:
-    """List of `CallbackMeta` instances"""
+class CallbackSpecList:
+    """List of {ref}`CallbackSpec` instances"""
 
-    def __init__(self, factory=CallbackMeta):
-        self.items: List[CallbackMeta] = []
+    def __init__(self, factory=CallbackSpec):
+        self.items: List[CallbackSpec] = []
+        self.conventional_specs = set()
         self.factory = factory
 
     def __repr__(self):
         return f"{type(self).__name__}({self.items!r}, factory={self.factory!r})"
 
-    def __str__(self):
-        return ", ".join(str(c) for c in self)
-
     def _add_unbounded_callback(self, func, is_event=False, transitions=None, **kwargs):
         """This list was a target for adding a func using decorator
         `@<state|event>[.on|before|after|enter|exit]` syntax.
@@ -179,45 +188,90 @@ class CallbackMetaList:
                 event.
 
         """
-        callback = self._add(func, **kwargs)
-        if not getattr(func, "_callbacks_to_update", None):
-            func._callbacks_to_update = set()
-        func._callbacks_to_update.add(callback._update_func)
-        func._is_event = is_event
+        spec = self._add(func, **kwargs)
+        if not getattr(func, "_specs_to_update", None):
+            func._specs_to_update = set()
+        if is_event:
+            func._specs_to_update.add(spec._update_func)
         func._transitions = transitions
 
         return func
 
-    def __call__(self, callback):
-        """Allows usage of the callback list as a decorator."""
-        return self._add_unbounded_callback(callback)
-
     def __iter__(self):
         return iter(self.items)
 
     def clear(self):
         self.items = []
 
-    def _add(self, func, **kwargs):
-        meta = self.factory(func, **kwargs)
+    def grouper(
+        self, group: CallbackGroup, factory: Type[CallbackSpec] = CallbackSpec
+    ) -> SpecListGrouper:
+        return SpecListGrouper(self, group, factory=factory)
+
+    def _add(self, func, group: CallbackGroup, factory=None, **kwargs):
+        if factory is None:
+            factory = self.factory
+        spec = factory(func, group, **kwargs)
 
-        if meta in self.items:
+        if spec in self.items:
             return
 
-        self.items.append(meta)
-        return meta
+        self.items.append(spec)
+        if spec.is_convention:
+            self.conventional_specs.add(spec.func)
+        return spec
 
-    def add(self, callbacks, **kwargs):
+    def add(self, callbacks, group: CallbackGroup, **kwargs):
         if callbacks is None:
             return self
 
         unprepared = ensure_iterable(callbacks)
         for func in unprepared:
-            self._add(func, **kwargs)
+            self._add(func, group=group, **kwargs)
 
         return self
 
 
+class CallbackWrapper:
+    def __init__(
+        self,
+        callback: Callable,
+        condition: Callable,
+        meta: "CallbackSpec",
+        unique_key: str,
+    ) -> None:
+        self._callback = callback
+        self._iscoro = iscoroutinefunction(callback)
+        self.condition = condition
+        self.meta = meta
+        self.unique_key = unique_key
+        self.expected_value = self.meta.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
+
+    async def __call__(self, *args, **kwargs):
+        value = self._callback(*args, **kwargs)
+        if isawaitable(value):
+            value = await value
+
+        if self.expected_value is not None:
+            return bool(value) == self.expected_value
+        return value
+
+    def call(self, *args, **kwargs):
+        value = self._callback(*args, **kwargs)
+        if self.expected_value is not None:
+            return bool(value) == self.expected_value
+        return value
+
+
 class CallbacksExecutor:
     """A list of callbacks that can be executed in order."""
 
@@ -234,57 +288,75 @@ class CallbacksExecutor:
     def __str__(self):
         return ", ".join(str(c) for c in self)
 
-    def _add(self, callback_meta: CallbackMeta, resolver: Callable):
-        for callback in callback_meta.build(resolver):
+    def _add(self, spec: CallbackSpec, resolver: Callable):
+        for callback in spec.build(resolver):
             if callback.unique_key in self.items_already_seen:
                 continue
 
             self.items_already_seen.add(callback.unique_key)
             insort(self.items, callback)
 
-    def add(self, items: CallbackMetaList, resolver: Callable):
+    def add(self, items: Iterable[CallbackSpec], resolver: Callable):
         """Validate configurations"""
         for item in items:
             self._add(item, resolver)
         return self
 
-    async def call(self, *args, **kwargs):
+    async def async_call(self, *args, **kwargs):
+        return await asyncio.gather(
+            *(
+                callback(*args, **kwargs)
+                for callback in self
+                if callback.condition(*args, **kwargs)
+            )
+        )
+
+    async def async_all(self, *args, **kwargs):
+        coros = [condition(*args, **kwargs) for condition in self]
+        for coro in asyncio.as_completed(coros):
+            if not await coro:
+                return False
+        return True
+
+    def call(self, *args, **kwargs):
         return [
-            await callback(*args, **kwargs)
+            callback.call(*args, **kwargs)
             for callback in self
-            if await callback.condition(*args, **kwargs)
+            if callback.condition(*args, **kwargs)
         ]
 
-    async def all(self, *args, **kwargs):
+    def all(self, *args, **kwargs):
         for condition in self:
-            if not await condition(*args, **kwargs):
+            if not condition.call(*args, **kwargs):
                 return False
         return True
 
 
 class CallbacksRegistry:
     def __init__(self) -> None:
-        self._registry: Dict[CallbackMetaList, CallbacksExecutor] = defaultdict(CallbacksExecutor)
-
-    def register(self, meta_list: CallbackMetaList, resolver):
-        executor_list = self[meta_list]
-        executor_list.add(meta_list, resolver)
-        return executor_list
+        self._registry: Dict[str, CallbacksExecutor] = defaultdict(CallbacksExecutor)
+        self._method_types: Counter = Counter()
 
     def clear(self):
         self._registry.clear()
 
-    def __getitem__(self, meta_list: CallbackMetaList) -> CallbacksExecutor:
-        return self._registry[meta_list]
+    def __getitem__(self, key: str) -> CallbacksExecutor:
+        return self._registry[key]
 
-    def check(self, meta_list: CallbackMetaList):
-        executor = self[meta_list]
-        for meta in meta_list:
-            if meta.suppress_errors:
+    def check(self, specs: CallbackSpecList):
+        for meta in specs:
+            if meta.is_convention:
                 continue
 
-            if any(callback for callback in executor if callback.meta == meta):
+            if any(
+                callback for callback in self[meta.group.build_key(specs)] if callback.meta == meta
+            ):
                 continue
             raise AttrNotFound(
                 _("Did not found name '{}' from model or statemachine").format(meta.func)
             )
+
+    def async_or_sync(self):
+        self._method_types.update(
+            callback._iscoro for executor in self._registry.values() for callback in executor
+        )

statemachine/contrib/diagram.py

@@ -69,12 +69,15 @@ class DotGraphMachine:
     def _actions_getter(self):
         if isinstance(self.machine, StateMachine):
 
-            def getter(x):
-                return self.machine._callbacks(x)
+            def getter(grouper):
+                return self.machine._get_callbacks(grouper.key)
         else:
 
-            def getter(x):
-                return x
+            def getter(grouper):
+                all_names = set(dir(self.machine))
+                return ", ".join(
+                    str(c) for c in grouper if not c.is_convention or c.func in all_names
+                )
 
         return getter