macedo/refac dispatcher (#490)

* refac: Removing registry's dependency of Listeners
* refac: Move all callback search to the dispatcher module

Author: fgmacedo

pyproject.toml

@@ -155,6 +155,7 @@ convention = "google"
 
 [tool.coverage.run]
 branch = true
+dynamic_context = "test_function"
 relative_files = true
 data_file = ".coverage"
 source = ["statemachine"]
@@ -177,3 +178,4 @@ exclude_lines = [
 
 [tool.coverage.html]
 directory = "tmp/htmlcov"
+show_contexts = true

statemachine/callbacks.py

@@ -5,29 +5,23 @@
 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 +55,6 @@ def build_key(self, specs: "CallbackSpecList") -> str:
         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,6 +64,9 @@ 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,
@@ -112,6 +94,12 @@ def __init__(
             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})"
 
@@ -132,71 +120,26 @@ def _update_func(self, func: Callable, attr_name: str):
         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(
             func,
             is_event=is_event,
             transitions=transitions,
             group=self.group,
-            factory=self.factory,
             **kwargs,
         )
 
@@ -210,6 +153,7 @@ 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):
@@ -253,15 +197,13 @@ def __iter__(self):
     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):
+        spec = self.factory(func, group, **kwargs)
 
         if spec in self.items:
             return
@@ -338,19 +280,21 @@ def __repr__(self):
     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(
@@ -402,7 +346,8 @@ def check(self, specs: CallbackSpecList):
                 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)