Merge branch 'release/2.1.2'

.github/workflows/python-package.yml

@@ -29,6 +29,7 @@ jobs:
  - name: Install Poetry
  uses: snok/install-poetry@v1
  with:
+ version: 1.5.1
  virtualenvs-create: true
  virtualenvs-in-project: true
  installer-parallel: true

.gitignore

@@ -40,6 +40,8 @@ pip-log.txt
 pip-delete-this-directory.txt
 
 # Unit test / coverage reports
+prof/
+.benchmarks/
 htmlcov/
 .tox/
 .coverage

docs/actions.md

@@ -87,7 +87,7 @@ All actions and {ref}`guards` support multiple method signatures. They follow th
 
 For each defined {ref}`state`, you can declare `enter` and `exit` callbacks.
 
-### Declare state actions by naming convention
+### Bind state actions by naming convention
 
 Callbacks by naming convention will be searched on the StateMachine and on the
 model, using the patterns:

docs/releases/2.1.2.md

@@ -0,0 +1,20 @@
+# StateMachine 2.1.2
+
+*October 6, 2023*
+
+This release improves the setup performance of the library by a 10x factor, with a major
+refactoring on how we handle the callbacks registry and validations.
+
+See [#401](https://github.com/fgmacedo/python-statemachine/issues/401) for the technical details.
+
+
+## Python compatibility 2.1.2
+
+StateMachine 2.1.2 supports Python 3.7, 3.8, 3.9, 3.10, 3.11 and 3.12.
+
+On the next major release (3.0.0), we will drop support for Python 3.7.
+
+## Bugfixes in 2.1.2
+
+- Fixes [#406](https://github.com/fgmacedo/python-statemachine/issues/406) action callback being
+ called twice when mixing decorator syntax combined with the naming convention.

docs/releases/index.md

@@ -13,8 +13,9 @@ Below are release notes through StateMachine and its patch releases.
 ### 2.0 releases
 
 ```{toctree}
-:maxdepth: 1
+:maxdepth: 2
 
+2.1.2
 2.1.1
 2.1.0
 2.0.0

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-statemachine"
-version = "2.1.1"
+version = "2.1.2"
 description = "Python Finite State Machines made easy."
 authors = ["Fernando Macedo <[email protected]>"]
 maintainers = [
@@ -26,14 +26,15 @@ classifiers = [
  "Programming Language :: Python :: 3.9",
  "Programming Language :: Python :: 3.10",
  "Programming Language :: Python :: 3.11",
+ "Programming Language :: Python :: 3.12",
  "Topic :: Software Development :: Libraries"
 ]
 
 [tool.poetry.extras]
 diagrams = ["pydot"]
 
 [tool.poetry.dependencies]
-python = ">=3.7, <3.12"
+python = ">=3.7, <3.13"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.0"
@@ -46,6 +47,8 @@ mypy = "^0.991"
 black = "^22.12.0"
 pdbpp = "^0.10.3"
 pytest-mock = "^3.10.0"
+pytest-profiling = "^1.7.0"
+pytest-benchmark = "^4.0.0"
 
 [tool.poetry.group.docs.dependencies]
 Sphinx = "4.5.0"
@@ -60,13 +63,14 @@ 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"
+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"
 doctest_optionflags = "ELLIPSIS IGNORE_EXCEPTION_DETAIL NORMALIZE_WHITESPACE IGNORE_EXCEPTION_DETAIL"
 
 [tool.mypy]
-python_version = "3.11"
+python_version = "3.12"
 warn_return_any = true
 warn_unused_configs = true
+disable_error_code = "annotation-unchecked"
 
 [[tool.mypy.overrides]]
 module = [

statemachine/__init__.py

@@ -3,6 +3,6 @@
 
 __author__ = """Fernando Macedo"""
 __email__ = "[email protected]"
-__version__ = "2.1.1"
+__version__ = "2.1.2"
 
 __all__ = ["StateMachine", "State"]

statemachine/callbacks.py

@@ -1,11 +1,39 @@
+from collections import defaultdict
+from collections import deque
+from typing import Callable
+from typing import Dict
+from typing import List
+
 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.
+ def __init__(
+ self,
+ callback: Callable,
+ condition: Callable,
+ unique_key: str,
+ expected_value: "bool | None" = None,
+ ) -> None:
+ self._callback = callback
+ self.condition = condition
+ self.unique_key = unique_key
+ self.expected_value = expected_value
+
+ def __repr__(self):
+ return f"{type(self).__name__}({self.unique_key})"
+
+ def __call__(self, *args, **kwargs):
+ result = self._callback(*args, **kwargs)
+ if self.expected_value is not None:
+ return bool(result) == self.expected_value
+ return result
+
+
+class CallbackMeta:
+ """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
  a callable, his signature can mismatch.
@@ -14,12 +42,11 @@ class CallbackWrapper:
  call is performed, to allow the proper callback resolution.
  """
 
- def __init__(self, func, suppress_errors=False, cond=None):
+ def __init__(self, func, suppress_errors=False, cond=None, 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.cond = CallbackMetaList().add(cond)
+ self.expected_value = expected_value
 
  def __repr__(self):
  return f"{type(self).__name__}({self.func!r})"
@@ -28,57 +55,67 @@ def __str__(self):
  return getattr(self.func, "__name__", self.func)
 
  def __eq__(self, other):
- return self.func == other.func and self._resolver_id == other._resolver_id
+ return self.func == other.func
 
  def __hash__(self):
  return id(self)
 
  def _update_func(self, func):
  self.func = func
 
- def setup(self, resolver):
+ def build(self, resolver) -> "CallbackWrapper | 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`.
  """
- 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
+ callback = resolver(self.func)
+ if not callback.is_empty:
+ conditions = CallbacksExecutor()
+ conditions.add(self.cond, resolver)
+
+ return CallbackWrapper(
+ callback=callback,
+ condition=conditions.all,
+ unique_key=callback.unique_key,
+ expected_value=self.expected_value,
+ )
 
- def __call__(self, *args, **kwargs):
- if self._callback is None:
- raise InvalidDefinition(
- _("Callback {!r} not property configured.").format(self)
+ if not self.suppress_errors:
+ raise AttrNotFound(
+ _("Did not found name '{}' from model or statemachine").format(
+ self.func
+ )
  )
- return self._callback(*args, **kwargs)
+ return None
+
 
+class BoolCallbackMeta(CallbackMeta):
+ """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
+ 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 ConditionWrapper(CallbackWrapper):
- def __init__(self, func, suppress_errors=False, expected_value=True):
- super().__init__(func, suppress_errors)
+ def __init__(self, func, suppress_errors=False, cond=None, expected_value=True):
+ self.func = func
+ self.suppress_errors = suppress_errors
+ self.cond = CallbackMetaList().add(cond)
  self.expected_value = expected_value
 
  def __str__(self):
  name = super().__str__()
  return name if self.expected_value else f"!{name}"
 
- def __call__(self, *args, **kwargs):
- return bool(super().__call__(*args, **kwargs)) == self.expected_value
-
 
-class Callbacks:
- def __init__(self, resolver=None, factory=CallbackWrapper):
- self.items = []
- self._resolver = resolver
+class CallbackMetaList:
+ def __init__(self, factory=CallbackMeta):
+ self.items: List[CallbackMeta] = []
  self.factory = factory
 
  def __repr__(self):
@@ -87,13 +124,6 @@ def __repr__(self):
  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.
@@ -135,31 +165,19 @@ def __iter__(self):
  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 all(self, *args, **kwargs):
- return all(condition(*args, **kwargs) for condition in self)
-
- 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):
+ def _add(self, func, registry=None, prepend=False, **kwargs):
+ meta = self.factory(func, **kwargs)
+ if registry is not None and not registry(self, meta, prepend=prepend):
  return
 
- if callback in self.items:
+ if meta in self.items:
  return
 
  if prepend:
- self.items.insert(0, callback)
+ self.items.insert(0, meta)
  else:
- self.items.append(callback)
- return callback
+ self.items.append(meta)
+ return meta
 
  def add(self, callbacks, **kwargs):
  if callbacks is None:
@@ -170,3 +188,73 @@ def add(self, callbacks, **kwargs):
  self._add(func, **kwargs)
 
  return self
+
+
+class CallbacksExecutor:
+ 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 add_one(
+ self, callback_info: CallbackMeta, resolver: Callable, prepend: bool = False
+ ) -> "CallbackWrapper | None":
+ callback = callback_info.build(resolver)
+ if callback is None:
+ return None
+
+ if callback.unique_key in self.items_already_seen:
+ return None
+
+ self.items_already_seen.add(callback.unique_key)
+ if prepend:
+ self.items.insert(0, callback)
+ else:
+ self.items.append(callback)
+ return callback
+
+ def add(self, items: CallbackMetaList, resolver: Callable):
+ """Validate configurations"""
+ for item in items:
+ self.add_one(item, resolver)
+ return self
+
+ def call(self, *args, **kwargs):
+ return [
+ callback(*args, **kwargs)
+ for callback in self
+ if callback.condition(*args, **kwargs)
+ ]
+
+ def all(self, *args, **kwargs):
+ return all(condition(*args, **kwargs) for condition in self)
+
+
+class CallbacksRegistry:
+ def __init__(self) -> None:
+ self._registry: Dict[CallbackMetaList, CallbacksExecutor] = defaultdict(
+ CallbacksExecutor
+ )
+
+ def register(self, callbacks: CallbackMetaList, resolver):
+ executor_list = self[callbacks]
+ executor_list.add(callbacks, resolver)
+ return executor_list
+
+ def __getitem__(self, callbacks: CallbackMetaList) -> CallbacksExecutor:
+ return self._registry[callbacks]
+
+ def build_register_function_for_resolver(self, resolver):
+ def register(
+ meta_list: CallbackMetaList,
+ meta: CallbackMeta,
+ prepend: bool = False,
+ ):
+ return self[meta_list].add_one(meta, resolver, prepend=prepend)
+
+ return register