python-statemachine 2.1.0__py3-none-any.whl → 2.3.5__py3-none-any.whl

{python_statemachine-2.1.0.dist-info → python_statemachine-2.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-statemachine
-Version: 2.1.0
+Version: 2.3.5
 Summary: Python Finite State Machines made easy.
 Home-page: https://github.com/fgmacedo/python-statemachine
 License: MIT
@@ -8,7 +8,8 @@ Author: Fernando Macedo
 Author-email: fgmacedo@gmail.com
 Maintainer: Fernando Macedo
 Maintainer-email: fgmacedo@gmail.com
-Requires-Python: >=3.7,<3.12
+Requires-Python: >=3.7
+Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
@@ -18,11 +19,8 @@ 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.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Provides-Extra: diagrams
 Description-Content-Type: text/markdown
@@ -30,8 +28,8 @@ Description-Content-Type: text/markdown
 # Python StateMachine
 
 [![pypi](https://img.shields.io/pypi/v/python-statemachine.svg)](https://pypi.python.org/pypi/python-statemachine)
+[![downloads total](https://static.pepy.tech/badge/python-statemachine)](https://pepy.tech/project/python-statemachine)
 [![downloads](https://img.shields.io/pypi/dm/python-statemachine.svg)](https://pypi.python.org/pypi/python-statemachine)
-[![build status](https://github.com/fgmacedo/python-statemachine/actions/workflows/python-package.yml/badge.svg?branch=develop)](https://github.com/fgmacedo/python-statemachine/actions/workflows/python-package.yml?query=branch%3Adevelop)
 [![Coverage report](https://codecov.io/gh/fgmacedo/python-statemachine/branch/develop/graph/badge.svg)](https://codecov.io/gh/fgmacedo/python-statemachine)
 [![Documentation Status](https://readthedocs.org/projects/python-statemachine/badge/?version=latest)](https://python-statemachine.readthedocs.io/en/latest/?badge=latest)
 [![GitHub commits since last release (main)](https://img.shields.io/github/commits-since/fgmacedo/python-statemachine/main/develop)](https://github.com/fgmacedo/python-statemachine/compare/main...develop)
@@ -39,33 +37,43 @@ Description-Content-Type: text/markdown
 
 Python [finite-state machines](https://en.wikipedia.org/wiki/Finite-state_machine) made easy.
 
+<div align="center">
 
-* Free software: MIT license
-* Documentation: https://python-statemachine.readthedocs.io.
-
+![](https://github.com/fgmacedo/python-statemachine/blob/develop/docs/images/python-statemachine.png?raw=true)
 
-Welcome to python-statemachine, an intuitive and powerful state machine framework designed for a
-great developer experience.
+</div>
 
-🚀 With StateMachine, you can easily create complex, dynamic systems with clean, readable code.
+Welcome to python-statemachine, an intuitive and powerful state machine library designed for a
+great developer experience. We provide a _pythonic_ and expressive API for implementing state
+machines in sync or asynchonous Python codebases.
 
-💡 Our framework makes it easy to understand and reason about the different states, events and
-transitions in your system, so you can focus on building great products.
+## Features
 
-🔒 python-statemachine also provides robust error handling and ensures that your system stays
-in a valid state at all times.
+- ✨ **Basic components**: Easily define **States**, **Events**, and **Transitions** to model your logic.
+- ⚙️ **Actions and handlers**: Attach actions and handlers to states, events, and transitions to control behavior dynamically.
+- 🛡️ **Conditional transitions**: Implement **Guards** and **Validators** to conditionally control transitions, ensuring they only occur when specific conditions are met.
+- 🚀 **Full async support**: Enjoy full asynchronous support. Await events, and dispatch callbacks asynchronously for seamless integration with async codebases.
+- 🔄 **Full sync support**: Use the same state machine from synchronous codebases without any modifications.
+- 🎨 **Declarative and simple API**: Utilize a clean, elegant, and readable API to define your state machine, making it easy to maintain and understand.
+- 👀 **Observer pattern support**: Register external and generic objects to watch events and register callbacks.
+- 🔍 **Decoupled design**: Separate concerns with a decoupled "state machine" and "model" design, promoting cleaner architecture and easier maintenance.
+- ✅ **Correctness guarantees**: Ensured correctness with validations at class definition time:
+   - Ensures exactly one `initial` state.
+   - Disallows transitions from `final` states.
+   - Requires ongoing transitions for all non-final states.
+   - Guarantees all non-final states have at least one path to a final state if final states are declared.
+   - Validates the state machine graph representation has a single component.
+- 📦 **Flexible event dispatching**: Dispatch events with any extra data, making it available to all callbacks, including actions and guards.
+- 🔧 **Dependency injection**: Needed parameters are injected into callbacks.
+- 📊 **Graphical representation**: Generate and output graphical representations of state machines. Create diagrams from the command line, at runtime, or even in Jupyter notebooks.
+- 🌍 **Internationalization support**: Provides error messages in different languages, making the library accessible to a global audience.
+- 🛡️ **Robust testing**: Ensured reliability with a codebase that is 100% covered by automated tests, including all docs examples. Releases follow semantic versioning for predictable releases.
+- 🏛️ **Domain model integration**: Seamlessly integrate with domain models using Mixins.
+- 🔧 **Django integration**: Automatically discover state machines in Django applications.
 
 
-A few reasons why you may consider using it:
-
-* 📈 python-statemachine is designed to help you build scalable,
-  maintainable systems that can handle any complexity.
-* 💪 You can easily create and manage multiple state machines within a single application.
-* 🚫 Prevents common mistakes and ensures that your system stays in a valid state at all times.
-
-
-## Getting started
 
+## Installing
 
 To install Python State Machine, run this command in your terminal:
 
@@ -77,6 +85,8 @@ our docs for more details.
 
     pip install python-statemachine[diagrams]
 
+## First example
+
 Define your state machine:
 
 ```py
@@ -137,7 +147,7 @@ Then start sending events to your new state machine:
 
 ```
 
-That's it. This is all an external object needs to know about your state machine: How to send events.
+**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.
 
 But if your use case needs, you can inspect state machine properties, like the current state:
@@ -269,6 +279,34 @@ and in diagrams:
 
 ```
 
+## Async support
+
+We support native coroutine using `asyncio`, enabling seamless integration with asynchronous code.
+There's no change on the public API of the library to work on async codebases.
+
+
+```py
+>>> class AsyncStateMachine(StateMachine):
+...     initial = State('Initial', initial=True)
+...     final = State('Final', final=True)
+...
+...     advance = initial.to(final)
+...
+...     async def on_advance(self):
+...         return 42
+
+>>> async def run_sm():
+...     sm = AsyncStateMachine()
+...     result = await sm.advance()
+...     print(f"Result is {result}")
+...     print(sm.current_state)
+
+>>> asyncio.run(run_sm())
+Result is 42
+Final
+
+```
+
 ## A more useful example
 
 A simple didactic state machine for controlling an `Order`:
@@ -375,7 +413,7 @@ https://python-statemachine.readthedocs.io.
 - If you found this project helpful, please consider giving it a star on GitHub.
 
 - **Contribute code**: If you would like to contribute code to this project, please submit a pull
-request. For more information on how to contribute, please see our [contributing.md]contributing.md) file.
+request. For more information on how to contribute, please see our [contributing.md](contributing.md) file.
 
 - **Report bugs**: If you find any bugs in this project, please report them by opening an issue
   on our GitHub issue tracker.

python_statemachine-2.3.5.dist-info/RECORD

@@ -0,0 +1,32 @@
+statemachine/__init__.py,sha256=ZSwV-f_lq_MIAG00F_PCnS-514sn_jf-6uykaeGD5Ug,192
+statemachine/callbacks.py,sha256=5_WaILrjUvZOYX_LQe4Gd8nsCvkErjw9DaHYG_ggvxs,11101
+statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/contrib/diagram.py,sha256=eK3unncEXNq3e_yfBTZmvgdWWWDZq69r7gsHvCHr5Ys,7208
+statemachine/dispatcher.py,sha256=2DtjCj_kiDF2uk_EEvXxs5NTABOvCr4paxVz77s6mXA,5365
+statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/engines/async_.py,sha256=Z-AS4zQ2xDj2uexJ7fepQTSaw5PjqesemWGXX9g0rpU,5546
+statemachine/engines/sync.py,sha256=bYCyzoYo03LLfxzUl2XyyNlmMmxDLn_w0AMa5IHCF3U,5497
+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/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=WgI4LbnOyOBl8OZqBXFRYETtt8rQi0XEhQN-D_2oMFM,11536
+statemachine/states.py,sha256=vpRNjiGmTDHvE0fn0gwdq8-WcG32n4ZiPTU-kgZ73rc,4870
+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.5.dist-info/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
+python_statemachine-2.3.5.dist-info/METADATA,sha256=CWbBQMeVziWU_TJdMiH67aDjn-Tw7OeOXVSFRzXO83Y,13983
+python_statemachine-2.3.5.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+python_statemachine-2.3.5.dist-info/RECORD,,

{python_statemachine-2.1.0.dist-info → python_statemachine-2.3.5.dist-info}/WHEEL

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

statemachine/__init__.py

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

statemachine/callbacks.py

@@ -1,42 +1,116 @@
+import asyncio
+from bisect import insort
+from collections import defaultdict
+from collections import deque
+from enum import IntEnum
+from enum import IntFlag
+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 .exceptions import InvalidDefinition
 from .i18n import _
 from .utils import ensure_iterable
 
 
-class CallbackWrapper:
-    """A thin wrapper that ensures the target callback is a proper callable.
+class CallbackPriority(IntEnum):
+    GENERIC = 0
+    INLINE = 10
+    DECORATOR = 20
+    NAMING = 30
+    AFTER = 40
+
+
+class SpecReference(IntFlag):
+    NAME = auto()
+    CALLABLE = auto()
+    PROPERTY = auto()
+
+
+SPECS_ALL = SpecReference.NAME | SpecReference.CALLABLE | SpecReference.PROPERTY
+SPECS_SAFE = SpecReference.NAME
+
+
+class CallbackGroup(IntEnum):
+    ENTER = auto()
+    EXIT = auto()
+    VALIDATOR = auto()
+    BEFORE = auto()
+    ON = auto()
+    AFTER = auto()
+    COND = auto()
+
+    def build_key(self, specs: "CallbackSpecList") -> str:
+        return f"{self.name}@{id(specs)}"
+
+
+def allways_true(*args, **kwargs):
+    return True
 
-    At first, `func` can be a string or a callable, and even if it's already
-    a callable, his signature can mismatch.
 
-    After instantiation, `.setup(resolver)` must be called before any real
-    call is performed, to allow the proper callback resolution.
+class CallbackSpec:
+    """Specs about callbacks.
+
+    At first, `func` can be a name (string), a property or a callable.
+
+    Names, properties and unbounded callables should be resolved to a callable
+    before any real call is performed.
     """
 
-    def __init__(self, func, suppress_errors=False, cond=None):
+    def __init__(
+        self,
+        func,
+        group: CallbackGroup,
+        is_convention=False,
+        cond=None,
+        priority: CallbackPriority = CallbackPriority.NAMING,
+        expected_value=None,
+    ):
         self.func = func
-        self.suppress_errors = suppress_errors
-        self.cond = Callbacks(factory=ConditionWrapper).add(cond)
-        self._callback = None
-        self._resolver_id = None
+        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})"
+        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 and self._resolver_id == other._resolver_id
+        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
+        self.reference = SpecReference.CALLABLE
+        self.attr_name = attr_name
 
-    def setup(self, resolver):
+    def build(self, resolver) -> Generator["CallbackWrapper", None, None]:
         """
         Resolves the `func` into a usable callable.
 
@@ -44,56 +118,57 @@ class CallbackWrapper:
             resolver (callable): A method responsible to build and return a valid callable that
                 can receive arbitrary parameters like `*args, **kwargs`.
         """
-        self.cond.setup(resolver)
-        try:
-            self._resolver_id = getattr(resolver, "id", id(resolver))
-            self._callback = resolver(self.func)
-            return True
-        except AttrNotFound:
-            if not self.suppress_errors:
-                raise
-            return False
-
-    def __call__(self, *args, **kwargs):
-        if self._callback is None:
-            raise InvalidDefinition(
-                _("Callback {!r} not property configured.").format(self)
+        for callback in resolver.search(self):
+            condition = self.cond if self.cond is not None else allways_true
+            yield CallbackWrapper(
+                callback=callback,
+                condition=condition,
+                meta=self,
+                unique_key=callback.unique_key,
             )
-        return self._callback(*args, **kwargs)
 
 
-class ConditionWrapper(CallbackWrapper):
-    def __init__(self, func, suppress_errors=False, expected_value=True):
-        super().__init__(func, suppress_errors)
-        self.expected_value = expected_value
+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)
 
-    def __str__(self):
-        name = super().__str__()
-        return name if self.expected_value else f"!{name}"
+    def add(self, callbacks, **kwargs):
+        self.list.add(callbacks, group=self.group, factory=self.factory, **kwargs)
+        return self
+
+    def __call__(self, callback):
+        return self.list._add_unbounded_callback(callback, group=self.group, factory=self.factory)
 
-    def __call__(self, *args, **kwargs):
-        return bool(super().__call__(*args, **kwargs)) == self.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 __iter__(self):
+        return (item for item in self.list if item.group == self.group)
 
-class Callbacks:
-    def __init__(self, resolver=None, factory=CallbackWrapper):
-        self.items = []
-        self._resolver = resolver
+
+class CallbackSpecList:
+    """List of {ref}`CallbackSpec` instances"""
+
+    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 setup(self, resolver):
-        """Validate configurations"""
-        self._resolver = resolver
-        self.items = [
-            callback for callback in self.items if callback.setup(self._resolver)
-        ]
-
     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.
@@ -117,56 +192,175 @@ class Callbacks:
                 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):
-        return self._add_unbounded_callback(callback)
-
     def __iter__(self):
         return iter(self.items)
 
     def clear(self):
         self.items = []
 
-    def call(self, *args, **kwargs):
-        return [
-            callback(*args, **kwargs)
-            for callback in self.items
-            if callback.cond.all(*args, **kwargs)
-        ]
+    def grouper(
+        self, group: CallbackGroup, factory: Type[CallbackSpec] = CallbackSpec
+    ) -> SpecListGrouper:
+        return SpecListGrouper(self, group, factory=factory)
 
-    def all(self, *args, **kwargs):
-        return all(condition(*args, **kwargs) for condition in self)
+    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, resolver=None, prepend=False, **kwargs):
-        resolver = resolver or self._resolver
-
-        callback = self.factory(func, **kwargs)
-        if resolver is not None and not callback.setup(resolver):
+        if spec in self.items:
             return
 
-        if callback in self.items:
-            return
+        self.items.append(spec)
+        if spec.is_convention:
+            self.conventional_specs.add(spec.func)
+        return spec
 
-        if prepend:
-            self.items.insert(0, callback)
-        else:
-            self.items.append(callback)
-        return callback
-
-    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."""
+
+    def __init__(self):
+        self.items: List[CallbackWrapper] = deque()
+        self.items_already_seen = set()
+
+    def __iter__(self):
+        return iter(self.items)
+
+    def __repr__(self):
+        return f"{type(self).__name__}({self.items!r})"
+
+    def __str__(self):
+        return ", ".join(str(c) for c in self)
+
+    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: Iterable[CallbackSpec], resolver: Callable):
+        """Validate configurations"""
+        for item in items:
+            self._add(item, resolver)
+        return self
+
+    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 [
+            callback.call(*args, **kwargs)
+            for callback in self
+            if callback.condition(*args, **kwargs)
+        ]
+
+    def all(self, *args, **kwargs):
+        for condition in self:
+            if not condition.call(*args, **kwargs):
+                return False
+        return True
+
+
+class CallbacksRegistry:
+    def __init__(self) -> None:
+        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]
+
+    def check(self, specs: CallbackSpecList):
+        for meta in specs:
+            if meta.is_convention:
+                continue
+
+            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.has_async_callbacks = any(
+            callback._iscoro for executor in self._registry.values() for callback in executor
+        )