python-statemachine 2.3.6__py3-none-any.whl → 2.4.0__py3-none-any.whl

{python_statemachine-2.3.6.dist-info → python_statemachine-2.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-statemachine
-Version: 2.3.6
+Version: 2.4.0
 Summary: Python Finite State Machines made easy.
 Home-page: https://github.com/fgmacedo/python-statemachine
 License: MIT
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Provides-Extra: diagrams
-Requires-Dist: pydot (>=2.0.0) ; extra == "diagrams"
+Requires-Dist: pydot (>=2.0.0) ; (python_full_version > "3.8.0") and (extra == "diagrams")
 Description-Content-Type: text/markdown
 
 # Python StateMachine
@@ -405,7 +405,7 @@ There's a lot more to cover, please take a look at our docs:
 https://python-statemachine.readthedocs.io.
 
 
-## Contributing to the project
+## Contributing
 
 * <a class="github-button" href="https://github.com/fgmacedo/python-statemachine" data-icon="octicon-star" aria-label="Star fgmacedo/python-statemachine on GitHub">Star this project</a>
 * <a class="github-button" href="https://github.com/fgmacedo/python-statemachine/issues" data-icon="octicon-issue-opened" aria-label="Issue fgmacedo/python-statemachine on GitHub">Open an Issue</a>
@@ -413,18 +413,18 @@ https://python-statemachine.readthedocs.io.
 
 - If you found this project helpful, please consider giving it a star on GitHub.
 
-- **Contribute code**: If you would like to contribute code to this project, please submit a pull
+- **Contribute code**: If you would like to contribute code, please submit a pull
 request. For more information on how to contribute, please see our [contributing.md](contributing.md) file.
 
-- **Report bugs**: If you find any bugs in this project, please report them by opening an issue
+- **Report bugs**: If you find any bugs, please report them by opening an issue
   on our GitHub issue tracker.
 
-- **Suggest features**: If you have a great idea for a new feature, please let us know by opening
-  an issue on our GitHub issue tracker.
+- **Suggest features**: If you have an idea for a new feature, of feels something being harder than it should be,
+  please let us know by opening an issue on our GitHub issue tracker.
 
-- **Documentation**: Help improve this project's documentation by submitting pull requests.
+- **Documentation**: Help improve documentation by submitting pull requests.
 
-- **Promote the project**: Help spread the word about this project by sharing it on social media,
+- **Promote the project**: Help spread the word by sharing on social media,
   writing a blog post, or giving a talk about it. Tag me on Twitter
   [@fgmacedo](https://twitter.com/fgmacedo) so I can share it too!
 

python_statemachine-2.4.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+statemachine/__init__.py,sha256=NLqMYmezhWHlgs3OJHd_zmKBsVEQAA3jhLIHAf4bFGM,226
+statemachine/callbacks.py,sha256=5Onm2HxhSfFiilL_1PCUxIsLdcmEOQD80CArurIx9rs,12974
+statemachine/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/contrib/diagram.py,sha256=1z0d_Ln0k4-jLaEYry8si5pK25lsViyPWMT7KkDeDSc,7131
+statemachine/dispatcher.py,sha256=4ewPGs-nOVSPMrDMhcuwkkc0c_AqLyw2Pv495bpfjXU,5407
+statemachine/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+statemachine/engines/async_.py,sha256=deZ5oYeoIYX9zOsFEOCT4KXsz5V1F9fbaMDOBATnTkE,5572
+statemachine/engines/sync.py,sha256=cGy23Ivx0Ul4NWSix8E8PNA1Ji4V9qvOd3K_yodD_UI,5523
+statemachine/event.py,sha256=ZyU6YmoLlKndBSohcmMp6v0tGSY2RG711JtJZJ6JXGY,3861
+statemachine/event_data.py,sha256=H9lp_XnvHSK9YErUOCvMK3ZBjWhC-xDSOJ2gZxtmrq8,2261
+statemachine/events.py,sha256=QVx1SsoPMwDI6J5mcuk8SoqMDIrPvZgQLOx4m_MNghI,1031
+statemachine/exceptions.py,sha256=vHVQPTTMMkVvySNbN6XZPciBryvpY608LDe3MCnmxFU,1124
+statemachine/factory.py,sha256=hVCLJIITv5ccXVPpg5H5B7_tfGZMqk7zSALTCAiXiWk,9318
+statemachine/graph.py,sha256=KtwB1CYckaLjTgQD9tEeuaEzJje9q3fPVpBViW5TgSk,487
+statemachine/i18n.py,sha256=NLvGseaORmQ0G-V_J8tkjoxh_piWMOm2CI6mBQpLamc,362
+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
+statemachine/mixins.py,sha256=Y1fa52Cj20JaGkyNk3P7Gpqkt4cGTjJ0YyV_VQyCl0M,1231
+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=HwuyWX3p_GZwKKrGbt9wk4-bHpymqs_pgqW7OlDgGRc,7877
+statemachine/spec_parser.py,sha256=Mqi9VMnlwJqEAcDnO-RMNv8kq-VKkHEqMgS_aeldcOI,3020
+statemachine/state.py,sha256=DlFAuQb8HN6pKOyaRgLvYRHJZCFYo2LFLbikGzbE9Jw,8526
+statemachine/statemachine.py,sha256=02qe_x2IAcLameakllXPviQ2pkAs9x9QA_ws-po-hWg,11372
+statemachine/states.py,sha256=pPROZwIyE3_tlBGL3DJXnM3gr1pWsWICEMMo2c742RY,4889
+statemachine/transition.py,sha256=4_dq2rR4x2at4d3B-3zuaP5mTa68P89DpFO2moPTTPM,4657
+statemachine/transition_list.py,sha256=4xxMaD265GuSCXA8gzeEF06lh-eRO0O_X4YgsRZYWVA,6120
+statemachine/utils.py,sha256=DpcrGqlbrnT-ogh-BogG0L07EG3KirHOsKORHlspDlI,1041
+python_statemachine-2.4.0.dist-info/LICENSE,sha256=zcP7TsJMqaFxuTvLRZPT7nJl3_ppjxR9Z76BE9pL5zc,1074
+python_statemachine-2.4.0.dist-info/METADATA,sha256=qZJym13d9zQll_snjRZ53kl982Mcf0NTVxfq7P0OOT8,14036
+python_statemachine-2.4.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+python_statemachine-2.4.0.dist-info/RECORD,,

statemachine/__init__.py

@@ -1,8 +1,9 @@
+from .event import Event
 from .state import State
 from .statemachine import StateMachine
 
 __author__ = """Fernando Macedo"""
 __email__ = "fgmacedo@gmail.com"
-__version__ = "2.3.6"
+__version__ = "2.4.0"
 
-__all__ = ["StateMachine", "State"]
+__all__ = ["StateMachine", "State", "Event"]

statemachine/callbacks.py

@@ -5,19 +5,30 @@ from collections import deque
 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
+
 
 class CallbackPriority(IntEnum):
     GENERIC = 0
@@ -54,6 +65,17 @@ 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.
 
@@ -110,7 +132,16 @@ class CallbackSpec:
         self.reference = SpecReference.CALLABLE
         self.attr_name = attr_name
 
-    def build(self, resolver) -> Generator["CallbackWrapper", None, None]:
+    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.
 
@@ -118,14 +149,29 @@ class CallbackSpec:
             resolver (callable): A method responsible to build and return a valid callable that
                 can receive arbitrary parameters like `*args, **kwargs`.
         """
-        for callback in resolver.search(self):
-            condition = self.cond if self.cond is not None else allways_true
-            yield CallbackWrapper(
-                callback=callback,
-                condition=condition,
-                meta=self,
-                unique_key=callback.unique_key,
+        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:
@@ -292,7 +338,7 @@ class CallbacksExecutor:
     def __str__(self):
         return ", ".join(str(c) for c in self)
 
-    def _add(self, spec: CallbackSpec, resolver: Callable):
+    def _add(self, spec: CallbackSpec, resolver: "Listeners"):
         for callback in spec.build(resolver):
             if callback.unique_key in self.items_already_seen:
                 continue
@@ -300,7 +346,7 @@ class CallbacksExecutor:
             self.items_already_seen.add(callback.unique_key)
             insort(self.items, callback)
 
-    def add(self, items: Iterable[CallbackSpec], resolver: Callable):
+    def add(self, items: Iterable[CallbackSpec], resolver: "Listeners"):
         """Validate configurations"""
         for item in items:
             self._add(item, resolver)
@@ -356,6 +402,12 @@ class CallbacksRegistry:
                 callback for callback in self[meta.group.build_key(specs)] if callback.meta == meta
             ):
                 continue
+            if hasattr(meta, "names_not_found"):
+                raise AttrNotFound(
+                    _("Did not found name '{}' from model or statemachine").format(
+                        ", ".join(meta.names_not_found)
+                    ),
+                )
             raise AttrNotFound(
                 _("Did not found name '{}' from model or statemachine").format(meta.func)
             )

statemachine/contrib/diagram.py

@@ -166,10 +166,6 @@ def quickchart_write_svg(sm: StateMachine, path: str):
     >>> sm = OrderControl()
     >>> print(sm._graph().to_string())
     digraph list {
-    fontname=Arial;
-    fontsize=10;
-    label=OrderControl;
-    rankdir=LR;
     ...
 
     To give you an example, we included this method that will serialize the dot, request the graph

statemachine/dispatcher.py

@@ -10,6 +10,7 @@ from typing import Tuple
 
 from .callbacks import SPECS_ALL
 from .callbacks import SpecReference
+from .event import Event
 from .signature import SignatureAdapter
 
 if TYPE_CHECKING:
@@ -75,7 +76,7 @@ class Listeners:
 
     def search(self, spec: "CallbackSpec") -> Generator["Callable", None, None]:
         if spec.reference is SpecReference.NAME:
-            yield from self._search_name(spec.func)
+            yield from self.search_name(spec.func)
             return
         elif spec.reference is SpecReference.CALLABLE:
             yield self._search_callable(spec)
@@ -111,7 +112,7 @@ class Listeners:
 
         return callable_method(spec.attr_name, spec.func, None)
 
-    def _search_name(self, name) -> Generator["Callable", None, None]:
+    def search_name(self, name) -> Generator["Callable", None, None]:
         for config in self.items:
             if name not in config.all_attrs:
                 continue
@@ -121,7 +122,7 @@ class Listeners:
                 yield attr_method(name, config.obj, config.resolver_id)
                 continue
 
-            if getattr(func, "_is_sm_event", False):
+            if isinstance(func, Event):
                 yield event_method(name, func, config.resolver_id)
                 continue
 
@@ -143,6 +144,7 @@ def attr_method(attribute, obj, resolver_id) -> Callable:
         return getter(obj)
 
     method.unique_key = f"{attribute}@{resolver_id}"  # type: ignore[attr-defined]
+    method.__name__ = attribute
     return method
 
 

statemachine/event.py

@@ -1,5 +1,7 @@
 from inspect import isawaitable
 from typing import TYPE_CHECKING
+from typing import List
+from uuid import uuid4
 
 from statemachine.utils import run_async_from_sync
 
@@ -7,47 +9,123 @@ from .event_data import TriggerData
 
 if TYPE_CHECKING:
     from .statemachine import StateMachine
+    from .transition_list import TransitionList
 
 
-class Event:
-    def __init__(self, name: str):
-        self.name: str = name
+_event_data_kwargs = {
+    "event_data",
+    "machine",
+    "event",
+    "model",
+    "transition",
+    "state",
+    "source",
+    "target",
+}
+
+
+class Event(str):
+    """An event is triggers a signal that something has happened.
+
+    They are send 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.
+
+    See also :ref:`events`.
+    """
+
+    id: str
+    """The event identifier."""
+
+    name: str
+    """The event name."""
+
+    _sm: "StateMachine | None" = None
+    """The state machine instance."""
+
+    _transitions: "TransitionList | None" = None
+    _has_real_id = False
+
+    def __new__(
+        cls,
+        transitions: "str | TransitionList | None" = None,
+        id: "str | None" = None,
+        name: "str | None" = None,
+        _sm: "StateMachine | None" = None,
+    ):
+        if isinstance(transitions, str):
+            id = transitions
+            transitions = None
+
+        _has_real_id = id is not None
+        id = str(id) if _has_real_id else f"__event__{uuid4().hex}"
+
+        instance = super().__new__(cls, id)
+        instance.id = id
+        if name:
+            instance.name = name
+        elif _has_real_id:
+            instance.name = str(id).replace("_", " ").capitalize()
+        else:
+            instance.name = ""
+        if transitions:
+            instance._transitions = transitions
+        instance._has_real_id = _has_real_id
+        instance._sm = _sm
+        return instance
 
     def __repr__(self):
-        return f"{type(self).__name__}({self.name!r})"
+        return f"{type(self).__name__}({self.id!r})"
 
-    def trigger(self, machine: "StateMachine", *args, **kwargs):
+    def is_same_event(self, *_args, event: "str | None" = None, **_kwargs) -> bool:
+        return self == event
+
+    def __get__(self, instance, owner):
+        """By implementing this method `Event` can be used as a property descriptor
+
+        When attached to a SM class, if the user tries to get the `Event` instance,
+        we intercept here and return a `BoundEvent` instance, so the user can call
+        it as a method with the correct SM instance.
+
+        """
+        if instance is None:
+            return self
+        return BoundEvent(id=self.id, name=self.name, _sm=instance)
+
+    def __call__(self, *args, **kwargs):
+        """Send this event to the current state machine.
+
+        Triggering an event on a state machine means invoking or sending a signal, initiating the
+        process that may result in executing a transition.
+        """
+        # The `__call__` is declared here to help IDEs knowing that an `Event`
+        # can be called as a method. But it is not meant to be called without
+        # an SM instance. Such SM instance is provided by `__get__` method when
+        # used as a property descriptor.
+
+        machine = self._sm
+        kwargs = {k: v for k, v in kwargs.items() if k not in _event_data_kwargs}
         trigger_data = TriggerData(
             machine=machine,
-            event=self.name,
+            event=self,
             args=args,
             kwargs=kwargs,
         )
         machine._put_nonblocking(trigger_data)
-        return machine._processing_loop()
-
-
-def trigger_event_factory(event_instance: Event):
-    """Build a method that sends specific `event` to the machine"""
-
-    def trigger_event(self, *args, **kwargs):
-        result = event_instance.trigger(self, *args, **kwargs)
+        result = machine._processing_loop()
         if not isawaitable(result):
             return result
         return run_async_from_sync(result)
 
-    trigger_event.name = event_instance.name  # type: ignore[attr-defined]
-    trigger_event.identifier = event_instance.name  # type: ignore[attr-defined]
-    trigger_event._is_sm_event = True  # type: ignore[attr-defined]
-    return trigger_event
-
-
-def same_event_cond_builder(expected_event: str):
-    """
-    Builds a condition method that evaluates to ``True`` when the expected event is received.
-    """
+    def split(  # type: ignore[override]
+        self, sep: "str | None" = None, maxsplit: int = -1
+    ) -> List["Event"]:
+        result = super().split(sep, maxsplit)
+        if len(result) == 1:
+            return [self]
+        return [Event(event) for event in result]
 
-    def cond(*args, event: "str | None" = None, **kwargs) -> bool:
-        return event == expected_event
 
-    return cond
+class BoundEvent(Event):
+    pass

statemachine/event_data.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING
 from typing import Any
 
 if TYPE_CHECKING:
+    from .event import Event
     from .state import State
     from .statemachine import StateMachine
     from .transition import Transition
@@ -13,7 +14,7 @@ if TYPE_CHECKING:
 class TriggerData:
     machine: "StateMachine"
 
-    event: str
+    event: "Event"
     """The Event that was triggered."""
 
     model: Any = field(init=False)

statemachine/events.py

@@ -1,3 +1,5 @@
+from statemachine.event import Event
+
 from .utils import ensure_iterable
 
 
@@ -5,14 +7,14 @@ class Events:
     """A collection of event names."""
 
     def __init__(self):
-        self.items = []
+        self._items: list[Event] = []
 
     def __repr__(self):
-        sep = " " if len(self.items) > 1 else ""
-        return sep.join(item for item in self.items)
+        sep = " " if len(self._items) > 1 else ""
+        return sep.join(item for item in self._items)
 
     def __iter__(self):
-        return iter(self.items)
+        return iter(self._items)
 
     def add(self, events):
         if events is None:
@@ -21,11 +23,18 @@ class Events:
         unprepared = ensure_iterable(events)
         for events in unprepared:
             for event in events.split(" "):
-                if event in self.items:
+                if event in self._items:
                     continue
-                self.items.append(event)
+                if isinstance(event, Event):
+                    self._items.append(event)
+                else:
+                    self._items.append(Event(id=event, name=event))
 
         return self
 
     def match(self, event: str):
         return any(e == event for e in self)
+
+    def _replace(self, old, new):
+        self._items.remove(old)
+        self._items.append(new)

statemachine/exceptions.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING
 from .i18n import _
 
 if TYPE_CHECKING:
+    from .event import Event
     from .state import State
 
 
@@ -31,8 +32,8 @@ class AttrNotFound(InvalidDefinition):
 class TransitionNotAllowed(StateMachineError):
     "Raised when there's no transition that can run from the current :ref:`state`."
 
-    def __init__(self, event: str, state: "State"):
+    def __init__(self, event: "Event", state: "State"):
         self.event = event
         self.state = state
-        msg = _("Can't {} when in {}.").format(self.event, self.state.name)
+        msg = _("Can't {} when in {}.").format(self.event.name, self.state.name)
         super().__init__(msg)

statemachine/factory.py

@@ -8,7 +8,6 @@ from uuid import uuid4
 
 from . import registry
 from .event import Event
-from .event import trigger_event_factory
 from .exceptions import InvalidDefinition
 from .graph import iterate_states_and_transitions
 from .graph import visit_connected_states
@@ -38,11 +37,13 @@ class StateMachineMetaclass(type):
 
         cls._abstract = True
         cls._strict_states = strict_states
-        cls._events: Dict[str, Event] = {}
+        cls._events: Dict[Event, None] = {}  # used Dict to preserve order and avoid duplicates
         cls._protected_attrs: set = set()
+        cls._events_to_update: Dict[Event, Event | None] = {}
 
         cls.add_inherited(bases)
         cls.add_from_attributes(attrs)
+        cls._update_event_references()
 
         try:
             cls.initial_state: State = next(s for s in cls.states if s.initial)
@@ -174,17 +175,26 @@ class StateMachineMetaclass(type):
                 cls.add_state(state.id, state)
 
             events = getattr(base, "_events", {})
-            for event in events.values():
-                cls.add_event(event.name)
+            for event in events:
+                cls.add_event(event=Event(id=event.id, name=event.name))
 
-    def add_from_attributes(cls, attrs):
+    def add_from_attributes(cls, attrs):  # noqa: C901
         for key, value in sorted(attrs.items(), key=lambda pair: pair[0]):
             if isinstance(value, States):
                 cls._add_states_from_dict(value)
             if isinstance(value, State):
                 cls.add_state(key, value)
             elif isinstance(value, (Transition, TransitionList)):
-                cls.add_event(key, value)
+                cls.add_event(event=Event(transitions=value, id=key, name=key))
+            elif isinstance(value, (Event,)):
+                cls.add_event(
+                    event=Event(
+                        transitions=value._transitions,
+                        id=key,
+                        name=value.name,
+                    ),
+                    old_event=value,
+                )
             elif getattr(value, "_specs_to_update", None):
                 cls._add_unbounded_callback(key, value)
 
@@ -196,7 +206,7 @@ class StateMachineMetaclass(type):
         # if func is an event, the `attr_name` will be replaced by an event trigger,
         # so we'll also give the ``func`` a new unique name to be used by the callback
         # machinery.
-        cls.add_event(attr_name, func._transitions)
+        cls.add_event(event=Event(func._transitions, id=attr_name, name=attr_name))
         attr_name = f"_{attr_name}_{uuid4().hex}"
         setattr(cls, attr_name, func)
 
@@ -214,17 +224,42 @@ class StateMachineMetaclass(type):
         for event in state.transitions.unique_events:
             cls.add_event(event)
 
-    def add_event(cls, event, transitions=None):
+    def add_event(
+        cls,
+        event: Event,
+        old_event: "Event | None" = None,
+    ):
+        if not event._has_real_id:
+            if event not in cls._events_to_update:
+                cls._events_to_update[event] = None
+            return
+
+        transitions = event._transitions
         if transitions is not None:
             transitions.add_event(event)
 
         if event not in cls._events:
-            event_instance = Event(event)
-            cls._events[event] = event_instance
-            setattr(cls, event, trigger_event_factory(event_instance))
+            cls._events[event] = None
+            setattr(cls, event.id, event)
+
+        if old_event is not None:
+            cls._events_to_update[old_event] = event
 
         return cls._events[event]
 
+    def _update_event_references(cls):
+        for old_event, new_event in cls._events_to_update.items():
+            for state in cls.states:
+                for transition in state.transitions:
+                    if transition._events.match(old_event):
+                        if new_event is None:
+                            raise InvalidDefinition(
+                                _("An event in the '{}' has no id.").format(transition)
+                            )
+                        transition.events._replace(old_event, new_event)
+
+        cls._events_to_update = {}
+
     @property
     def events(self):
-        return list(self._events.values())
+        return list(self._events)