python-statemachine 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

{python_statemachine-2.5.0.dist-info → python_statemachine-2.6.0.dist-info}/METADATA

@@ -1,11 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: python-statemachine
-Version: 2.5.0
+Version: 2.6.0
 Summary: Python Finite State Machines made easy.
 Project-URL: homepage, https://github.com/fgmacedo/python-statemachine
 Author-email: Fernando Macedo <fgmacedo@gmail.com>
 Maintainer-email: Fernando Macedo <fgmacedo@gmail.com>
 License: MIT License
+License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: Django
@@ -19,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Home Automation
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.7
@@ -127,6 +129,8 @@ You can now create an instance:
 This state machine can be represented graphically as follows:
 
 ```py
+>>> # This example will only run on automated tests if dot is present
+>>> getfixture("requires_dot_installed")
 >>> img_path = "docs/images/readme_trafficlightmachine.png"
 >>> sm._graph().write_png(img_path)
 

{python_statemachine-2.5.0.dist-info → python_statemachine-2.6.0.dist-info}/RECORD

@@ -1,37 +1,37 @@
-statemachine/__init__.py,sha256=JsTxT_XFohxEg-P6qmBYcxNTwzW-A2a9zLIk7wpRzaM,226
+statemachine/__init__.py,sha256=srtcRn5wkZna0Qd1bV8rTm6SF1JM-tg47_O3kcTkBwM,226
 statemachine/callbacks.py,sha256=UUOuMotQDV3ZkpqjWp3CIL3UrA70Bh_xYDf4Ugjlou8,11475
 statemachine/dispatcher.py,sha256=Ai8i79Lo5HdUJ-toOVg4NDUzAy88sryBHDbYdl_7sWE,7785
-statemachine/event.py,sha256=DhAVtoPGCHv95r3QOuL-Tn93UMWXPhiuODFcc9FPUPA,4586
+statemachine/event.py,sha256=PceLkT5oQ4LRXHJGMqNyA43-y-CqJL9rUVCX94qaBL0,4583
 statemachine/event_data.py,sha256=H9lp_XnvHSK9YErUOCvMK3ZBjWhC-xDSOJ2gZxtmrq8,2261
 statemachine/events.py,sha256=UTYJu8te_bxiORTQpoXY5tB_x-ymVPWDOREcxCyhExA,1018
 statemachine/exceptions.py,sha256=vHVQPTTMMkVvySNbN6XZPciBryvpY608LDe3MCnmxFU,1124
 statemachine/factory.py,sha256=crL2FPfzdku3STlbxaF9N3oV9L1BFWoCAT9K3zEnBYo,9219
 statemachine/graph.py,sha256=KtwB1CYckaLjTgQD9tEeuaEzJje9q3fPVpBViW5TgSk,487
 statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
-statemachine/mixins.py,sha256=Y1fa52Cj20JaGkyNk3P7Gpqkt4cGTjJ0YyV_VQyCl0M,1231
+statemachine/mixins.py,sha256=8qxZZfBwVdFcr3oPFVWHGzgmAubH6VgQus5x3c6VEE0,1706
 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=mZjYXjMAF2XNLxI_MfTYoReJxTuPBHExEm7H76yueWY,7117
-statemachine/spec_parser.py,sha256=DRG-_6bWRTCTgU6qZHqRp5aOxFRZP0O_4VvVxyleItA,5686
+statemachine/signature.py,sha256=eoSCQkgLo4o68461WrF2_sUrlhS4gR-m8mGs6Xb-CFQ,9866
+statemachine/spec_parser.py,sha256=S2vsxIhSHUKrNhtwv_gXhc8H38n2ZCv-6Tk-18A8uR0,7298
 statemachine/state.py,sha256=a2uJZyn8sM8HdnVN_FesCgcjoeDE8gfXCAChbLm4p9g,9504
-statemachine/statemachine.py,sha256=mznQ4NpiysrHm1Ef3JPGRQ07gSXzAD9bER3r_ou9d40,10881
+statemachine/statemachine.py,sha256=leIYvPcEyotblUSnZZZHDkUYMsrxJZPFzYzFJCpa9Kk,11584
 statemachine/states.py,sha256=pPROZwIyE3_tlBGL3DJXnM3gr1pWsWICEMMo2c742RY,4889
 statemachine/transition.py,sha256=YDpI6NuCipW4cF4GVIt3o8ACE6VhWAQWHaZKjmjSQRA,5335
 statemachine/transition_list.py,sha256=I9viQ0zr6E8oL3WEESkst9DwQeTNJ6nwDAQXsWeo3_c,4179
-statemachine/transition_mixin.py,sha256=OGKF-hMyTEZDtlK_XxGaa5OqxYjmUtThMac9tDQUKUY,2615
+statemachine/transition_mixin.py,sha256=wUJ3alWMMM7hch-IJuzUaonmcvLr0rGnvWo962NYLt4,2894
 statemachine/utils.py,sha256=DpcrGqlbrnT-ogh-BogG0L07EG3KirHOsKORHlspDlI,1041
 statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 statemachine/contrib/diagram.py,sha256=CVNIhBTedik_02b-4KUua_3_HtiO1TYQNWOg3ulkqiE,7159
 statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-statemachine/engines/async_.py,sha256=HA9EtS7vYS5tulvdwH2NnTMkpUddcDZPXVNckSQFAak,5212
+statemachine/engines/async_.py,sha256=aiNv6NsfEJVm-p16FNnRVZgtwNy9iFRN3tWX01uX6LI,6322
 statemachine/engines/base.py,sha256=d65JvngOrp8sE4RR8i2wrd72wzIci9-3InMLyGdxsZQ,1201
-statemachine/engines/sync.py,sha256=Cys05fn7zQf3WowdIaVrdD8mAVQ-HEjbTMRngv_Z4cU,5035
-statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=4Pk-h5nk7twOTHcRQ_Chanfdi5EtFi9aTAzGkVJuCo8,2424
-statemachine/locale/hi_IN/LC_MESSAGES/statemachine.po,sha256=Bs5bbIxDrYtODSNJKNl4FH8ZtjEJwPIidRwbAxMwu5E,4941
-statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=gmnhc15-6YVDCLWYT0ZQL5jfXHgIOYq5p5rJLqNPaxE,3593
-statemachine/locale/zh_CN/LC_MESSAGES/statemachine.po,sha256=cDbRHDYpi3pwJkFmaSn79q5KmX9cGmHFHw1ndj37vRw,3325
-python_statemachine-2.5.0.dist-info/METADATA,sha256=LzU6fCMlw6gANXQeCCgRpyVRorsAzvF8UMWERtnowng,14068
-python_statemachine-2.5.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-python_statemachine-2.5.0.dist-info/licenses/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
-python_statemachine-2.5.0.dist-info/RECORD,,
+statemachine/engines/sync.py,sha256=HmHBMpgTtQJov1pbSPOkmWTEYkunfGa8alSXTNSDknw,6081
+statemachine/locale/en/LC_MESSAGES/statemachine.po,sha256=TuhNII8U73A-Gge-gxUKEb73g2DkQBSFHDVs3Eh1DRc,2837
+statemachine/locale/hi_IN/LC_MESSAGES/statemachine.po,sha256=OebfrHo04S65Y_cw_ZmdaPDpX-YitaGvNgrRp3v8VbU,5824
+statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po,sha256=7eWBeXqJz0XV8wTthCFeWtKnUJSbys-oBX73xXaQfLA,4211
+statemachine/locale/zh_CN/LC_MESSAGES/statemachine.po,sha256=lnCRgxeIvyDkOZVdxcGqRTwlSm9BVHjJmycumFDz0YU,3858
+python_statemachine-2.6.0.dist-info/METADATA,sha256=xBVFYCnyHePX5PMrfdLzw8tyXsx65P6njeLj35mATF8,14252
+python_statemachine-2.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_statemachine-2.6.0.dist-info/licenses/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
+python_statemachine-2.6.0.dist-info/RECORD,,

{python_statemachine-2.5.0.dist-info → python_statemachine-2.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

statemachine/__init__.py

@@ -4,6 +4,6 @@ from .statemachine import StateMachine
 
 __author__ = """Fernando Macedo"""
 __email__ = "fgmacedo@gmail.com"
-__version__ = "2.5.0"
+__version__ = "2.6.0"
 
 __all__ = ["StateMachine", "State", "Event"]

statemachine/engines/async_.py

@@ -97,6 +97,34 @@ class AsyncEngine(BaseEngine):
 
         return result if executed else None
 
+    async def enabled_events(self, *args, **kwargs):
+        sm = self.sm
+        enabled = {}
+        for transition in sm.current_state.transitions:
+            for event in transition.events:
+                if event in enabled:
+                    continue
+                extended_kwargs = kwargs.copy()
+                extended_kwargs.update(
+                    {
+                        "machine": sm,
+                        "model": sm.model,
+                        "event": getattr(sm, event),
+                        "source": transition.source,
+                        "target": transition.target,
+                        "state": sm.current_state,
+                        "transition": transition,
+                    }
+                )
+                try:
+                    if await sm._callbacks.async_all(
+                        transition.cond.key, *args, **extended_kwargs
+                    ):
+                        enabled[event] = getattr(sm, event)
+                except Exception:
+                    enabled[event] = getattr(sm, event)
+        return list(enabled.values())
+
     async def _activate(self, trigger_data: TriggerData, transition: "Transition"):
         event_data = EventData(trigger_data=trigger_data, transition=transition)
         args, kwargs = event_data.args, event_data.extended_kwargs

statemachine/engines/sync.py

@@ -99,6 +99,32 @@ class SyncEngine(BaseEngine):
 
         return result if executed else None
 
+    def enabled_events(self, *args, **kwargs):
+        sm = self.sm
+        enabled = {}
+        for transition in sm.current_state.transitions:
+            for event in transition.events:
+                if event in enabled:
+                    continue
+                extended_kwargs = kwargs.copy()
+                extended_kwargs.update(
+                    {
+                        "machine": sm,
+                        "model": sm.model,
+                        "event": getattr(sm, event),
+                        "source": transition.source,
+                        "target": transition.target,
+                        "state": sm.current_state,
+                        "transition": transition,
+                    }
+                )
+                try:
+                    if sm._callbacks.all(transition.cond.key, *args, **extended_kwargs):
+                        enabled[event] = getattr(sm, event)
+                except Exception:
+                    enabled[event] = getattr(sm, event)
+        return list(enabled.values())
+
     def _activate(self, trigger_data: TriggerData, transition: "Transition"):
         event_data = EventData(trigger_data=trigger_data, transition=transition)
         args, kwargs = event_data.args, event_data.extended_kwargs

statemachine/event.py

@@ -28,9 +28,9 @@ _event_data_kwargs = {
 
 
 class Event(AddCallbacksMixin, str):
-    """An event is triggers a signal that something has happened.
+    """An event triggers a signal that something has happened.
 
-    They are send to a state machine and allow the state machine to react.
+    They are sent to a state machine and allow the state machine to react.
 
     An event starts a :ref:`Transition`, which can be thought of as a “cause” that initiates a
     change in the state of the system.

statemachine/locale/en/LC_MESSAGES/statemachine.po

@@ -1,24 +1,35 @@
-# This file is distributed under the same license as the PROJECT project.
+# This file is distributed under the same license as the  project.
 # Fernando Macedo <fgmacedo@gmail.com>, 2024.
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: 2.4.0\n"
+"Project-Id-Version:  2.4.0\n"
 "Report-Msgid-Bugs-To: fgmacedo@gmail.com\n"
-"POT-Creation-Date: 2023-03-04 16:10-0300\n"
+"POT-Creation-Date: 2026-02-13 18:28-0300\n"
 "PO-Revision-Date: 2024-06-07 17:41-0300\n"
 "Last-Translator: Fernando Macedo <fgmacedo@gmail.com>\n"
+"Language: en\n"
+"Language-Team: en <LL@li.org>\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel 2.12.1\n"
+"Generated-By: Babel 2.16.0\n"
 
-#: statemachine/callbacks.py:165
+#: statemachine/callbacks.py:349 statemachine/callbacks.py:354
+msgid "Did not found name '{}' from model or statemachine"
+msgstr ""
+
+#: statemachine/dispatcher.py:126
 msgid "Failed to parse boolean expression '{}'"
 msgstr ""
 
-#: statemachine/callbacks.py:407 statemachine/callbacks.py:412
-msgid "Did not found name '{}' from model or statemachine"
+#: statemachine/event.py:90
+msgid "Cannot add callback '{}' to an event with no transitions."
+msgstr ""
+
+#: statemachine/event.py:123
+msgid "Event {} cannot be called without a SM instance"
 msgstr ""
 
 #: statemachine/exceptions.py:24
@@ -29,64 +40,68 @@ msgstr ""
 msgid "Can't {} when in {}."
 msgstr ""
 
-#: statemachine/factory.py:74
+#: statemachine/factory.py:73
 msgid "There are no states."
 msgstr ""
 
-#: statemachine/factory.py:77
+#: statemachine/factory.py:76
 msgid "There are no events."
 msgstr ""
 
-#: statemachine/factory.py:89
+#: statemachine/factory.py:88
 msgid ""
 "There should be one and only one initial state. You currently have these:"
 " {!r}"
 msgstr ""
 
-#: statemachine/factory.py:102
+#: statemachine/factory.py:101
 msgid "Cannot declare transitions from final state. Invalid state(s): {}"
 msgstr ""
 
-#: statemachine/factory.py:110
+#: statemachine/factory.py:109
 msgid ""
 "All non-final states should have at least one outgoing transition. These "
 "states have no outgoing transition: {!r}"
 msgstr ""
 
-#: statemachine/factory.py:124
+#: statemachine/factory.py:123
 msgid ""
 "All non-final states should have at least one path to a final state. "
 "These states have no path to a final state: {!r}"
 msgstr ""
 
-#: statemachine/factory.py:148
+#: statemachine/factory.py:147
 msgid ""
 "There are unreachable states. The statemachine graph should have a single"
 " component. Disconnected states: {}"
 msgstr ""
 
-#: statemachine/factory.py:257
+#: statemachine/factory.py:253
 msgid "An event in the '{}' has no id."
 msgstr ""
 
-#: statemachine/mixins.py:26
+#: statemachine/mixins.py:28
 msgid "{!r} is not a valid state machine name."
 msgstr ""
 
-#: statemachine/state.py:155
+#: statemachine/state.py:194
 msgid "State overriding is not allowed. Trying to add '{}' to {}"
 msgstr ""
 
-#: statemachine/statemachine.py:94
+#: statemachine/statemachine.py:89
 msgid "There are no states or transitions."
 msgstr ""
 
-#: statemachine/statemachine.py:285
+#: statemachine/statemachine.py:277
 msgid ""
 "There's no current state set. In async code, did you activate the initial"
 " state? (e.g., `await sm.activate_initial_state()`)"
 msgstr ""
 
-#: statemachine/engines/async_.py:22
+#: statemachine/transition_mixin.py:15
+msgid "{} only supports the decorator syntax to register callbacks."
+msgstr ""
+
+#: statemachine/engines/async_.py:18
 msgid "Only RTC is supported on async engine"
 msgstr ""

statemachine/locale/hi_IN/LC_MESSAGES/statemachine.po

@@ -5,22 +5,32 @@ msgid ""
 msgstr ""
 "Project-Id-Version:  2.4.0\n"
 "Report-Msgid-Bugs-To: fgmacedo@gmail.com\n"
-"POT-Creation-Date: 2023-03-04 16:10-0300\n"
+"POT-Creation-Date: 2026-02-13 18:28-0300\n"
 "PO-Revision-Date: 2024-06-07 17:41-0300\n"
 "Last-Translator: Fernando Macedo <fgmacedo@gmail.com>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: hi_IN\n"
+"Language-Team: hi_IN <LL@li.org>\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel 2.14.0\n"
+"Generated-By: Babel 2.16.0\n"
 
-#: statemachine/callbacks.py:165
+#: statemachine/callbacks.py:349 statemachine/callbacks.py:354
+msgid "Did not found name '{}' from model or statemachine"
+msgstr "मॉडल या स्टेटमशीन में नाम '{}' नहीं मिला"
+
+#: statemachine/dispatcher.py:126
 msgid "Failed to parse boolean expression '{}'"
 msgstr "बूलियन अभिव्यक्ति '{}' को पार्स करने में विफल रहा"
 
-#: statemachine/callbacks.py:407 statemachine/callbacks.py:412
-msgid "Did not found name '{}' from model or statemachine"
-msgstr "मॉडल या स्टेटमशीन में नाम '{}' नहीं मिला"
+#: statemachine/event.py:90
+msgid "Cannot add callback '{}' to an event with no transitions."
+msgstr "बिना ट्रांज़िशन वाले इवेंट में कॉलबैक '{}' नहीं जोड़ सकते।"
+
+#: statemachine/event.py:123
+msgid "Event {} cannot be called without a SM instance"
+msgstr "इवेंट {} को SM इंस्टेंस के बिना कॉल नहीं किया जा सकता"
 
 #: statemachine/exceptions.py:24
 msgid "{!r} is not a valid state value."
@@ -30,64 +40,80 @@ msgstr "{!r} एक मान्य स्टेट मान नहीं ह
 msgid "Can't {} when in {}."
 msgstr "{} स्थिति में {} नहीं कर सकते।"
 
-#: statemachine/factory.py:74
+#: statemachine/factory.py:73
 msgid "There are no states."
 msgstr "कोई स्टेट नहीं है।"
 
-#: statemachine/factory.py:77
+#: statemachine/factory.py:76
 msgid "There are no events."
 msgstr "कोई इवेंट नहीं है।"
 
-#: statemachine/factory.py:89
+#: statemachine/factory.py:88
 msgid ""
 "There should be one and only one initial state. You currently have these:"
 " {!r}"
-msgstr "एक और केवल एक प्रारंभिक स्टेट होना चाहिए। वर्तमान में आपके पास ये हैं: {!r}"
+msgstr ""
+"एक और केवल एक प्रारंभिक स्टेट होना चाहिए। वर्तमान में आपके पास ये हैं: "
+"{!r}"
 
-#: statemachine/factory.py:102
+#: statemachine/factory.py:101
 msgid "Cannot declare transitions from final state. Invalid state(s): {}"
 msgstr "अंतिम स्टेट से ट्रांज़िशन घोषित नहीं कर सकते। अमान्य स्टेट: {}"
 
-#: statemachine/factory.py:110
+#: statemachine/factory.py:109
 msgid ""
 "All non-final states should have at least one outgoing transition. These "
 "states have no outgoing transition: {!r}"
-msgstr "सभी गैर-अंतिम स्टेट में कम से कम एक आउटगोइंग ट्रांज़िशन होना चाहिए। इन स्टेट में कोई आउटगोइंग ट्रांज़िशन नहीं है: {!r}"
+msgstr ""
+"सभी गैर-अंतिम स्टेट में कम से कम एक आउटगोइंग ट्रांज़िशन होना चाहिए। इन "
+"स्टेट में कोई आउटगोइंग ट्रांज़िशन नहीं है: {!r}"
 
-#: statemachine/factory.py:124
+#: statemachine/factory.py:123
 msgid ""
 "All non-final states should have at least one path to a final state. "
 "These states have no path to a final state: {!r}"
-msgstr "सभी गैर-अंतिम स्टेट में अंतिम स्टेट तक कम से कम एक पथ होना चाहिए। इन स्टेट में अंतिम स्टेट तक कोई पथ नहीं है: {!r}"
+msgstr ""
+"सभी गैर-अंतिम स्टेट में अंतिम स्टेट तक कम से कम एक पथ होना चाहिए। इन "
+"स्टेट में अंतिम स्टेट तक कोई पथ नहीं है: {!r}"
 
-#: statemachine/factory.py:148
+#: statemachine/factory.py:147
 msgid ""
 "There are unreachable states. The statemachine graph should have a single"
 " component. Disconnected states: {}"
-msgstr "कुछ स्टेट पहुंच योग्य नहीं हैं। स्टेटमशीन ग्राफ में एक ही घटक होना चाहिए। डिस्कनेक्टेड स्टेट: {}"
+msgstr ""
+"कुछ स्टेट पहुंच योग्य नहीं हैं। स्टेटमशीन ग्राफ में एक ही घटक होना चाहिए।"
+" डिस्कनेक्टेड स्टेट: {}"
 
-#: statemachine/factory.py:257
+#: statemachine/factory.py:253
 msgid "An event in the '{}' has no id."
 msgstr "'{}' में एक इवेंट का आईडी नहीं है।"
 
-#: statemachine/mixins.py:26
+#: statemachine/mixins.py:28
 msgid "{!r} is not a valid state machine name."
 msgstr "{!r} एक मान्य स्टेटमशीन नाम नहीं है।"
 
-#: statemachine/state.py:155
+#: statemachine/state.py:194
 msgid "State overriding is not allowed. Trying to add '{}' to {}"
-msgstr "स्टेट ओवरराइड करना अनुमति नहीं है। '{}' को {} में जोड़ने की कोशिश कर रहे हैं"
+msgstr ""
+"स्टेट ओवरराइड करना अनुमति नहीं है। '{}' को {} में जोड़ने की कोशिश कर रहे "
+"हैं"
 
-#: statemachine/statemachine.py:94
+#: statemachine/statemachine.py:89
 msgid "There are no states or transitions."
 msgstr "कोई स्टेट या ट्रांज़िशन नहीं हैं।"
 
-#: statemachine/statemachine.py:285
+#: statemachine/statemachine.py:277
 msgid ""
 "There's no current state set. In async code, did you activate the initial"
 " state? (e.g., `await sm.activate_initial_state()`)"
-msgstr "कोई वर्तमान स्टेट सेट नहीं है। असिंक्रोनस कोड में, क्या आपने प्रारंभिक स्टेट को सक्रिय किया? (उदाहरण: `await sm.activate_initial_state()`)"
+msgstr ""
+"कोई वर्तमान स्टेट सेट नहीं है। असिंक्रोनस कोड में, क्या आपने प्रारंभिक "
+"स्टेट को सक्रिय किया? (उदाहरण: `await sm.activate_initial_state()`)"
+
+#: statemachine/transition_mixin.py:15
+msgid "{} only supports the decorator syntax to register callbacks."
+msgstr "{} केवल कॉलबैक रजिस्टर करने के लिए डेकोरेटर सिंटैक्स का समर्थन करता है।"
 
-#: statemachine/engines/async_.py:22
+#: statemachine/engines/async_.py:18
 msgid "Only RTC is supported on async engine"
 msgstr "असिंक्रोनस इंजन पर केवल RTC समर्थित है"

statemachine/locale/pt_BR/LC_MESSAGES/statemachine.po

@@ -5,22 +5,32 @@ msgid ""
 msgstr ""
 "Project-Id-Version:  2.4.0\n"
 "Report-Msgid-Bugs-To: fgmacedo@gmail.com\n"
-"POT-Creation-Date: 2023-03-04 16:10-0300\n"
+"POT-Creation-Date: 2026-02-13 18:28-0300\n"
 "PO-Revision-Date: 2024-06-07 17:41-0300\n"
 "Last-Translator: Fernando Macedo <fgmacedo@gmail.com>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: pt_BR\n"
+"Language-Team: pt_BR <LL@li.org>\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel 2.14.0\n"
+"Generated-By: Babel 2.16.0\n"
 
-#: statemachine/callbacks.py:165
+#: statemachine/callbacks.py:349 statemachine/callbacks.py:354
+msgid "Did not found name '{}' from model or statemachine"
+msgstr "Nome '{}' não encontrado no modelo ou na máquina de estados"
+
+#: statemachine/dispatcher.py:126
 msgid "Failed to parse boolean expression '{}'"
 msgstr "Falha ao interpretar a expressão booleana '{}'"
 
-#: statemachine/callbacks.py:407 statemachine/callbacks.py:412
-msgid "Did not found name '{}' from model or statemachine"
-msgstr "Nome '{}' não encontrado no modelo ou na máquina de estados"
+#: statemachine/event.py:90
+msgid "Cannot add callback '{}' to an event with no transitions."
+msgstr "Não é possível adicionar callback '{}' a um evento sem transições."
+
+#: statemachine/event.py:123
+msgid "Event {} cannot be called without a SM instance"
+msgstr "O evento {} não pode ser chamado sem uma instância de SM"
 
 #: statemachine/exceptions.py:24
 msgid "{!r} is not a valid state value."
@@ -30,64 +40,81 @@ msgstr "{!r} não é um valor de estado válido."
 msgid "Can't {} when in {}."
 msgstr "Não é possível {} quando em {}."
 
-#: statemachine/factory.py:74
+#: statemachine/factory.py:73
 msgid "There are no states."
 msgstr "Não há estados."
 
-#: statemachine/factory.py:77
+#: statemachine/factory.py:76
 msgid "There are no events."
 msgstr "Não há eventos."
 
-#: statemachine/factory.py:89
+#: statemachine/factory.py:88
 msgid ""
 "There should be one and only one initial state. You currently have these:"
 " {!r}"
-msgstr "Deve haver um e apenas um estado inicial. Atualmente, você possui estes: {!r}"
+msgstr ""
+"Deve haver um e apenas um estado inicial. Atualmente, você possui estes: "
+"{!r}"
 
-#: statemachine/factory.py:102
+#: statemachine/factory.py:101
 msgid "Cannot declare transitions from final state. Invalid state(s): {}"
-msgstr "Não é possível declarar transições a partir de um estado final. Estado(s) inválido(s): {}"
+msgstr ""
+"Não é possível declarar transições a partir de um estado final. Estado(s)"
+" inválido(s): {}"
 
-#: statemachine/factory.py:110
+#: statemachine/factory.py:109
 msgid ""
 "All non-final states should have at least one outgoing transition. These "
 "states have no outgoing transition: {!r}"
-msgstr "Todos os estados não finais devem ter pelo menos uma transição de saída. Estes estados não possuem transição de saída: {!r}"
+msgstr ""
+"Todos os estados não finais devem ter pelo menos uma transição de saída. "
+"Estes estados não possuem transição de saída: {!r}"
 
-#: statemachine/factory.py:124
+#: statemachine/factory.py:123
 msgid ""
 "All non-final states should have at least one path to a final state. "
 "These states have no path to a final state: {!r}"
-msgstr "Todos os estados não finais devem ter pelo menos um caminho para um estado final. Estes estados não possuem caminho para um estado final: {!r}"
+msgstr ""
+"Todos os estados não finais devem ter pelo menos um caminho para um "
+"estado final. Estes estados não possuem caminho para um estado final: "
+"{!r}"
 
-#: statemachine/factory.py:148
+#: statemachine/factory.py:147
 msgid ""
 "There are unreachable states. The statemachine graph should have a single"
 " component. Disconnected states: {}"
-msgstr "Há estados inacessíveis. O grafo da máquina de estados deve ter um único componente. Estados desconectados: {}"
+msgstr ""
+"Há estados inacessíveis. O grafo da máquina de estados deve ter um único "
+"componente. Estados desconectados: {}"
 
-#: statemachine/factory.py:257
+#: statemachine/factory.py:253
 msgid "An event in the '{}' has no id."
 msgstr "Um evento em '{}' não possui id."
 
-#: statemachine/mixins.py:26
+#: statemachine/mixins.py:28
 msgid "{!r} is not a valid state machine name."
 msgstr "{!r} não é um nome de máquina de estados válido."
 
-#: statemachine/state.py:155
+#: statemachine/state.py:194
 msgid "State overriding is not allowed. Trying to add '{}' to {}"
 msgstr "Sobrescrever estados não é permitido. Tentando adicionar '{}' a {}"
 
-#: statemachine/statemachine.py:94
+#: statemachine/statemachine.py:89
 msgid "There are no states or transitions."
 msgstr "Não há estados ou transições."
 
-#: statemachine/statemachine.py:285
+#: statemachine/statemachine.py:277
 msgid ""
 "There's no current state set. In async code, did you activate the initial"
 " state? (e.g., `await sm.activate_initial_state()`)"
-msgstr "Nenhum estado atual definido. Em código assíncrono, você ativou o estado inicial? (ex.: `await sm.activate_initial_state()`)"
+msgstr ""
+"Nenhum estado atual definido. Em código assíncrono, você ativou o estado "
+"inicial? (ex.: `await sm.activate_initial_state()`)"
+
+#: statemachine/transition_mixin.py:15
+msgid "{} only supports the decorator syntax to register callbacks."
+msgstr "{} suporta apenas a sintaxe de decorator para registrar callbacks."
 
-#: statemachine/engines/async_.py:22
+#: statemachine/engines/async_.py:18
 msgid "Only RTC is supported on async engine"
 msgstr "Apenas RTC é suportado no motor assíncrono"

statemachine/locale/zh_CN/LC_MESSAGES/statemachine.po

@@ -5,22 +5,32 @@ msgid ""
 msgstr ""
 "Project-Id-Version:  2.4.0\n"
 "Report-Msgid-Bugs-To: fgmacedo@gmail.com\n"
-"POT-Creation-Date: 2023-03-04 16:10-0300\n"
+"POT-Creation-Date: 2026-02-13 18:28-0300\n"
 "PO-Revision-Date: 2024-06-07 17:41-0300\n"
 "Last-Translator: Fernando Macedo <fgmacedo@gmail.com>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel 2.14.0\n"
+"Generated-By: Babel 2.16.0\n"
 
-#: statemachine/callbacks.py:165
+#: statemachine/callbacks.py:349 statemachine/callbacks.py:354
+msgid "Did not found name '{}' from model or statemachine"
+msgstr "在模型或状态机中未找到名称 '{}'"
+
+#: statemachine/dispatcher.py:126
 msgid "Failed to parse boolean expression '{}'"
 msgstr "无法解析布尔表达式 '{}'"
 
-#: statemachine/callbacks.py:407 statemachine/callbacks.py:412
-msgid "Did not found name '{}' from model or statemachine"
-msgstr "在模型或状态机中未找到名称 '{}'"
+#: statemachine/event.py:90
+msgid "Cannot add callback '{}' to an event with no transitions."
+msgstr "无法将回调 '{}' 添加到没有转换的事件。"
+
+#: statemachine/event.py:123
+msgid "Event {} cannot be called without a SM instance"
+msgstr "事件 {} 不能在没有 SM 实例的情况下调用"
 
 #: statemachine/exceptions.py:24
 msgid "{!r} is not a valid state value."
@@ -30,64 +40,68 @@ msgstr "{!r} 不是有效的状态值。"
 msgid "Can't {} when in {}."
 msgstr "在 {} 时无法 {}。"
 
-#: statemachine/factory.py:74
+#: statemachine/factory.py:73
 msgid "There are no states."
 msgstr "没有状态。"
 
-#: statemachine/factory.py:77
+#: statemachine/factory.py:76
 msgid "There are no events."
 msgstr "没有事件。"
 
-#: statemachine/factory.py:89
+#: statemachine/factory.py:88
 msgid ""
 "There should be one and only one initial state. You currently have these:"
 " {!r}"
 msgstr "应有且仅有一个初始状态。当前您有这些：{!r}"
 
-#: statemachine/factory.py:102
+#: statemachine/factory.py:101
 msgid "Cannot declare transitions from final state. Invalid state(s): {}"
 msgstr "无法从终止状态声明转换。无效状态：{}"
 
-#: statemachine/factory.py:110
+#: statemachine/factory.py:109
 msgid ""
 "All non-final states should have at least one outgoing transition. These "
 "states have no outgoing transition: {!r}"
 msgstr "所有非终止状态都应至少有一个外部转换。这些状态没有外部转换：{!r}"
 
-#: statemachine/factory.py:124
+#: statemachine/factory.py:123
 msgid ""
 "All non-final states should have at least one path to a final state. "
 "These states have no path to a final state: {!r}"
 msgstr "所有非终止状态应至少有一个到终止状态的路径。这些状态没有到终止状态的路径：{!r}"
 
-#: statemachine/factory.py:148
+#: statemachine/factory.py:147
 msgid ""
 "There are unreachable states. The statemachine graph should have a single"
 " component. Disconnected states: {}"
 msgstr "存在不可到达的状态。状态机图应具有单个组件。断开的状态：{}"
 
-#: statemachine/factory.py:257
+#: statemachine/factory.py:253
 msgid "An event in the '{}' has no id."
 msgstr "'{}' 中的事件没有 ID。"
 
-#: statemachine/mixins.py:26
+#: statemachine/mixins.py:28
 msgid "{!r} is not a valid state machine name."
 msgstr "{!r} 不是有效的状态机名称。"
 
-#: statemachine/state.py:155
+#: statemachine/state.py:194
 msgid "State overriding is not allowed. Trying to add '{}' to {}"
 msgstr "不允许覆盖状态。尝试将 '{}' 添加到 {}"
 
-#: statemachine/statemachine.py:94
+#: statemachine/statemachine.py:89
 msgid "There are no states or transitions."
 msgstr "没有状态或转换。"
 
-#: statemachine/statemachine.py:285
+#: statemachine/statemachine.py:277
 msgid ""
 "There's no current state set. In async code, did you activate the initial"
 " state? (e.g., `await sm.activate_initial_state()`)"
 msgstr "没有设置当前状态。在异步代码中，您是否激活了初始状态？（例如，`await sm.activate_initial_state()`）"
 
-#: statemachine/engines/async_.py:22
+#: statemachine/transition_mixin.py:15
+msgid "{} only supports the decorator syntax to register callbacks."
+msgstr "{} 仅支持使用装饰器语法注册回调。"
+
+#: statemachine/engines/async_.py:18
 msgid "Only RTC is supported on async engine"
 msgstr "异步引擎仅支持 RTC"

statemachine/mixins.py

@@ -22,6 +22,8 @@ class MachineMixin:
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if not self.state_machine_name:
+            if self._is_django_historical_model():
+                return
             raise ValueError(
                 _("{!r} is not a valid state machine name.").format(self.state_machine_name)
             )
@@ -34,3 +36,12 @@ class MachineMixin:
         )
         if self.bind_events_as_methods:
             sm.bind_events_to(self)
+
+    @classmethod
+    def _is_django_historical_model(cls) -> bool:
+        """Detect Django historical models created by ``apps.get_model()`` in migrations.
+
+        Django sets ``__module__ = '__fake__'`` on these dynamically-created classes,
+        which lack the user-defined class attributes like ``state_machine_name``.
+        """
+        return getattr(cls, "__module__", None) == "__fake__"

statemachine/signature.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from functools import partial
 from inspect import BoundArguments
 from inspect import Parameter
@@ -6,6 +8,12 @@ from inspect import iscoroutinefunction
 from itertools import chain
 from types import MethodType
 from typing import Any
+from typing import FrozenSet
+from typing import Optional
+from typing import Tuple
+
+BindCacheKey = Tuple[int, FrozenSet[str]]
+BindTemplate = Tuple[Tuple[str, ...], Optional[str], Optional[str]]  # noqa: UP007
 
 
 def _make_key(method):
@@ -44,6 +52,11 @@ def signature_cache(user_function):
 
 class SignatureAdapter(Signature):
     is_coroutine: bool = False
+    _bind_cache: dict[BindCacheKey, BindTemplate]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._bind_cache = {}
 
     @classmethod
     @signature_cache
@@ -60,19 +73,71 @@ class SignatureAdapter(Signature):
         adapter.is_coroutine = iscoroutinefunction(method)
         return adapter
 
-    def bind_expected(self, *args: Any, **kwargs: Any) -> BoundArguments:  # noqa: C901
+    def bind_expected(self, *args: Any, **kwargs: Any) -> BoundArguments:
+        cache_key: BindCacheKey = (len(args), frozenset(kwargs.keys()))
+        template = self._bind_cache.get(cache_key)
+
+        if template is not None:
+            return self._fast_bind(args, kwargs, template)
+
+        result = self._full_bind(cache_key, *args, **kwargs)
+        return result
+
+    def _fast_bind(
+        self,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        template: BindTemplate,
+    ) -> BoundArguments:
+        param_names, kwargs_param_name, var_positional_name = template
+        arguments: dict[str, Any] = {}
+        past_var_positional = False
+
+        for i, name in enumerate(param_names):
+            if name == var_positional_name:
+                # Collect all remaining positional args into a tuple
+                arguments[name] = args[i:]
+                past_var_positional = True
+            elif past_var_positional:
+                # After *args, remaining params are keyword-only
+                arguments[name] = kwargs.get(name)
+            elif i < len(args):
+                # Match _full_bind: if param is also in kwargs, kwargs wins
+                # (POSITIONAL_OR_KEYWORD params prefer kwargs over positional args)
+                if name in kwargs:
+                    arguments[name] = kwargs[name]
+                else:
+                    arguments[name] = args[i]
+            else:
+                arguments[name] = kwargs.get(name)
+
+        if kwargs_param_name is not None:
+            matched = set(param_names)
+            arguments[kwargs_param_name] = {k: v for k, v in kwargs.items() if k not in matched}
+
+        return BoundArguments(self, arguments)  # type: ignore[arg-type]
+
+    def _full_bind(  # noqa: C901
+        self,
+        cache_key: BindCacheKey,
+        *args: Any,
+        **kwargs: Any,
+    ) -> BoundArguments:
         """Get a BoundArguments object, that maps the passed `args`
         and `kwargs` to the function's signature.  It avoids to raise `TypeError`
         trying to fill all the required arguments and ignoring the unknown ones.
 
         Adapted from the internal `inspect.Signature._bind`.
         """
-        arguments = {}
+        arguments: dict[str, Any] = {}
+        param_names_used: list[str] = []
 
         parameters = iter(self.parameters.values())
         arg_vals = iter(args)
         parameters_ex: Any = ()
         kwargs_param = None
+        kwargs_param_name: str | None = None
+        var_positional_name: str | None = None
 
         while True:
             # Let's iterate through the positional arguments and corresponding
@@ -95,8 +160,7 @@ class SignatureAdapter(Signature):
                     elif param.name in kwargs:
                         if param.kind == Parameter.POSITIONAL_ONLY:
                             msg = (
-                                "{arg!r} parameter is positional only, "
-                                "but was passed as a keyword"
+                                "{arg!r} parameter is positional only, but was passed as a keyword"
                             )
                             msg = msg.format(arg=param.name)
                             raise TypeError(msg) from None
@@ -141,12 +205,15 @@ class SignatureAdapter(Signature):
                         values = [arg_val]
                         values.extend(arg_vals)
                         arguments[param.name] = tuple(values)
+                        param_names_used.append(param.name)
+                        var_positional_name = param.name
                         break
 
                     if param.name in kwargs and param.kind != Parameter.POSITIONAL_ONLY:
                         arguments[param.name] = kwargs.pop(param.name)
                     else:
                         arguments[param.name] = arg_val
+                    param_names_used.append(param.name)
 
         # Now, we iterate through the remaining parameters to process
         # keyword arguments
@@ -172,14 +239,19 @@ class SignatureAdapter(Signature):
                 # arguments.
                 pass
             else:
-                arguments[param_name] = arg_val  #
+                arguments[param_name] = arg_val
+                param_names_used.append(param_name)
 
         if kwargs:
             if kwargs_param is not None:
                 # Process our '**kwargs'-like parameter
-                arguments[kwargs_param.name] = kwargs  # type: ignore [assignment]
+                arguments[kwargs_param.name] = kwargs  # type: ignore[assignment]
+                kwargs_param_name = kwargs_param.name
             else:
                 # 'ignoring we got an unexpected keyword argument'
                 pass
 
-        return BoundArguments(self, arguments)  # type: ignore [arg-type]
+        template: BindTemplate = (tuple(param_names_used), kwargs_param_name, var_positional_name)
+        self._bind_cache[cache_key] = template
+
+        return BoundArguments(self, arguments)  # type: ignore[arg-type]

statemachine/spec_parser.py

@@ -2,6 +2,7 @@ import ast
 import operator
 import re
 from functools import reduce
+from inspect import isawaitable
 from typing import Callable
 
 replacements = {"!": "not ", "^": " and ", "v": " or "}
@@ -33,8 +34,15 @@ def replace_operators(expr: str) -> str:
 
 
 def custom_not(predicate: Callable) -> Callable:
-    def decorated(*args, **kwargs) -> bool:
-        return not predicate(*args, **kwargs)
+    def decorated(*args, **kwargs):
+        result = predicate(*args, **kwargs)
+        if isawaitable(result):
+
+            async def _negate():
+                return not await result
+
+            return _negate()
+        return not result
 
     decorated.__name__ = f"not({predicate.__name__})"
     unique_key = getattr(predicate, "unique_key", "")
@@ -43,8 +51,26 @@ def custom_not(predicate: Callable) -> Callable:
 
 
 def custom_and(left: Callable, right: Callable) -> Callable:
-    def decorated(*args, **kwargs) -> bool:
-        return left(*args, **kwargs) and right(*args, **kwargs)  # type: ignore[no-any-return]
+    def decorated(*args, **kwargs):
+        left_result = left(*args, **kwargs)
+        if isawaitable(left_result):
+
+            async def _async_and():
+                lr = await left_result
+                if not lr:
+                    return lr
+                rr = right(*args, **kwargs)
+                if isawaitable(rr):
+                    return await rr
+                return rr
+
+            return _async_and()
+        if not left_result:
+            return left_result
+        right_result = right(*args, **kwargs)
+        if isawaitable(right_result):
+            return right_result
+        return right_result
 
     decorated.__name__ = f"({left.__name__} and {right.__name__})"
     decorated.unique_key = _unique_key(left, right, "and")  # type: ignore[attr-defined]
@@ -52,8 +78,26 @@ def custom_and(left: Callable, right: Callable) -> Callable:
 
 
 def custom_or(left: Callable, right: Callable) -> Callable:
-    def decorated(*args, **kwargs) -> bool:
-        return left(*args, **kwargs) or right(*args, **kwargs)  # type: ignore[no-any-return]
+    def decorated(*args, **kwargs):
+        left_result = left(*args, **kwargs)
+        if isawaitable(left_result):
+
+            async def _async_or():
+                lr = await left_result
+                if lr:
+                    return lr
+                rr = right(*args, **kwargs)
+                if isawaitable(rr):
+                    return await rr
+                return rr
+
+            return _async_or()
+        if left_result:
+            return left_result
+        right_result = right(*args, **kwargs)
+        if isawaitable(right_result):
+            return right_result
+        return right_result
 
     decorated.__name__ = f"({left.__name__} or {right.__name__})"
     decorated.unique_key = _unique_key(left, right, "or")  # type: ignore[attr-defined]
@@ -73,8 +117,18 @@ def build_custom_operator(operator) -> Callable:
     operator_repr = comparison_repr[operator]
 
     def custom_comparator(left: Callable, right: Callable) -> Callable:
-        def decorated(*args, **kwargs) -> bool:
-            return bool(operator(left(*args, **kwargs), right(*args, **kwargs)))
+        def decorated(*args, **kwargs):
+            left_result = left(*args, **kwargs)
+            right_result = right(*args, **kwargs)
+            if isawaitable(left_result) or isawaitable(right_result):
+
+                async def _async_compare():
+                    lr = (await left_result) if isawaitable(left_result) else left_result
+                    rr = (await right_result) if isawaitable(right_result) else right_result
+                    return bool(operator(lr, rr))
+
+                return _async_compare()
+            return bool(operator(left_result, right_result))
 
         decorated.__name__ = f"({left.__name__} {operator_repr} {right.__name__})"
         decorated.unique_key = _unique_key(left, right, operator_repr)  # type: ignore[attr-defined]

statemachine/statemachine.py

@@ -75,7 +75,7 @@ class StateMachine(metaclass=StateMachineMetaclass):
         allow_event_without_transition: bool = False,
         listeners: "List[object] | None" = None,
     ):
-        self.model = model if model else Model()
+        self.model = model if model is not None else Model()
         self.state_field = state_field
         self.start_value = start_value
         self.allow_event_without_transition = allow_event_without_transition
@@ -147,6 +147,7 @@ class StateMachine(metaclass=StateMachineMetaclass):
         self._register_callbacks([])
         self.add_listener(*listeners.keys())
         self._engine = self._get_engine(rtc)
+        self._engine.start()
 
     def _get_initial_state(self):
         initial_state_value = self.start_value if self.start_value else self.initial_state.value
@@ -182,7 +183,7 @@ class StateMachine(metaclass=StateMachineMetaclass):
         return self
 
     def _register_callbacks(self, listeners: List[object]):
-        self._listeners.update({listener: None for listener in listeners})
+        self._listeners.update(dict.fromkeys(listeners))
         self._add_listener(
             Listeners.from_listeners(
                 (
@@ -223,7 +224,7 @@ class StateMachine(metaclass=StateMachineMetaclass):
 
             :ref:`listeners`.
         """
-        self._listeners.update({o: None for o in listeners})
+        self._listeners.update(dict.fromkeys(listeners))
         return self._add_listener(
             Listeners.from_listeners(Listener.from_obj(o) for o in listeners),
             allowed_references=SPECS_SAFE,
@@ -294,6 +295,24 @@ class StateMachine(metaclass=StateMachineMetaclass):
         """List of the current allowed events."""
         return [getattr(self, event) for event in self.current_state.transitions.unique_events]
 
+    def enabled_events(self, *args, **kwargs):
+        """List of the current enabled events, considering guard conditions.
+
+        An event is **enabled** if at least one of its transitions from the current
+        state has all ``cond``/``unless`` guards satisfied.
+
+        Args:
+            *args: Positional arguments forwarded to condition callbacks.
+            **kwargs: Keyword arguments forwarded to condition callbacks.
+
+        Returns:
+            A list of enabled :ref:`Event` instances.
+        """
+        result = self._engine.enabled_events(*args, **kwargs)
+        if not isawaitable(result):
+            return result
+        return run_async_from_sync(result)
+
     def _put_nonblocking(self, trigger_data: TriggerData):
         """Put the trigger on the queue without blocking the caller."""
         self._engine.put(trigger_data)

statemachine/transition_mixin.py

@@ -1,14 +1,21 @@
 from typing import Callable
 
 from .callbacks import CallbackGroup
+from .i18n import _
 
 
 class AddCallbacksMixin:
     def _add_callback(self, callback, grouper: CallbackGroup, is_event=False, **kwargs):
         raise NotImplementedError
 
-    def __call__(self, f):
-        return self._add_callback(f, CallbackGroup.ON, is_event=True)
+    def __call__(self, *args, **kwargs):
+        if len(args) == 1 and callable(args[0]) and not kwargs:
+            return self._add_callback(args[0], CallbackGroup.ON, is_event=True)
+        raise TypeError(
+            _("{} only supports the decorator syntax to register callbacks.").format(
+                type(self).__name__
+            )
+        )
 
     def before(self, f: Callable):
         """Adds a ``before`` :ref:`transition actions` callback to every :ref:`transition` in the