test: Nested states with general syntax

Author: fgmacedo

statemachine/factory.py

@@ -60,9 +60,8 @@ def _check(cls):
         if not has_states:
             raise InvalidDefinition(_("There are no states."))
 
-        # TODO: Validate no events if has nested states
-        # if not has_events:
-        #     raise InvalidDefinition(_("There are no events."))
+        if not has_events:
+            raise InvalidDefinition(_("There are no events."))
 
         cls._check_initial_state()
         cls._check_final_states()
@@ -143,10 +142,11 @@ def _add_unbounded_callback(cls, attr_name, func):
 
     def add_state(cls, id, state: State):
         state._set_id(id)
-        cls.states.append(state)
-        cls.states_map[state.value] = state
-        if not hasattr(cls, id):
-            setattr(cls, id, state)
+        if not state.parent:
+            cls.states.append(state)
+            cls.states_map[state.value] = state
+            if not hasattr(cls, id):
+                setattr(cls, id, state)
 
         # also register all events associated directly with transitions
         for event in state.transitions.unique_events:

statemachine/state.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Dict
+from typing import TypeAlias
 from weakref import ref
 
 from .callbacks import CallbackMetaList
@@ -14,19 +15,22 @@
 
 
 class NestedStateFactory(type):
-    def __new__(cls, classname, bases, attrs, name=None, initial=False, parallel=False):
+    def __new__(  # type: ignore [misc]
+        cls, classname, bases, attrs, name=None, initial=False, parallel=False
+    ) -> "State":
 
         if not bases:
-            return super().__new__(cls, classname, bases, attrs)
+            return super().__new__(cls, classname, bases, attrs)  # type: ignore [return-value]
 
         substates = []
         for key, value in attrs.items():
-            if not isinstance(value, State):
-                continue
-            value._set_id(key)
-            substates.append(value)
+            if isinstance(value, State):
+                value._set_id(key)
+                substates.append(value)
+            if isinstance(value, TransitionList):
+                value.add_event(key)
 
-        return State(name, initial=initial, parallel=parallel, substates=substates)
+        return State(name=name, initial=initial, parallel=parallel, substates=substates)
 
 
 class NestedStateBuilder(metaclass=NestedStateFactory):
@@ -112,27 +116,27 @@ class State:
 
     """
 
-    Builder = NestedStateBuilder
+    Builder: TypeAlias = NestedStateBuilder
 
     def __init__(
         self,
         name: str = "",
         value: Any = None,
         initial: bool = False,
         final: bool = False,
-        parallel=False,
-        substates=None,
+        parallel: bool = False,
+        substates: Any = None,
         enter: Any = None,
         exit: Any = None,
     ):
         self.name = name
         self.value = value
         self.parallel = parallel
-        self.parent: "State" = None
         self.substates = substates or []
         self._initial = initial
         self._final = final
         self._id: str = ""
+        self.parent: "State" = None
         self.transitions = TransitionList()
         self.enter = CallbackMetaList().add(enter)
         self.exit = CallbackMetaList().add(exit)
@@ -141,6 +145,7 @@ def __init__(
     def _init_substates(self):
         for substate in self.substates:
             substate.parent = self
+            setattr(self, substate.id, substate)
 
     def __eq__(self, other):
         return (

tests/examples/microwave_inheritance_machine.py

@@ -50,6 +50,7 @@ class on(State.Builder, name="On"):
                 cooking.to(idle, cond="open.is_active")
                 cooking.to.itself(internal=True, on="increment_timer")
 
+            assert isinstance(on, State)  # so mypy stop complaining
             turn_off = on.to(off)
             turn_on = off.to(on)
             on.to(off, cond="cook_time_is_over")  # eventless transition

tests/test_compound.py

@@ -11,8 +11,8 @@ class engine(State.Builder, name="Engine", initial=True):
             off = State("Off", initial=True)
             on = State("On")
 
-            turn_off = on.to(off)
             turn_on = off.to(on)
+            turn_off = on.to(off)
 
     return TestMachine
 
@@ -26,8 +26,8 @@ def test_capture_constructor_arguments(self, compound_engine_cls):
 
     def test_list_children_states(self, compound_engine_cls):
         sm = compound_engine_cls()
-        assert [s.id for s in sm.engine.children] == ["off", "on"]
+        assert [s.id for s in sm.engine.substates] == ["off", "on"]
 
     def test_list_events(self, compound_engine_cls):
         sm = compound_engine_cls()
-        assert [e.name for e in sm.events] == ["turn_off", "turn_on"]
+        assert [e.name for e in sm.events] == ["turn_on", "turn_off"]