Improve callback registry (#442)

* chore: 15% faster setup with attr by name comparison
* refac: Renaming callbacks methods
* refac: Renaming callbacks to specs when refering to metadata
* refac: Removing resolver_factory

Author: fgmacedo

docs/images/order_control_machine_initial.png

@@ -65,7 +65,7 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.pytest.ini_options]
-addopts = "--ignore=docs/conf.py --ignore=docs/auto_examples/ --ignore=docs/_build/ --ignore=tests/examples/ --cov --cov-config .coveragerc --doctest-glob='*.md' --doctest-modules --doctest-continue-on-failure --benchmark-autosave"
+addopts = "--ignore=docs/conf.py --ignore=docs/auto_examples/ --ignore=docs/_build/ --ignore=tests/examples/ --cov --cov-config .coveragerc --doctest-glob='*.md' --doctest-modules --doctest-continue-on-failure --benchmark-autosave --benchmark-group-by=name"
 doctest_optionflags = "ELLIPSIS IGNORE_EXCEPTION_DETAIL NORMALIZE_WHITESPACE IGNORE_EXCEPTION_DETAIL"
 asyncio_mode = "auto"
 markers = [

pyproject.toml

@@ -2,10 +2,13 @@
 from collections import defaultdict
 from collections import deque
 from enum import IntEnum
+from enum import auto
 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,74 +23,81 @@ 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
 
-    def __repr__(self):
-        return f"{type(self).__name__}({self.unique_key})"
+class CallbackGroup(IntEnum):
+    ENTER = auto()
+    EXIT = auto()
+    VALIDATOR = auto()
+    BEFORE = auto()
+    ON = auto()
+    AFTER = auto()
+    COND = auto()
 
-    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)
+async 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)
 
     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
+        self.reference = SpecReference.CALLABLE
+        self.attr_name = attr_name
 
     def _wrap_callable(self, func, _expected_value):
         return func
@@ -100,8 +110,12 @@ def build(self, resolver) -> Generator["CallbackWrapper", None, None]:
             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 = (
+                next(resolver.search(CallbackSpec(self.cond, CallbackGroup.COND)))
+                if self.cond is not None
+                else allways_true
+            )
             yield CallbackWrapper(
                 callback=self._wrap_callable(callback, self.expected_value),
                 condition=condition,
@@ -110,7 +124,7 @@ def build(self, resolver) -> Generator["CallbackWrapper", None, None]:
             )
 
 
-class BoolCallbackMeta(CallbackMeta):
+class BoolCallbackSpec(CallbackSpec):
     """A thin wrapper that register info about actions and guards.
 
     At first, `func` can be a string or a callable, and even if it's already
@@ -123,13 +137,14 @@ class BoolCallbackMeta(CallbackMeta):
     def __init__(
         self,
         func,
-        suppress_errors=False,
+        group: CallbackGroup,
+        is_convention=False,
         cond=None,
         priority: CallbackPriority = CallbackPriority.NAMING,
         expected_value=True,
     ):
         super().__init__(
-            func, suppress_errors, cond, priority=priority, expected_value=expected_value
+            func, group, is_convention, cond, priority=priority, expected_value=expected_value
         )
 
     def __str__(self):
@@ -143,19 +158,47 @@ async def bool_wrapper(*args, **kwargs):
         return bool_wrapper
 
 
-class CallbackMetaList:
-    """List of `CallbackMeta` instances"""
+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 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 __init__(self, factory=CallbackMeta):
-        self.items: List[CallbackMeta] = []
+    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 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 _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 +222,76 @@ def _add_unbounded_callback(self, func, is_event=False, transitions=None, **kwar
                 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.condition = condition
+        self.meta = meta
+        self.unique_key = unique_key
+
+    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):
+        return await self._callback(*args, **kwargs)
+
+
 class CallbacksExecutor:
     """A list of callbacks that can be executed in order."""
 
@@ -234,15 +308,15 @@ def __repr__(self):
     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)
@@ -264,26 +338,22 @@ async def all(self, *args, **kwargs):
 
 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)
 
     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)