python-statemachine 2.4.0__py3-none-any.whl → 2.5.0__py3-none-any.whl

{python_statemachine-2.4.0.dist-info → python_statemachine-2.5.0.dist-info}/METADATA

@@ -1,19 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: python-statemachine
-Version: 2.4.0
+Version: 2.5.0
 Summary: Python Finite State Machines made easy.
-Home-page: https://github.com/fgmacedo/python-statemachine
-License: MIT
-Author: Fernando Macedo
-Author-email: fgmacedo@gmail.com
-Maintainer: Fernando Macedo
-Maintainer-email: fgmacedo@gmail.com
-Requires-Python: >=3.7
+Project-URL: homepage, https://github.com/fgmacedo/python-statemachine
+Author-email: Fernando Macedo <fgmacedo@gmail.com>
+Maintainer-email: Fernando Macedo <fgmacedo@gmail.com>
+License: MIT License
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: AsyncIO
+Classifier: Framework :: Django
 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
@@ -21,9 +19,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
 Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.7
 Provides-Extra: diagrams
-Requires-Dist: pydot (>=2.0.0) ; (python_full_version > "3.8.0") and (extra == "diagrams")
+Requires-Dist: pydot>=2.0.0; extra == 'diagrams'
 Description-Content-Type: text/markdown
 
 # Python StateMachine
@@ -196,19 +196,19 @@ Easily iterate over all states:
 
 ```py
 >>> [s.id for s in sm.states]
-['green', 'red', 'yellow']
+['green', 'yellow', 'red']
 
 ```
 
 Or over events:
 
 ```py
->>> [t.name for t in sm.events]
+>>> [t.id for t in sm.events]
 ['cycle']
 
 ```
 
-Call an event by its name:
+Call an event by its id:
 
 ```py
 >>> sm.cycle()
@@ -216,7 +216,7 @@ Don't move.
 'Running cycle from yellow to red'
 
 ```
-Or send an event with the event name:
+Or send an event with the event id:
 
 ```py
 >>> sm.send('cycle')
@@ -427,4 +427,3 @@ request. For more information on how to contribute, please see our [contributing
 - **Promote the project**: Help spread the word by sharing on social media,
   writing a blog post, or giving a talk about it. Tag me on Twitter
   [@fgmacedo](https://twitter.com/fgmacedo) so I can share it too!
-

python_statemachine-2.5.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+statemachine/__init__.py,sha256=JsTxT_XFohxEg-P6qmBYcxNTwzW-A2a9zLIk7wpRzaM,226
+statemachine/callbacks.py,sha256=UUOuMotQDV3ZkpqjWp3CIL3UrA70Bh_xYDf4Ugjlou8,11475
+statemachine/dispatcher.py,sha256=Ai8i79Lo5HdUJ-toOVg4NDUzAy88sryBHDbYdl_7sWE,7785
+statemachine/event.py,sha256=DhAVtoPGCHv95r3QOuL-Tn93UMWXPhiuODFcc9FPUPA,4586
+statemachine/event_data.py,sha256=H9lp_XnvHSK9YErUOCvMK3ZBjWhC-xDSOJ2gZxtmrq8,2261
+statemachine/events.py,sha256=UTYJu8te_bxiORTQpoXY5tB_x-ymVPWDOREcxCyhExA,1018
+statemachine/exceptions.py,sha256=vHVQPTTMMkVvySNbN6XZPciBryvpY608LDe3MCnmxFU,1124
+statemachine/factory.py,sha256=crL2FPfzdku3STlbxaF9N3oV9L1BFWoCAT9K3zEnBYo,9219
+statemachine/graph.py,sha256=KtwB1CYckaLjTgQD9tEeuaEzJje9q3fPVpBViW5TgSk,487
+statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
+statemachine/mixins.py,sha256=Y1fa52Cj20JaGkyNk3P7Gpqkt4cGTjJ0YyV_VQyCl0M,1231
+statemachine/model.py,sha256=OylI3FjMiHpYyDl9mtK1zEJMeSvemaN4giQDonpc8kI,211
+statemachine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/registry.py,sha256=HmV9sUGkYVrNUZxJYoZo-trSUis7dIun_WcGktblgc8,922
+statemachine/signature.py,sha256=mZjYXjMAF2XNLxI_MfTYoReJxTuPBHExEm7H76yueWY,7117
+statemachine/spec_parser.py,sha256=DRG-_6bWRTCTgU6qZHqRp5aOxFRZP0O_4VvVxyleItA,5686
+statemachine/state.py,sha256=a2uJZyn8sM8HdnVN_FesCgcjoeDE8gfXCAChbLm4p9g,9504
+statemachine/statemachine.py,sha256=mznQ4NpiysrHm1Ef3JPGRQ07gSXzAD9bER3r_ou9d40,10881
+statemachine/states.py,sha256=pPROZwIyE3_tlBGL3DJXnM3gr1pWsWICEMMo2c742RY,4889
+statemachine/transition.py,sha256=YDpI6NuCipW4cF4GVIt3o8ACE6VhWAQWHaZKjmjSQRA,5335
+statemachine/transition_list.py,sha256=I9viQ0zr6E8oL3WEESkst9DwQeTNJ6nwDAQXsWeo3_c,4179
+statemachine/transition_mixin.py,sha256=OGKF-hMyTEZDtlK_XxGaa5OqxYjmUtThMac9tDQUKUY,2615
+statemachine/utils.py,sha256=DpcrGqlbrnT-ogh-BogG0L07EG3KirHOsKORHlspDlI,1041
+statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/contrib/diagram.py,sha256=CVNIhBTedik_02b-4KUua_3_HtiO1TYQNWOg3ulkqiE,7159
+statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/engines/async_.py,sha256=HA9EtS7vYS5tulvdwH2NnTMkpUddcDZPXVNckSQFAak,5212
+statemachine/engines/base.py,sha256=d65JvngOrp8sE4RR8i2wrd72wzIci9-3InMLyGdxsZQ,1201
+statemachine/engines/sync.py,sha256=Cys05fn7zQf3WowdIaVrdD8mAVQ-HEjbTMRngv_Z4cU,5035
+statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=4Pk-h5nk7twOTHcRQ_Chanfdi5EtFi9aTAzGkVJuCo8,2424
+statemachine/locale/hi_IN/LC_MESSAGES/statemachine.po,sha256=Bs5bbIxDrYtODSNJKNl4FH8ZtjEJwPIidRwbAxMwu5E,4941
+statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=gmnhc15-6YVDCLWYT0ZQL5jfXHgIOYq5p5rJLqNPaxE,3593
+statemachine/locale/zh_CN/LC_MESSAGES/statemachine.po,sha256=cDbRHDYpi3pwJkFmaSn79q5KmX9cGmHFHw1ndj37vRw,3325
+python_statemachine-2.5.0.dist-info/METADATA,sha256=LzU6fCMlw6gANXQeCCgRpyVRorsAzvF8UMWERtnowng,14068
+python_statemachine-2.5.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+python_statemachine-2.5.0.dist-info/licenses/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
+python_statemachine-2.5.0.dist-info/RECORD,,

{python_statemachine-2.4.0.dist-info → python_statemachine-2.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.6.1
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any

statemachine/__init__.py

@@ -4,6 +4,6 @@ from .statemachine import StateMachine
 
 __author__ = """Fernando Macedo"""
 __email__ = "fgmacedo@gmail.com"
-__version__ = "2.4.0"
+__version__ = "2.5.0"
 
 __all__ = ["StateMachine", "State", "Event"]

statemachine/callbacks.py

@@ -5,29 +5,22 @@ from collections import deque
 from enum import IntEnum
 from enum import IntFlag
 from enum import auto
-from functools import partial
-from functools import reduce
 from inspect import isawaitable
-from inspect import iscoroutinefunction
 from typing import TYPE_CHECKING
 from typing import Callable
 from typing import Dict
-from typing import Generator
-from typing import Iterable
 from typing import List
-from typing import Set
-from typing import Type
 
 from .exceptions import AttrNotFound
-from .exceptions import InvalidDefinition
 from .i18n import _
-from .spec_parser import custom_and
-from .spec_parser import operator_mapping
-from .spec_parser import parse_boolean_expr
 from .utils import ensure_iterable
 
 if TYPE_CHECKING:
-    from statemachine.dispatcher import Listeners
+    from typing import Set
+
+
+def allways_true(*args, **kwargs):
+    return True
 
 
 class CallbackPriority(IntEnum):
@@ -61,21 +54,6 @@ class CallbackGroup(IntEnum):
         return f"{self.name}@{id(specs)}"
 
 
-def allways_true(*args, **kwargs):
-    return True
-
-
-def take_callback(name: str, resolver: "Listeners", not_found_handler: Callable) -> Callable:
-    callbacks = list(resolver.search_name(name))
-    if len(callbacks) == 0:
-        not_found_handler(name)
-        return allways_true
-    elif len(callbacks) == 1:
-        return callbacks[0]
-    else:
-        return reduce(custom_and, callbacks)
-
-
 class CallbackSpec:
     """Specs about callbacks.
 
@@ -85,11 +63,15 @@ class CallbackSpec:
     before any real call is performed.
     """
 
+    names_not_found: "Set[str] | None" = None
+    """List of names that were not found on the model or statemachine"""
+
     def __init__(
         self,
         func,
         group: CallbackGroup,
         is_convention=False,
+        is_event: bool = False,
         cond=None,
         priority: CallbackPriority = CallbackPriority.NAMING,
         expected_value=None,
@@ -97,6 +79,7 @@ class CallbackSpec:
         self.func = func
         self.group = group
         self.is_convention = is_convention
+        self.is_event = is_event
         self.cond = cond
         self.expected_value = expected_value
         self.priority = priority
@@ -107,11 +90,22 @@ class CallbackSpec:
         elif callable(func):
             self.reference = SpecReference.CALLABLE
             self.is_bounded = hasattr(func, "__self__")
-            self.attr_name = func.__name__
+            self.attr_name = (
+                func.__name__ if not self.is_event or self.is_bounded else f"_{func.__name__}_"
+            )
+            if not self.is_bounded:
+                func.attr_name = self.attr_name
+                func.is_event = is_event
         else:
             self.reference = SpecReference.NAME
             self.attr_name = func
 
+        self.may_contain_boolean_expression = (
+            not self.is_convention
+            and self.group == CallbackGroup.COND
+            and self.reference == SpecReference.NAME
+        )
+
     def __repr__(self):
         return f"{type(self).__name__}({self.func!r}, is_convention={self.is_convention!r})"
 
@@ -127,68 +121,19 @@ class CallbackSpec:
     def __hash__(self):
         return id(self)
 
-    def _update_func(self, func: Callable, attr_name: str):
-        self.func = func
-        self.reference = SpecReference.CALLABLE
-        self.attr_name = attr_name
-
-    def _wrap(self, callback):
-        condition = self.cond if self.cond is not None else allways_true
-        return CallbackWrapper(
-            callback=callback,
-            condition=condition,
-            meta=self,
-            unique_key=callback.unique_key,
-        )
-
-    def build(self, resolver: "Listeners") -> Generator["CallbackWrapper", None, None]:
-        """
-        Resolves the `func` into a usable callable.
-
-        Args:
-            resolver (callable): A method responsible to build and return a valid callable that
-                can receive arbitrary parameters like `*args, **kwargs`.
-        """
-        if (
-            not self.is_convention
-            and self.group == CallbackGroup.COND
-            and self.reference == SpecReference.NAME
-        ):
-            names_not_found: Set[str] = set()
-            take_callback_partial = partial(
-                take_callback, resolver=resolver, not_found_handler=names_not_found.add
-            )
-            try:
-                expression = parse_boolean_expr(self.func, take_callback_partial, operator_mapping)
-            except SyntaxError as err:
-                raise InvalidDefinition(
-                    _("Failed to parse boolean expression '{}'").format(self.func)
-                ) from err
-            if not expression or names_not_found:
-                self.names_not_found = names_not_found
-                return
-            yield self._wrap(expression)
-            return
-
-        for callback in resolver.search(self):
-            yield self._wrap(callback)
-
 
 class SpecListGrouper:
-    def __init__(
-        self, list: "CallbackSpecList", group: CallbackGroup, factory=CallbackSpec
-    ) -> None:
+    def __init__(self, list: "CallbackSpecList", group: CallbackGroup) -> None:
         self.list = list
         self.group = group
-        self.factory = factory
         self.key = group.build_key(list)
 
     def add(self, callbacks, **kwargs):
-        self.list.add(callbacks, group=self.group, factory=self.factory, **kwargs)
+        self.list.add(callbacks, group=self.group, **kwargs)
         return self
 
     def __call__(self, callback):
-        return self.list._add_unbounded_callback(callback, group=self.group, factory=self.factory)
+        return self.list._add_unbounded_callback(callback, group=self.group)
 
     def _add_unbounded_callback(self, func, is_event=False, transitions=None, **kwargs):
         self.list._add_unbounded_callback(
@@ -196,7 +141,6 @@ class SpecListGrouper:
             is_event=is_event,
             transitions=transitions,
             group=self.group,
-            factory=self.factory,
             **kwargs,
         )
 
@@ -210,12 +154,13 @@ class CallbackSpecList:
     def __init__(self, factory=CallbackSpec):
         self.items: List[CallbackSpec] = []
         self.conventional_specs = set()
+        self._groupers: Dict[CallbackGroup, SpecListGrouper] = {}
         self.factory = factory
 
     def __repr__(self):
         return f"{type(self).__name__}({self.items!r}, factory={self.factory!r})"
 
-    def _add_unbounded_callback(self, func, is_event=False, transitions=None, **kwargs):
+    def _add_unbounded_callback(self, func, transitions=None, **kwargs):
         """This list was a target for adding a func using decorator
         `@<state|event>[.on|before|after|enter|exit]` syntax.
 
@@ -238,11 +183,7 @@ class CallbackSpecList:
                 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)
+        self._add(func, **kwargs)
         func._transitions = transitions
 
         return func
@@ -253,15 +194,16 @@ class CallbackSpecList:
     def clear(self):
         self.items = []
 
-    def grouper(
-        self, group: CallbackGroup, factory: Type[CallbackSpec] = CallbackSpec
-    ) -> SpecListGrouper:
-        return SpecListGrouper(self, group, factory=factory)
+    def grouper(self, group: CallbackGroup) -> SpecListGrouper:
+        if group not in self._groupers:
+            self._groupers[group] = SpecListGrouper(self, group)
+        return self._groupers[group]
 
-    def _add(self, func, group: CallbackGroup, factory=None, **kwargs):
-        if factory is None:
-            factory = self.factory
-        spec = factory(func, group, **kwargs)
+    def _add(self, func, group: CallbackGroup, **kwargs):
+        if isinstance(func, CallbackSpec):
+            spec = func
+        else:
+            spec = self.factory(func, group, **kwargs)
 
         if spec in self.items:
             return
@@ -291,7 +233,7 @@ class CallbackWrapper:
         unique_key: str,
     ) -> None:
         self._callback = callback
-        self._iscoro = iscoroutinefunction(callback)
+        self._iscoro = getattr(callback, "is_coroutine", False)
         self.condition = condition
         self.meta = meta
         self.unique_key = unique_key
@@ -338,19 +280,21 @@ class CallbacksExecutor:
     def __str__(self):
         return ", ".join(str(c) for c in self)
 
-    def _add(self, spec: CallbackSpec, resolver: "Listeners"):
-        for callback in spec.build(resolver):
-            if callback.unique_key in self.items_already_seen:
-                continue
+    def add(self, key: str, spec: CallbackSpec, builder: Callable[[], Callable]):
+        if key in self.items_already_seen:
+            return
 
-            self.items_already_seen.add(callback.unique_key)
-            insort(self.items, callback)
+        self.items_already_seen.add(key)
 
-    def add(self, items: Iterable[CallbackSpec], resolver: "Listeners"):
-        """Validate configurations"""
-        for item in items:
-            self._add(item, resolver)
-        return self
+        condition = spec.cond if spec.cond is not None else allways_true
+        wrapper = CallbackWrapper(
+            callback=builder(),
+            condition=condition,
+            meta=spec,
+            unique_key=key,
+        )
+
+        insort(self.items, wrapper)
 
     async def async_call(self, *args, **kwargs):
         return await asyncio.gather(
@@ -387,9 +331,6 @@ class CallbacksRegistry:
         self._registry: Dict[str, CallbacksExecutor] = defaultdict(CallbacksExecutor)
         self.has_async_callbacks: bool = False
 
-    def clear(self):
-        self._registry.clear()
-
     def __getitem__(self, key: str) -> CallbacksExecutor:
         return self._registry[key]
 
@@ -402,7 +343,8 @@ class CallbacksRegistry:
                 callback for callback in self[meta.group.build_key(specs)] if callback.meta == meta
             ):
                 continue
-            if hasattr(meta, "names_not_found"):
+
+            if meta.names_not_found:
                 raise AttrNotFound(
                     _("Did not found name '{}' from model or statemachine").format(
                         ", ".join(meta.names_not_found)
@@ -416,3 +358,24 @@ class CallbacksRegistry:
         self.has_async_callbacks = any(
             callback._iscoro for executor in self._registry.values() for callback in executor
         )
+
+    def call(self, key: str, *args, **kwargs):
+        if key not in self._registry:
+            return []
+        return self._registry[key].call(*args, **kwargs)
+
+    def async_call(self, key: str, *args, **kwargs):
+        return self._registry[key].async_call(*args, **kwargs)
+
+    def all(self, key: str, *args, **kwargs):
+        if key not in self._registry:
+            return True
+        return self._registry[key].all(*args, **kwargs)
+
+    def async_all(self, key: str, *args, **kwargs):
+        return self._registry[key].async_all(*args, **kwargs)
+
+    def str(self, key: str) -> str:
+        if key not in self._registry:
+            return ""
+        return str(self._registry[key])

statemachine/contrib/diagram.py

@@ -29,7 +29,7 @@ class DotGraphMachine:
     transition_font_size = "9"
     """Transition font size in points"""
 
-    def __init__(self, machine):
+    def __init__(self, machine: StateMachine):
         self.machine = machine
 
     def _get_graph(self):
@@ -69,11 +69,11 @@ class DotGraphMachine:
     def _actions_getter(self):
         if isinstance(self.machine, StateMachine):
 
-            def getter(grouper):
-                return self.machine._get_callbacks(grouper.key)
+            def getter(grouper) -> str:
+                return self.machine._callbacks.str(grouper.key)
         else:
 
-            def getter(grouper):
+            def getter(grouper) -> str:
                 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