refac: Improved internal APIs for engine and callbacks registry (#459)

Author: fgmacedo

statemachine/callbacks.py

@@ -1,6 +1,5 @@
 import asyncio
 from bisect import insort
-from collections import Counter
 from collections import defaultdict
 from collections import deque
 from enum import IntEnum
@@ -335,7 +334,7 @@ def all(self, *args, **kwargs):
 class CallbacksRegistry:
     def __init__(self) -> None:
         self._registry: Dict[str, CallbacksExecutor] = defaultdict(CallbacksExecutor)
-        self._method_types: Counter = Counter()
+        self.has_async_callbacks: bool = False
 
     def clear(self):
         self._registry.clear()
@@ -357,6 +356,6 @@ def check(self, specs: CallbackSpecList):
             )
 
     def async_or_sync(self):
-        self._method_types.update(
+        self.has_async_callbacks = any(
             callback._iscoro for executor in self._registry.values() for callback in executor
         )

statemachine/engines/async_.py

@@ -31,9 +31,9 @@ async def activate_initial_state(self):
         Given how async works on python, there's no built-in way to activate the initial state that
         may depend on async code from the StateMachine.__init__ method.
         """
-        return await self._processing_loop()
+        return await self.processing_loop()
 
-    async def _processing_loop(self):
+    async def processing_loop(self):
         """Process event triggers.
 
         The simplest implementation is the non-RTC (synchronous),

statemachine/engines/sync.py

@@ -29,9 +29,9 @@ def activate_initial_state(self):
         Given how async works on python, there's no built-in way to activate the initial state that
         may depend on async code from the StateMachine.__init__ method.
         """
-        return self._processing_loop()
+        return self.processing_loop()
 
-    def _processing_loop(self):
+    def processing_loop(self):
         """Process event triggers.
 
         The simplest implementation is the non-RTC (synchronous),

statemachine/statemachine.py

@@ -106,7 +106,7 @@ def __init__(
         self._engine = self._get_engine(rtc)
 
     def _get_engine(self, rtc: bool):
-        if self._callbacks_registry._method_types[True] > 0:
+        if self._callbacks_registry.has_async_callbacks:
             return AsyncEngine(self, rtc=rtc)
         else:
             return SyncEngine(self, rtc=rtc)
@@ -118,7 +118,7 @@ def activate_initial_state(self):
         return run_async_from_sync(result)
 
     def _processing_loop(self):
-        return self._engine._processing_loop()
+        return self._engine.processing_loop()
 
     def __init_subclass__(cls, strict_states: bool = False):
         cls._strict_states = strict_states
@@ -303,9 +303,6 @@ def _put_nonblocking(self, trigger_data: TriggerData):
     def send(self, event: str, *args, **kwargs):
         """Send an :ref:`Event` to the state machine.
 
-        This is a thin wrapper around :meth:`async_send` to allow synchronous
-        code to send events.
-
         .. seealso::
 
             See: :ref:`triggering events`.