def types_of_all_modules(self, node):
if isinstance(node, NodeGroup):
modules = self._graph().node_attr(node, NodeAttributes.GROUPED_NODES)
types = CollectionTools.union_all(self.types_of_single_module(module) for module in modules)
else:
types = self.types_of_single_module(node)
return types
def nodes_in_edge_list(edge_list):
"""
>>> sorted(GraphConversions.nodes_in_edge_list([('a', 'b'), ('b', 'c')]))
['a', 'b', 'c']
"""
nodes = CollectionTools.union_all(
((source for (source, _target) in edge_list),
(target for (_source, target) in edge_list)))
return nodes
def __copy_edges_and_node(self, nodes, edges, do_deepcopy):
if edges != None:
if do_deepcopy:
self.__edges = deepcopy(set(edges))
else:
self.__edges = edges
#self.__edges = set([AttributedEdge(source, target) for (source, target) in edges])
if nodes == None:
self.__nodes = dict()
for node in CollectionTools.union_all(edge.node_set() for edge in self.__edges):
self.__nodes[node] = dict()
if nodes != None:
if do_deepcopy:
self.__nodes = deepcopy(nodes)
else:
self.__nodes = nodes
if edges == None:
self.__edges = set()
def get_scc_merged_graph(self):
result_graph = MutableAttributeGraph()
for node in self.__base_graph.node_names_iter():
if self.__scc_helper.get_scc_number_of_node(node) == None:
result_graph.add_node(node)
result_graph.set_node_attrs(node, self.__base_graph.node_attrs(node))
result_graph.set_node_attrs(node, {NodeAttributes.LABEL: ""})
for scc in self.__scc_helper.get_sccs_iter():
node_name = self.get_scc_node_name(scc)
result_graph.add_node(node_name)
all_base_nodes = CollectionTools.union_all(self.__get_grouped_nodes(node)
for node in scc)
result_graph.set_node_attrs(node_name, {NodeAttributes.GROUPED_NODES: all_base_nodes, NodeAttributes.LABEL: ""})
for edge in self.__base_graph.edges():
source = self.get_node_name(edge.get_from_node())
target = self.get_node_name(edge.get_to_node())
if source != target:
result_graph.add_edge(source, target)
return result_graph
def dependent_nodes(graph, start_nodes):
"""
>>> graph = GraphConversions.edge_list_to_pygraph([('a', 'b'), ('b', 'c'), ('a', 'c')])
>>> sorted(GraphAlgorithms.dependent_nodes(graph, ['c']))
['a', 'b', 'c']
"""
if isinstance(graph, BasicGraph):
accessibility_matrix = GraphAlgorithms.accessibility_matrix_from_graph(
graph, inverse=True)
elif isinstance(graph, digraph):
accessibility_matrix = accessibility(graph.reverse())
else:
raise TypeError("%s is not a known graph type", graph)
# dependent_nodes = set()
# for start_node in start_nodes:
# if start_node in accessibility_matrix:
# dependent_nodes.update(accessibility_matrix[start_node])
# return dependent_nodes
# TODO ist das effizienter als
return CollectionTools.union_all(accessibility_matrix[start_node]
for start_node in start_nodes
if start_node in accessibility_matrix)
def get_skip_module_types_as_source(self):
return CollectionTools.union_all((PhysicalModuleTypeConstants.WRAPPER_MODULE_TYPES,
PhysicalModuleTypeConstants.IRRELEVANT_MODULE_TYPES))
def get_skip_module_types_as_source(self):
return CollectionTools.union_all((PhysicalModuleTypeConstants.IMPLEMENTATION_MODULE_TYPES,
PhysicalModuleTypeConstants.INTERFACE_MODULE_TYPES,
PhysicalModuleTypeConstants.IRRELEVANT_MODULE_TYPES))
def nodes_raw(self):
if self.__nodes == None:
self.__nodes = frozenset(CollectionTools.union_all(graph.nodes_raw()
for graph in self.__graphs))
return self.__nodes
def connected_nodes(self):
return CollectionTools.union_all(edge.node_set() for edge in self._edges())
def node_group_prefixes(self):
return CollectionTools.union_all(
(BaseSuffixModuleGrouper.node_group_prefixes(self),
set(self.defined_module_group_suffixes.values())))
