fixes for sub graphs

Author: kyklos-admin

graphutil/graphutil.py

@@ -16,6 +16,9 @@
 # --David Minor April 9, 2018  -from here on check git hub
 # --https://github.com/dahvid/graphutil.git
 
+#this breaks subgraphs from version 2
+version = '3.0.1'
+
 has_graphviz = True
 try:
     import graphviz as pgv
@@ -253,6 +256,11 @@ def clear(self):
     def set_attribute(self, name, value):
         self.graph_attributes[name] = value
 
+    def add_attributes(self, key_values):
+        for k,v in key_values.items():
+            self.graph_attributes[k] = v
+
+
     def get_attribute(self, name):
         return self.graph_attributes.get(name)
 
@@ -288,11 +296,30 @@ def substitute(self, node, g):
         self.ccs_dirty = True
         self.topo_dirty = True
 
+    """
+    This inserts a node after the from_node, interrupting and re-routing all outputs
+    through the after_node. attributes will be preserved until from_attr or to_attr are given
+    assumes the after_node is already added to the graph
+    """
+    def insert_node_after(self,from_node, after_node, from_attr=None, to_attr=None):
+        from_arcs = self.out_arcs(from_node)
+        if from_arcs:
+            for f in from_arcs:
+                to_node = self.tail(f)
+                to_data = to_attr if to_attr else self.edge_data(f)[2]
+                from_data = from_attr if from_attr else self.edge_data(f)[2]
+                self.delete_edge(f)
+                #duplicate insertion means nothing here
+                self.add_edge(from_node,after_node,edge_data=from_data, no_except=True)
+                self.add_edge(after_node, to_node, edge_data=to_data)
+        else: #is leaf node, create an edge from scratch
+            self.add_edge(from_node,after_node,edge_data=from_attr)
+
 
 
 
     #TODO this should use a dfs for effeciency, instead of duplicating edges
-    def induce(self, nodes, label=None):
+    def induce(self, nodes, label=None, attributes=None):
         """
             creates an induced graph from the passed in set of tasks
             :return  graph, dangling out edges, dangling in edges
@@ -321,6 +348,8 @@ def induce(self, nodes, label=None):
                     dangling_out_edges += [(head,tail,data)]
         for (head,tail),data in edges.items():
                 g.add_edge(head,tail,data)
+        if attributes:
+            g.add_attributes(attributes)
         return (g, dangling_in_edges, dangling_out_edges)
 
 
@@ -545,6 +574,10 @@ def add_edge(self, head_id, tail_id, edge_data=None, no_except=False):
         self.ccs_dirty = True
         return edge_id
 
+    def set_edge_data(self,edge_id, data):
+        ed = self.edge_data(edge_id)
+        self.edges[edge_id] = (ed[0],ed[1],data)
+
 
     # --Removes the edge from the normal graph, but does not delete
     # --its information.  The edge is held in a separate structure
@@ -655,6 +688,9 @@ def get_edges(self, head_id, tail_id):
         return edges
 
 
+    def get_edge_attributes(self,edge_id):
+        d = self.edge_data(edge_id)
+        return d[2]
     # print "WARNING: No edge to return."
 
     def number_of_nodes(self):
@@ -740,6 +776,21 @@ def set_node_data(self, node_id, data):
     def edge_data(self, edge_id):
         return self.edges[edge_id]
 
+    def is_linear(self):
+        return not self.has_splits() and not self.has_joins()
+
+    # --Returns true if graph has any splits
+    def has_splits(self):
+        for n in self.node_list():
+            if len(self.out_arcs(n)) > 1:
+                return True
+        return False
+
+    def has_joins(self):
+        for n in self.node_list():
+            if len(self.in_arcs(n)) > 1:
+                return True
+        return False
 
     # --Returns a reference to the head of the edge.  (A reference to the head id)
     def head(self, edge):
@@ -766,7 +817,7 @@ def tail_data(self, edge):
     def out_arcs(self, node_id):
         if node_id not in self.nodes.keys():
             return []
-        return self.nodes[node_id][1]
+        return copy.copy(self.nodes[node_id][1])
 
 
     # --Returns a copy of the list of edge data of the node's out arcs.
@@ -778,7 +829,7 @@ def out_arcs_data(self, node_id):
     def in_arcs(self, node_id):
         if node_id not in self.nodes.keys():
             return []
-        return self.nodes[node_id][0]
+        return copy.copy(self.nodes[node_id][0])
 
 
     # --Returns list of adjacent nodes on input arcs
@@ -800,8 +851,6 @@ def out_adjacency_list(self):
         return dict([(node, self.out_adjacent(node)) for node in self.nodes])
 
 
-    # return { node : self.out_adjacent(node) for node in self.nodes}
-
     # --Similar to above.
     def in_arcs_data(self, node_id):
         return [self.edge_data(edge_id) for edge_id in self.in_arcs(node_id)]
@@ -833,7 +882,7 @@ def degree(self, node_id):
 
     # --merges graph into this graph
     # --overwriting any shared nodes
-    def merge(self, graph):
+    def merge(self, graph, remove_old_edges=False):
         for node,data in graph.node_dict().items():
             if node in self.node_list():
                 self.set_node_data(node,data)
@@ -843,6 +892,13 @@ def merge(self, graph):
         for edge,data in graph.edge_dict().items():
             if edge not in self.edge_dict():
                 self.add_edge(edge[0],edge[1],data[2])
+        if remove_old_edges:
+            for edge, data in self.edge_dict().items():
+                if edge[0] in graph.node_list() and (edge[1] in graph.node_list()):
+                    if edge not in graph.edge_dict():
+                        edges = self.get_edges(edge[0],edge[1])
+                        for e in edges:
+                            self.delete_edge(e)
 
     # location of each node in topo list
     def make_topo_node_finder(self):
@@ -968,9 +1024,6 @@ def connected_components(self):
         else:
             return self.ccs
 
-
-
-
     # --Tells dfs to stop searching this branch and go on to the next one
     class SkipBranch(Exception):
         pass
@@ -1004,6 +1057,25 @@ def dfs(self, source_id, visitor=None, repeat=False):
                     nodes_already_stacked[self.tail(edge)] = 0
                     dfs_stack.push(self.tail(edge))
         return dfs_list
+    """
+    Combindes dfs with topo, will do dfs but insure topo order followed
+    """
+    def dfs_topo_sort(self):
+        visited = { n : False for n in self.node_list()}
+        result = []
+        def DFS(node):
+            if visited[node]:
+                return
+            visited[node] = True
+            for adj in self.out_adjacent(node):
+                DFS(adj)
+            result.append(node)
+
+        for i in self.topological_sort():
+            DFS(i)
+
+        result.reverse()
+        return result
 
 
     class Counter:
@@ -1286,3 +1358,4 @@ def robust_topological_sort(self):
         sorted_components = robust_topological_sort(graph)
         # print 'robust topo sort', sorted_components
         return sorted_components
+