improve graph generation of novel hsm

- for both graphviz and pygraphviz

use dest if state is an enum

improve graph generation for nested graphs (#413)

Author: aleneum

Diff for: transitions/extensions/diagrams.py

@@ -5,6 +5,7 @@
 import warnings
 import logging
 from functools import partial
+import copy
 
 _LOGGER = logging.getLogger(__name__)
 _LOGGER.addHandler(logging.NullHandler())
@@ -26,8 +27,10 @@ class TransitionGraphSupport(Transition):
     def _change_state(self, event_data):
         graph = event_data.machine.model_graphs[event_data.model]
         graph.reset_styling()
-        graph.set_previous_transition(self.source, self.dest)
+        graph.set_previous_transition(self.source, self.dest, event_data.event.name)
         _super(TransitionGraphSupport, self)._change_state(event_data)  # pylint: disable=protected-access
+        for state in _flatten(listify(getattr(event_data.model, event_data.machine.model_attribute))):
+            graph.set_node_style(self.dest if hasattr(state, 'name') else state, 'active')
 
 
 class GraphMachine(MarkupMachine):
@@ -88,7 +91,13 @@ class GraphMachine(MarkupMachine):
             '': {},
             'default': {
                 'color': 'black',
-                'fillcolor': 'white'
+                'fillcolor': 'white',
+                'style': 'solid'
+            },
+            'parallel': {
+                'color': 'black',
+                'fillcolor': 'white',
+                'style': 'dotted'
             },
             'previous': {
                 'color': 'blue',
@@ -263,3 +272,47 @@ def _get_global_name(self, path):
                 return self._get_global_name(path)
         else:
             return self.machine.get_global_name()
+
+    def _get_elements(self):
+        states = []
+        transitions = []
+        try:
+            markup = self.machine.get_markup_config()
+            q = [([], markup)]
+
+            while q:
+                prefix, scope = q.pop(0)
+                for transition in scope.get('transitions', []):
+                    if prefix:
+                        t = copy.copy(transition)
+                        t['source'] = self.machine.state_cls.separator.join(prefix + [t['source']])
+                        t['dest'] = self.machine.state_cls.separator.join(prefix + [t['dest']])
+                    else:
+                        t = transition
+                    transitions.append(t)
+                for state in scope.get('children', []) + scope.get('states', []):
+                    if not prefix:
+                        s = state
+                        states.append(s)
+
+                    ini = state.get('initial', [])
+                    if not isinstance(ini, list):
+                        ini = ini.name if hasattr(ini, 'name') else ini
+                        t = dict(trigger='',
+                                 source=self.machine.state_cls.separator.join(prefix + [state['name']]) + '_anchor',
+                                 dest=self.machine.state_cls.separator.join(prefix + [state['name'], ini]))
+                        transitions.append(t)
+                    if state.get('children', []):
+                        q.append((prefix + [state['name']], state))
+        except KeyError as e:
+            _LOGGER.error("Graph creation incomplete!")
+        return states, transitions
+
+
+def _flatten(item):
+    for elem in item:
+        if isinstance(elem, (list, tuple, set)):
+            for res in _flatten(elem):
+                yield res
+        else:
+            yield elem

Diff for: transitions/extensions/diagrams_graphviz.py

@@ -13,6 +13,7 @@
 import copy
 
 from .diagrams import BaseGraph
+from ..core import listify
 try:
     import graphviz as pgv
 except ImportError:  # pragma: no cover
@@ -37,10 +38,9 @@ def __init__(self, machine, title=None):
         self.reset_styling()
         _super(Graph, self).__init__(machine, title)
 
-    def set_previous_transition(self, src, dst):
+    def set_previous_transition(self, src, dst, key=None):
         self.custom_styles['edge'][src][dst] = 'previous'
         self.set_node_style(src, 'previous')
-        self.set_node_style(dst, 'active')
 
     def set_node_style(self, state, style):
         self.custom_styles['node'][state] = style
@@ -76,49 +76,24 @@ def generate(self, title=None, roi_state=None):
         if not pgv:  # pragma: no cover
             raise Exception('AGraph diagram requires graphviz')
 
-        title = '' if not title else title
+        title = self.machine.title if not title else title
 
         fsm_graph = pgv.Digraph(name=title, node_attr=self.machine.style_attributes['node']['default'],
                                 edge_attr=self.machine.style_attributes['edge']['default'],
                                 graph_attr=self.machine.style_attributes['graph']['default'])
         fsm_graph.graph_attr.update(**self.machine.machine_attributes)
+        fsm_graph.graph_attr['label'] = title
         # For each state, draw a circle
-        try:
-            markup = self.machine.get_markup_config()
-            q = [([], markup)]
-            states = []
-            transitions = []
-            while q:
-                prefix, scope = q.pop(0)
-                for transition in scope.get('transitions', []):
-                    if prefix:
-                        t = copy.copy(transition)
-                        t['source'] = self.machine.state_cls.separator.join(prefix + [t['source']])
-                        t['dest'] = self.machine.state_cls.separator.join(prefix + [t['dest']])
-                    else:
-                        t = transition
-                    transitions.append(t)
-                for state in scope.get('states', []):
-                    if prefix:
-                        s = copy.copy(state)
-                        s['name'] = self.machine.state_cls.separator.join(prefix + [s['name']])
-                    else:
-                        s = state
-                    states.append(s)
-                    if state.get('children', []):
-                        q.append((prefix + [state['name']], state))
-
-            if roi_state:
-                transitions = [t for t in transitions
-                               if t['source'] == roi_state or self.custom_styles['edge'][t['source']][t['dest']]]
-                state_names = [t for trans in transitions
-                               for t in [trans['source'], trans.get('dest', trans['source'])]]
-                state_names += [k for k, style in self.custom_styles['node'].items() if style]
-                states = _filter_states(states, state_names, self.machine.state_cls)
-            self._add_nodes(states, fsm_graph)
-            self._add_edges(transitions, fsm_graph)
-        except KeyError:
-            _LOGGER.error("Graph creation incomplete!")
+        states, transitions = self._get_elements()
+        if roi_state:
+            transitions = [t for t in transitions
+                           if t['source'] == roi_state or self.custom_styles['edge'][t['source']][t['dest']]]
+            state_names = [t for trans in transitions
+                           for t in [trans['source'], trans.get('dest', trans['source'])]]
+            state_names += [k for k, style in self.custom_styles['node'].items() if style]
+            states = _filter_states(states, state_names, self.machine.state_cls)
+        self._add_nodes(states, fsm_graph)
+        self._add_edges(transitions, fsm_graph)
         setattr(fsm_graph, 'draw', partial(self.draw, fsm_graph))
         return fsm_graph
 
@@ -152,41 +127,44 @@ def __init__(self, *args, **kwargs):
         self._cluster_states = []
         _super(NestedGraph, self).__init__(*args, **kwargs)
 
-    def set_previous_transition(self, src, dst):
+    def set_previous_transition(self, src, dst, key=None):
         src_name = self._get_global_name(src.split(self.machine.state_cls.separator))
         dst_name = self._get_global_name(dst.split(self.machine.state_cls.separator))
-        _super(NestedGraph, self).set_previous_transition(src_name, dst_name)
+        _super(NestedGraph, self).set_previous_transition(src_name, dst_name, key)
 
-    def _add_nodes(self, states, container, prefix=''):
+    def _add_nodes(self, states, container, prefix='', default_style='default'):
 
         for state in states:
             name = prefix + state['name']
             label = self._convert_state_attributes(state)
 
-            if 'children' in state:
+            if state.get('children', []):
                 cluster_name = "cluster_" + name
                 with container.subgraph(name=cluster_name,
                                         graph_attr=self.machine.style_attributes['graph']['default']) as sub:
-                    style = self.custom_styles['node'][name]
+                    style = self.custom_styles['node'][name] or default_style
                     sub.graph_attr.update(label=label, rank='source', **self.machine.style_attributes['graph'][style])
                     self._cluster_states.append(name)
+                    is_parallel = isinstance(state.get('initial', ''), list)
+                    width = '0.0' if is_parallel else '0.1'
                     with sub.subgraph(name=cluster_name + '_root',
                                       graph_attr={'label': '', 'color': 'None', 'rank': 'min'}) as root:
-                        root.node(name + "_anchor", shape='point', fillcolor='black', width='0.1')
-                    self._add_nodes(state['children'], sub, prefix=prefix + state['name'] + self.machine.state_cls.separator)
+                        root.node(name + "_anchor", shape='point', fillcolor='black', width=width)
+                    self._add_nodes(state['children'], sub, default_style='parallel' if is_parallel else 'default',
+                                    prefix=prefix + state['name'] + self.machine.state_cls.separator)
             else:
-                style = self.custom_styles['node'][name]
+                style = self.custom_styles['node'][name] or default_style
                 container.node(name, label=label, **self.machine.style_attributes['node'][style])
 
-    def _add_edges(self, transitions, container):
+    def _add_edges(self, transitions, container, prefix=''):
         edges_attr = defaultdict(lambda: defaultdict(dict))
 
         for transition in transitions:
             # enable customizable labels
             label_pos = 'label'
-            src = transition['source']
+            src = prefix + transition['source']
             try:
-                dst = transition['dest']
+                dst = prefix + transition['dest']
             except KeyError:
                 dst = src
             if edges_attr[src][dst]:

Diff for: transitions/extensions/diagrams_pygraphviz.py

@@ -61,35 +61,9 @@ def generate(self, title=None):
         self.fsm_graph = pgv.AGraph(label=title, **self.machine.machine_attributes)
         self.fsm_graph.node_attr.update(self.machine.style_attributes['node']['default'])
         self.fsm_graph.edge_attr.update(self.machine.style_attributes['edge']['default'])
-
-        # For each state, draw a circle
-        markup = self.machine.get_markup_config()
-        q = [([], markup)]
-        states = []
-        transitions = []
-        while q:
-            prefix, scope = q.pop(0)
-            for transition in scope.get('transitions', []):
-                if prefix:
-                    t = copy.copy(transition)
-                    t['source'] = self.machine.state_cls.separator.join(prefix + [t['source']])
-                    t['dest'] = self.machine.state_cls.separator.join(prefix + [t['dest']])
-                else:
-                    t = transition
-                transitions.append(t)
-            for state in scope.get('states', []):
-                if prefix:
-                    s = copy.copy(state)
-                    s['name'] = self.machine.state_cls.separator.join(prefix + [s['name']])
-                else:
-                    s = state
-                states.append(s)
-                if state.get('children', []):
-                    q.append((prefix + [state['name']], state))
-
+        states, transitions = self._get_elements()
         self._add_nodes(states, self.fsm_graph)
         self._add_edges(transitions, self.fsm_graph)
-
         setattr(self.fsm_graph, 'style_attributes', self.machine.style_attributes)
 
         return self.fsm_graph
@@ -132,7 +106,7 @@ def set_node_style(self, state, style):
         style_attr = self.fsm_graph.style_attributes.get('node', {}).get(style)
         node.attr.update(style_attr)
 
-    def set_previous_transition(self, src, dst):
+    def set_previous_transition(self, src, dst, key=None):
         try:
             edge = self.fsm_graph.get_edge(src, dst)
         except KeyError:
@@ -164,27 +138,26 @@ def __init__(self, *args, **kwargs):
         _super(NestedGraph, self).__init__(*args, **kwargs)
         # self.style_attributes['edge']['default']['minlen'] = 2
 
-    def _add_nodes(self, states, container, prefix=''):
+    def _add_nodes(self, states, container, prefix='', default_style='default'):
         for state in states:
             name = prefix + state['name']
             label = self._convert_state_attributes(state)
 
             if 'children' in state:
                 cluster_name = "cluster_" + name
+                is_parallel = isinstance(state.get('initial', ''), list)
                 sub = container.add_subgraph(name=cluster_name, label=label, rank='source',
-                                             **self.machine.style_attributes['graph']['default'])
+                                             **self.machine.style_attributes['graph'][default_style])
                 root_container = sub.add_subgraph(name=cluster_name + '_root', label='', color=None, rank='min')
-                # child_container = sub.add_subgraph(name=cluster_name + '_child', label='', color=None)
-                root_container.add_node(name + "_anchor", shape='point', fillcolor='black', width='0.1')
-                self._add_nodes(state['children'], sub, prefix=prefix + state['name'] + NestedState.separator)
+                width = '0' if is_parallel else '0.1'
+                root_container.add_node(name + "_anchor", shape='point', fillcolor='black', width=width)
+                self._add_nodes(state['children'], sub, prefix=prefix + state['name'] + NestedState.separator,
+                                default_style='parallel' if is_parallel else 'default')
             else:
                 container.add_node(name, label=label, shape=self.machine.style_attributes['node']['default']['shape'])
 
     def _add_edges(self, transitions, container):
 
-        # for sub in container.subgraphs_iter():
-        #     events = self._add_edges(transitions, sub)
-
         for transition in transitions:
             # enable customizable labels
             label_pos = 'label'
@@ -232,28 +205,29 @@ def set_node_style(self, state, style):
             style_attr = self.fsm_graph.style_attributes.get('graph', {}).get(style)
             subgraph.graph_attr.update(style_attr)
 
-    def set_previous_transition(self, src, dst):
+    def set_previous_transition(self, src, dst, key=None):
         src = self._get_global_name(src.split(self.machine.state_cls.separator))
         dst = self._get_global_name(dst.split(self.machine.state_cls.separator))
+        edge_attr = self.fsm_graph.style_attributes.get('edge', {}).get('previous').copy()
         try:
             edge = self.fsm_graph.get_edge(src, dst)
         except KeyError:
             _src = src
             _dst = dst
             if _get_subgraph(self.fsm_graph, 'cluster_' + src):
+                edge_attr['ltail'] = 'cluster_' + src
                 _src += '_anchor'
             if _get_subgraph(self.fsm_graph, 'cluster_' + dst):
+                edge_attr['lhead'] = "cluster_" + dst
                 _dst += '_anchor'
             try:
                 edge = self.fsm_graph.get_edge(_src, _dst)
             except KeyError:
                 self.fsm_graph.add_edge(_src, _dst)
                 edge = self.fsm_graph.get_edge(_src, _dst)
 
-        style_attr = self.fsm_graph.style_attributes.get('edge', {}).get('previous')
-        edge.attr.update(style_attr)
+        edge.attr.update(edge_attr)
         self.set_node_style(src, 'previous')
-        self.set_node_style(dst, 'active')
 
 
 def _get_subgraph(graph, name):

Diff for: transitions/extensions/factory.py

@@ -119,5 +119,5 @@ class HierarchicalAsyncGraphMachine(GraphMachine, HierarchicalAsyncMachine):
     (False, False, False, True): AsyncMachine,
     (True, False, False, True): AsyncGraphMachine,
     (False, True, False, True): HierarchicalAsyncMachine,
-    (False, True, False, True): HierarchicalAsyncGraphMachine
+    (True, True, False, True): HierarchicalAsyncGraphMachine
 }