def set_edge_attrs_subgraph_dependent_on_nodes(graph, start_nodes, attrs):
dependent_nodes = GraphAlgorithms.dependent_nodes(graph, start_nodes)
for edge in graph.edges():
if edge.get_from_node() in dependent_nodes and edge.get_to_node() in dependent_nodes:
if isinstance(edge, AttributedEdge):
edge.set_attrs(attrs)
else:
raise ValueError("Trying to set attributes on non-attributed edge")
def transitive_closure_from_graph(graph):
accessibility_matrix = GraphAlgorithms.accessibility_matrix_from_graph(graph)
#result_graph = MutableAttributeGraph(nodes=graph.nodes_raw())
result = set()
for from_node, to_nodes in accessibility_matrix.iteritems():
for to_node in to_nodes:
if from_node != to_node:
# TODO Muss ich hier eine AttributedEdge nehmen, tut es nicht auch eine SimpleEdge?
result.add(AttributedEdge(from_node=from_node, to_node=to_node))
return result
def process(self, show=False):
self._parser = config_dependency_parser()
self._parser.process()
dep_filter = config_dependency_filter(
config=config_dependency_filter_config)
self._parser.output(dep_filter)
decorator_conf = DecoratorSet(
node_tooltip_decorators=[NodeGroupDecorator()],
edge_tooltip_decorators=[EdgeGroupDecorator()])
basename = self.__generic_files_tools.get_module_link_deps_basename(
) + '-sub-custom'
outputter = config_dependency_filter_outputter(decorator_conf)
graph = dep_filter.graph()
# TODO Momentan nur ein Test!
#start_nodes = ['osapi', 'prio4dyn', 'dyn', 'prid4dynmfc', 'bib']
if config_basic.get_system() == 'prins':
start_nodes = set(ifilter(is_prins_classic,
graph.node_names())) - set(['osapi'])
description = GraphDescriptionImpl(
description=
"subgraph: modules independent of legacy PRINS (link deps)")
elif config_basic.get_system() == 'revengtools':
start_nodes = set(
ifilter(
lambda x: x.startswith(('infrastructure', 'cpp', 'python',
'systems', 'commons.graph')),
graph.node_names()))
description = GraphDescriptionImpl(
description="subgraph: generic core")
else:
raise RuntimeError("Unknown system %s" % config_basic.get_system())
GraphAlgorithms.remove_subgraph_dependent_on_nodes(graph, start_nodes)
description.set_basename(basename)
description.set_section('subgraph')
DependencyFilterOutputterTools.output_detail_and_overview_graph(
graph, outputter, description=description)
def __init__(self,
graph=None,
accessibility_matrix=None,
weight_function=None):
assert len(filter(
None, (graph, accessibility_matrix
))) == 1, "Either graph or accessiblity_matrix must be set"
if accessibility_matrix:
self.__accessibility_matrix = accessibility_matrix
else:
self.__accessibility_matrix = GraphAlgorithms.accessibility_matrix_from_graph(
graph)
self.__weight_function = weight_function
assert weight_function == None, "TODO using a weight function support is not yet implemented"
def __init__(self,
file_dependencies,
file_to_module_map,
use_transitive_closure=True,
module_name_filter=lambda module: module):
if use_transitive_closure:
unique_file_dependencies = set(
(src, dst) for (src, dst) in file_dependencies)
self.__reverse_file_dependencies = SetValuedDictTools.convert_from_itemiterator(
(target, source)
for (source, target) in GraphAlgorithms.transitive_closure(
unique_file_dependencies))
else:
self.__reverse_file_dependencies = SetValuedDictTools.convert_from_itemiterator(
(target, source) for (source, target) in file_dependencies)
self.__target_files_to_referencing_modules_map = dict()
self.__files_to_modules_raw = dict(file_to_module_map)
self.__module_name_filter = module_name_filter
def _create_accessibility_matrix(self, graph):
self.__accessibility_matrix = GraphAlgorithms.accessibility_matrix_from_graph(
graph, inverse=False)
def attach_graph(self, graph):
BaseGraphElementDecorator.attach_graph(self, graph)
start_nodes = self.get_start_nodes()
self.__subgraph_nodes = GraphAlgorithms.dependent_nodes(
graph, start_nodes)
def set_node_attrs_subgraph_dependent_on_nodes(graph, start_nodes, attrs):
dependent_nodes = GraphAlgorithms.dependent_nodes(graph, start_nodes)
for node in dependent_nodes:
graph.set_node_attrs(node, attrs)
def test_dependent_nodes_1_1(self):
result = GraphAlgorithms.dependent_nodes(GraphConversions.edge_list_to_pygraph(edge_list=self.INPUT_EDGES_1), start_nodes=[1])
self.assertEquals(set([1]), result)
def test_remove_branches_1_4(self):
result = GraphAlgorithms.remove_branches(cut_nodes=[1], edges=self.INPUT_EDGES_1, target_nodes=[5])
self.assertEquals(set([(4, 5), (3, 4), (2, 5), (2, 3), (2, 4)]), set(result))
def test_cut_branches_1_3(self):
result = GraphAlgorithms.cut_branches(cut_obj_ids=[4], edges=self.INPUT_EDGES_1)
self.assertEquals(set([(1,2), (2,3), (3,4), (2, 4), (2, 5)]), set(result))
def test_cut_branches_1_1(self):
result = GraphAlgorithms.cut_branches(cut_obj_ids=[], edges=self.INPUT_EDGES_1)
self.assertEquals(set(self.INPUT_EDGES_1), set(result))