override property initial to accept nested state strings and parallel state lists/tuples (#476, #455)

Author: aleneum

Changelog.md

@@ -5,6 +5,7 @@
 - Bugfix #477: Model callbacks were not added to a LockedHierarchicalMachine when the machine itself served as a model (thanks @oliver-goetz)
 - Bugfix #475: Clear collection of tasks to prevent memory leak when initializing many models (thanks @h-nakai)
 - Feature #474: Added static `AsyncMachine.protected_tasks` list which can be used to prevent `transitions` to cancel certain tasks.
+- Feature: Constructor of `HierarchicalMachine` now accepts substates ('A_1_c') and parallel states (['A', 'B']) as `initial` parameter
 
 ## 0.8.3 (September 2020)
 

tests/test_nesting.py

@@ -404,6 +404,8 @@ def test_intial_state(self):
         self.assertTrue(m.is_B(allow_substates=True))
         m.do()
         self.assertEqual(m.state, 'B{0}1'.format(separator))
+        m = self.stuff.machine_cls(states=states, transitions=transitions, initial='B{0}2{0}b'.format(separator))
+        self.assertTrue('B{0}2{0}b'.format(separator), m.state)
 
     def test_get_triggers(self):
         seperator = self.state_cls.separator

tests/test_parallel.py

@@ -121,8 +121,21 @@ def test_multiple(self):
         self.assertEqual([['B{0}1{0}a{0}z'.format(State.separator),
                            'B{0}1{0}b{0}y'.format(State.separator)],
                           'B{0}2{0}a'.format(State.separator)], m.state)
+
+        # check whether we can initialize a new machine in a parallel state
+        m2 = self.machine_cls(states=states, initial=m.state)
+        self.assertEqual([['B{0}1{0}a{0}z'.format(State.separator),
+                           'B{0}1{0}b{0}y'.format(State.separator)],
+                          'B{0}2{0}a'.format(State.separator)], m2.state)
         m.to_A()
         self.assertEqual('A', m.state)
+        m2.to_A()
+        self.assertEqual(m.state, m2.state)
+
+    def test_deep_initial(self):
+        m = self.machine_cls(initial=['A', 'B{0}2{0}a'.format(State.separator)])
+        m.to_B()
+        self.assertEqual('B', m.state)
 
     def test_multiple_deeper(self):
         sep = self.state_cls.separator

transitions/extensions/nesting.py

@@ -247,9 +247,7 @@ def _resolve_transition(self, event_data):
         else:
             new_states, enter_partials = {}, []
 
-        for key in scoped_tree:
-            del scoped_tree[key]
-
+        scoped_tree.clear()
         for new_key, value in new_states.items():
             scoped_tree[new_key] = value
             break
@@ -370,7 +368,12 @@ def add_model(self, model, initial=None):
         initial_name = getattr(models[0], self.model_attribute)
         if hasattr(initial_name, 'name'):
             initial_name = initial_name.name
-        initial_states = self._resolve_initial(models, initial_name.split(self.state_cls.separator))
+        # initial states set by add_model or machine might contain initial states themselves.
+        if isinstance(initial_name, string_types):
+            initial_states = self._resolve_initial(models, initial_name.split(self.state_cls.separator))
+        # when initial is set to a (parallel) state, we accept it as it is
+        else:
+            initial_states = initial_name
         for mod in models:
             self.set_state(initial_states, mod)
             if hasattr(mod, 'to'):
@@ -380,6 +383,15 @@ def add_model(self, model, initial=None):
                 to_func = partial(self.to_state, mod)
                 setattr(mod, 'to', to_func)
 
+    @property
+    def initial(self):
+        """ Return the initial state. """
+        return self._initial
+
+    @initial.setter
+    def initial(self, value):
+        self._initial = self._recursive_initial(value)
+
     def add_ordered_transitions(self, states=None, trigger='next_state',
                                 loop=True, loop_includes_initial=True,
                                 conditions=None, unless=None, before=None,
@@ -876,6 +888,24 @@ def _init_state(self, state):
             for substate in self.states.values():
                 self._init_state(substate)
 
+    def _recursive_initial(self, value):
+        if isinstance(value, string_types):
+            path = value.split(self.state_cls.separator, 1)
+            if len(path) > 1:
+                state_name, suffix = path
+                # make sure the passed state has been created already
+                _super(HierarchicalMachine, self.__class__).initial.fset(self, state_name)
+                with self(state_name):
+                    self.initial = suffix
+                    self._initial = state_name + self.state_cls.separator + self._initial
+            else:
+                _super(HierarchicalMachine, self.__class__).initial.fset(self, value)
+        elif isinstance(value, (list, tuple)):
+            return [self._recursive_initial(v) for v in value]
+        else:
+            _super(HierarchicalMachine, self.__class__).initial.fset(self, value)
+        return self._initial[0] if isinstance(self._initial, list) and len(self._initial) == 1 else self._initial
+
     def _resolve_initial(self, models, state_name_path, prefix=[]):
         if state_name_path:
             state_name = state_name_path.pop(0)