release 0.6.6

Author: aleneum

Changelog.md

@@ -1,17 +1,22 @@
 # Changelog
 
-## 0.6.6 ()
+## 0.6.6 (May, 2018)
 
-- `HierarchicalMachine` now considers the initial state of `NestedState` instances/names passed to `initial`.
+Release 0.6.6 is a minor release and contains several bugfixes and new features:
+
+- Bugfix: `HierarchicalMachine` now considers the initial state of `NestedState` instances/names passed to `initial`.
 - Bugfix: `HierarchicalMachine` used to ignore children when `NestedStates` were added to the machine.
-- Feature: Added `Machine.dispatch` to trigger events on all models assigned to `Machine`.
+- Bugfix #300: Fixed missing brackets in `TimeoutState` (thanks @Synss)
+- Feature #289: Introduced `Machine.resolve_callable(func, event_data)` to enable customization of callback definitions (thanks @ollamh and @paulbovbel)
+- Feature #299: Added support for internal transitions with `dest=None` (thanks @maueki)
+- Feature: Added `Machine.dispatch` to trigger events on all models assigned to `Machine`
 
 ## 0.6.5 (April, 2018)
 
 Release 0.6.5 is a minor release and contains a new feature and a bugfix:
 
 - Feature #287: Embedding `HierarchicalMachine` will now reuse the machine's `initial` state. Passing `initial: False` overrides this (thanks @mrjogo).
-- Bugfix #292: Models using `GraphMashine` were not picklable in the past due to `graph` property. Graphs for each model are now stored in `GraphMachine.model_graphs` (thanks @ansumanm)
+- Bugfix #292: Models using `GraphMashine` were not picklable in the past due to `graph` property. Graphs for each model are now stored in `GraphMachine.model_graphs` (thanks @ansumanm).
 
 ## 0.6.4 (January, 2018)
 

README.md

@@ -30,11 +30,12 @@ A lightweight, object-oriented state machine implementation in Python. Compatibl
         - [Automatic transitions](#automatic-transitions-for-all-states)
         - [Transitioning from multiple states](#transitioning-from-multiple-states)
         - [Reflexive transitions from multiple states](#reflexive-from-multiple-states)
+        - [Internal transitions](#internal-transitions)
         - [Ordered transitions](#ordered-transitions)
         - [Queued transitions](#queued-transitions)
         - [Conditional transitions](#conditional-transitions)
         - [Callbacks](#transition-callbacks)
-    - [Execution order](#execution-order)
+    - [Callback resolution and execution order](#execution-order)
     - [Passing data](#passing-data)
     - [Alternative initialization patterns](#alternative-initialization-patterns)
     - [Logging](#logging)
@@ -463,6 +464,15 @@ machine.add_transition('touch', ['liquid', 'gas', 'plasma'], '=', after='change_
 
 This will add reflexive transitions for all three states with `touch()` as trigger and with `change_shape` executed after each trigger.
 
+#### <a name="internal-transitions"></a>Internal transitions
+In contrast to reflexive transitions, internal transitions will never actually leave the state.
+This means that transition-related callbacks such as `before` or `after` will be processed while state-related callbacks `exit` or `enter` will not.
+To define a transition to be internal, set the destination to `None`.
+
+```python
+machine.add_transition('internal', ['liquid', 'gas'], None, after='change_shape')
+```
+
 #### <a name="ordered-transitions"></a> Ordered transitions
 A common desire is for state transitions to follow a strict linear sequence. For instance, given states `['A', 'B', 'C']`, you might want valid transitions for `A` → `B`, `B` → `C`, and `C` → `A` (but no other pairs).
 
@@ -675,7 +685,37 @@ print(lump.state)
 >>> initial
 ```
 
-### <a name="execution-order"> Execution order
+### <a name="execution-order"> Callback resolution and execution order
+
+As you have probably already realized, the standard way of passing callbacks to states and transitions is by name.
+When processing callbacks, Transitions will use the name to retrieve the related callback from the model.
+If the method cannot be retrieved and it contains dots, Transitions will treat the name as a path to a module function and try to import it.
+Alternatively, you can pass callables such as (bound) functions directly.
+
+```python
+from transitions import Machine
+from mod import imported_func
+
+
+class Model(object):
+
+    def a_callback(self):
+        imported_func()
+
+
+model = Model()
+machine = Machine(model=model, states=['A'], initial='A')
+machine.add_transition('by_name', 'A', 'A', after='a_callback')
+machine.add_transition('by_reference', 'A', 'A', after=model.a_callback)
+machine.add_transition('imported', 'A', 'A', after='mod.imported_func')
+
+model.by_name()
+model.by_reference()
+model.imported()
+```
+The callback resolution is done in `Machine.resolve_callbacks`.
+This method can be overridden in case more complex callback resolution strategies are required.
+
 In summary, callbacks on transitions are executed in the following order:
 
 |      Callback                  | Current State |               Comments                                      |

tests/test_graphing.py

@@ -187,6 +187,12 @@ def test_to_method_filtering(self):
         self.assertEqual(len(m2.get_graph().get_edge('B', 'A')), 2)
         self.assertEqual(m2.get_graph().get_edge('A', 'B').attr['label'], 'to_B')
 
+    def test_loops(self):
+        m = self.machine_cls(states=['A'], initial='A')
+        m.add_transition('reflexive', 'A', '=')
+        m.add_transition('fixed', 'A', None)
+        g1 = m.get_graph()
+
     def test_roi(self):
         m = self.machine_cls(states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A')
         m.add_transition('to_state_A', 'B', 'A')

transitions/core.py

@@ -259,19 +259,19 @@ def execute(self, event_data):
             machine.callback(func, event_data)
             _LOGGER.debug("%sExecuted callback '%s' before transition.", event_data.machine.name, func)
 
-        self._change_state(event_data)
+        if self.dest:  # if self.dest is None this is an internal transition with no actual state change
+            self._change_state(event_data)
 
         for func in itertools.chain(self.after, machine.after_state_change):
             machine.callback(func, event_data)
             _LOGGER.debug("%sExecuted callback '%s' after transition.", event_data.machine.name, func)
         return True
 
     def _change_state(self, event_data):
-        if self.dest:  # if self.dest is None this is an internal transition with no actual state change
-            event_data.machine.get_state(self.source).exit(event_data)
-            event_data.machine.set_state(self.dest, event_data.model)
-            event_data.update(event_data.model)
-            event_data.machine.get_state(self.dest).enter(event_data)
+        event_data.machine.get_state(self.source).exit(event_data)
+        event_data.machine.set_state(self.dest, event_data.model)
+        event_data.update(event_data.model)
+        event_data.machine.get_state(self.dest).enter(event_data)
 
     def add_callback(self, trigger, func):
         """ Add a new before, after, or prepare callback.

transitions/extensions/diagrams.py

@@ -124,7 +124,11 @@ def _add_edges(self, events, container):
                 src = transitions[0]
                 edge_attr = {}
                 for trans in transitions[1]:
-                    dst = trans.dest
+                    if trans.dest is None:
+                        dst = src
+                        label += " [internal]"
+                    else:
+                        dst = trans.dest
                     edge_attr['label'] = self._transition_label(label, trans)
                     if container.has_edge(src, dst):
                         edge = container.get_edge(src, dst)
@@ -241,12 +245,14 @@ def _add_edges(self, events, container):
                     if trans in self.seen_transitions:
                         continue
                     if trans.dest is None:
+                        dst = src
+                        label += " [internal]"
+                    elif not container.has_node(trans.dest) and _get_subgraph(container, 'cluster_' + trans.dest) is None:
                         continue
-                    if not container.has_node(trans.dest) and _get_subgraph(container, 'cluster_' + trans.dest) is None:
-                        continue
+                    else:
+                        dst = self.machine.get_state(trans.dest)
 
                     self.seen_transitions.append(trans)
-                    dst = self.machine.get_state(trans.dest)
                     if dst.children:
                         if not src.is_substate_of(dst.name):
                             edge_attr['lhead'] = "cluster_" + dst.name
@@ -274,9 +280,6 @@ class TransitionGraphSupport(Transition):
     """
 
     def _change_state(self, event_data):
-        if self.dest is None:
-            return
-
         machine = event_data.machine
         model = event_data.model
         dest = machine.get_state(self.dest)

transitions/extensions/nesting.py

@@ -211,8 +211,6 @@ def execute(self, event_data):
 
     # The actual state change method 'execute' in Transition was restructured to allow overriding
     def _change_state(self, event_data):
-        if self.dest is None:
-            return
         machine = event_data.machine
         model = event_data.model
         dest_state = machine.get_state(self.dest)