test: Nested states with general syntax

Author: fgmacedo

statemachine/factory.py

@@ -68,9 +68,8 @@ def _check(cls):
         if not cls.states:
             raise InvalidDefinition(_("There are no states."))
 
-        # TODO: Validate no events if has nested states
-        # if not cls._events:
-        #     raise InvalidDefinition(_("There are no events."))
+        if not cls._events:
+            raise InvalidDefinition(_("There are no events."))
 
         cls._check_disconnected_state()
 
@@ -117,8 +116,9 @@ def _add_unbounded_callback(cls, attr_name, func):
 
     def add_state(cls, id, state):
         state._set_id(id)
-        cls.states.append(state)
-        cls.states_map[state.value] = state
+        if not state.parent:
+            cls.states.append(state)
+            cls.states_map[state.value] = state
 
         # also register all events associated directly with transitions
         for event in state.transitions.unique_events:

statemachine/state.py

@@ -1,4 +1,5 @@
-from typing import Any, Optional  # noqa: F401, I001
+from typing import Any
+from typing import TypeAlias
 from copy import deepcopy
 
 from .callbacks import Callbacks
@@ -9,19 +10,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):
@@ -102,37 +106,37 @@ class State:
 
     """
 
-    Builder = NestedStateBuilder
+    Builder: TypeAlias = NestedStateBuilder
 
     def __init__(
         self,
-        name,
-        value=None,
-        initial=False,
-        final=False,
-        parallel=False,
-        substates=None,
-        enter=None,
-        exit=None,
+        name: str = "",
+        value: Any = None,
+        initial: bool = False,
+        final: bool = False,
+        parallel: bool = False,
+        substates: Any = None,
+        enter: Any = None,
+        exit: Any = None,
     ):
-        # type: (str, Optional[Any], bool, bool, bool, Optional[Any], Optional[Any], Optional[Any]) -> None  # noqa
         self.name = name
         self.value = value
         self.parallel = parallel
-        self.parent: "State" = None
         self.substates = substates or []
-        self._id = None  # type: Optional[str]
-        self._storage = ""
         self._initial = initial
-        self.transitions = TransitionList()
         self._final = final
+        self._id: str = ""
+        self._storage: str = ""
+        self.parent: "State" = None
+        self.transitions = TransitionList()
         self.enter = Callbacks().add(enter)
         self.exit = Callbacks().add(exit)
         self._init_substates()
 
     def _init_substates(self):
         for substate in self.substates:
             substate.parent = self
+            setattr(self, substate.id, substate)
 
     def __eq__(self, other):
         return (
@@ -190,6 +194,8 @@ def _set_id(self, id):
         self._storage = f"_{id}"
         if self.value is None:
             self.value = id
+        if not self.name:
+            self.name = self._id.replace("_", " ").capitalize()
 
     def _to_(self, *states, **kwargs):
         transitions = TransitionList(

statemachine/transition_list.py

@@ -1,5 +1,3 @@
-from collections import OrderedDict
-
 from .utils import ensure_iterable
 
 
@@ -67,10 +65,9 @@ def add_event(self, event):
 
     @property
     def unique_events(self):
-        # Compat Python2.7: Using OrderedDict to get a unique ordered list
-        tmp_list = OrderedDict()
+        tmp_ordered_unique_events_as_keys_on_dict = {}
         for transition in self.transitions:
             for event in transition.events:
-                tmp_list[event] = True
+                tmp_ordered_unique_events_as_keys_on_dict[event] = True
 
-        return list(tmp_list.keys())
+        return list(tmp_ordered_unique_events_as_keys_on_dict.keys())

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"]