def test_subgraphing(self):
original_numbers = self._get_original_numbers()
simple = Graph(name='simple')
simple.add_node(x=0.0, y=0.0, name='A')
simple.add_node(x=0.0, y=1.0, name='B')
simple.connect('A', 'B', name="I", directional=False)
simple_copy = simple.copy(1.0, 0.0)
super_graph = Graph(name='super_graph', graphs=[simple, simple_copy])
super_graph.connect('simple:A',
'simple(copy):B',
name='II',
directional=True)
nodes = [('simple:A', Node(0.0, 0.0)), ('simple:B', Node(0.0, 1.0)),
('simple(copy):A', Node(1.0, 0.0)),
('simple(copy):B', Node(1.0, 1.0))]
edges = [('simple:I', Edge('simple:A', 'simple:B', directional=False)),
('simple(copy):I',
Edge('simple(copy):A', 'simple(copy):B', directional=False)),
('II', Edge('simple:A', 'simple(copy):B', directional=True))]
numbers = (
4, # anchored_nodes
3, # anchored_edges
0, # unique_nodes
1, # unique_anchored_edges
0, # unique_unanchored_edges
2, # subgraphs
2 # anchored_subgraphs
)
self._check_graph(super_graph, 'super_graph', 'simple:A', True, nodes,
edges, numbers)
self._check_numbers(original_numbers, 8, 6, 3)
def test_attributes(self):
edge = Edge('tail', 'head', directional=True)
self.assertEqual(edge.tail, 'tail')
self.assertEqual(edge.head, 'head')
self.assertTrue(edge.directional)
self.assertEqual(edge.string_connector, ' --> ')
edge = Edge('tail', 'head', directional=False)
self.assertFalse(edge.directional)
self.assertEqual(edge.string_connector, ' --- ')
def test_copy(self):
original_numbers = self._get_original_numbers()
simple = Graph(name='simple')
simple.add_node(x=0.0, y=0.0, name='A')
simple.add_node(x=0.0, y=1.0, name='B')
simple.connect('A', 'B', name="I", directional=False)
simple_copy = simple.copy(0.0, 0.0)
nodes = [('A', Node(0.0, 0.0)), ('B', Node(0.0, 1.0))]
edges = [('I', Edge('A', 'B', directional=False))]
numbers = (
2, # anchored_nodes
1, # anchored_edges
2, # unique_nodes
1, # unique_anchored_edges
0, # unique_unanchored_edges
0, # subgraphs
0 # anchored_subgraphs
)
self._check_graph(simple_copy, 'simple(copy)', 'A', True, nodes, edges,
numbers)
self._check_numbers(original_numbers, 6, 3, 2)
for node, node_copy in zip(simple.nodes.values(),
simple_copy.nodes.values()):
self.assertEqual(node, node_copy)
self.assertIsNot(node, node_copy)
for edge, edge_copy in zip(simple.edges.values(),
simple_copy.edges.values()):
self.assertEqual(edge, edge_copy)
self.assertIsNot(edge, edge_copy)
def _check_if_edge_exists(self, nodeA, nodeB, name):
tmp_edge = Edge(nodeA, nodeB)
for key, edge in self.edges.items():
if edge == tmp_edge:
print('Warning: Edge', name, 'from', nodeA, 'to', nodeB,
'was previously specified.', key,
'is being overwritten.')
del self.edges[key]
def test_connect(self):
original_numbers = self._get_original_numbers()
simple = Graph(name='simple')
simple.add_node(x=0.0, y=0.0, name='A')
simple.add_node(x=0.0, y=1.0, name='B', anchor=True)
simple.connect('A', 'B', name="I", directional=False)
nodes = [('A', Node(0.0, 0.0)), ('B', Node(0.0, 1.0))]
edges = [('I', Edge('A', 'B', directional=False))]
numbers = (
2, # anchored_nodes
1, # anchored_edges
2, # unique_nodes
1, # unique_anchored_edges
0, # unique_unanchored_edges
0, # subgraphs
0 # anchored_subgraphs
)
self._check_graph(simple, 'simple', 'B', True, nodes, edges, numbers)
self._check_numbers(original_numbers, 4, 2, 1)
def connect(self, tail, head, **kwargs):
'''
positional arguments:
tail (str): name of the 'tail' node
head (str): name of the 'head' node (where the arrow points to)
keyword arguments:
name (str): name of the edge
directional (bool): True - draw arrow pointing twords the head.
False - draw straight line between nodes.
'''
name = process_name("Edge " + str(len(Edge._instances)), kwargs)
self._check_if_node_exists(tail)
self._check_if_node_exists(head)
self._check_if_edge_exists(tail, head, name)
self.edges[name] = Edge(tail, head, **kwargs)
if tail in self.anchored_nodes:
self.anchored_edges.append(name)
self.unique_anchored_edges.append(name)
if head not in self.anchored_nodes:
self.anchored_nodes.append(head)
self._anchor_subgraph(head)
elif head in self.anchored_nodes:
self.anchored_edges.append(name)
self.unique_anchored_edges.append(name)
if tail not in self.anchored_nodes:
self.anchored_nodes.append(tail)
self._anchor_subgraph(tail)
else:
self.unique_unanchored_edges.append(name)
self.anchor_graph()
return name
def test_edge_number(self):
original_count = len(Edge._instances)
tmp_edge = Edge('tail', 'head')
self.assertEqual(tmp_edge.count, original_count + 1)
del tmp_edge
self.assertEqual(len(Edge._instances), original_count)
def test_inequality(self):
edge = Edge('tail', 'head', directional=True)
tmp_edge = Edge('bob', 'head', directional=True)
self.assertNotEqual(tmp_edge, edge)
def test_equality(self):
edge = Edge('tail', 'head', directional=True)
tmp_edge = deepcopy(edge)
tmp_edge.directional = False
self.assertEqual(tmp_edge, edge)
def test_has_node(self):
edge = Edge('tail', 'head', directional=True)
self.assertTrue(edge.has_node('tail'))
self.assertTrue(edge.has_node('head'))
def test_copy(self):
edge = Edge('tail', 'head', directional=True)
tmp_edge = deepcopy(edge)
self.assertEqual(tmp_edge, edge)
self.assertIsNot(tmp_edge, edge)
def test_has_node(self):
edge = Edge('tail', 'head', directional = True)
self.assertTrue(edge.has_node('tail'))
self.assertTrue(edge.has_node('head'))
def test_copying_with_subgraphing(self):
original_numbers = self._get_original_numbers()
pipe1 = Graph(name='pipe1')
pipe1.add_node(x=0.0, y=0.0, name='inlet')
pipe1.add_node(1.0, 0.0, name='outlet')
pipe2 = pipe1.copy(x=1.5, y=0.0, name='pipe2')
long_pipe1 = Graph(name='long_pipe1', graphs=[pipe1, pipe2])
long_pipe1.connect('pipe1:outlet', 'pipe2:inlet', name="junction")
long_pipe1.connect('pipe1:inlet',
'pipe1:outlet',
name="internal-connection1",
directional=False)
long_pipe1.connect('pipe2:inlet',
'pipe2:outlet',
name="internal-connection2",
directional=False)
long_pipe2 = long_pipe1.copy(x=2.5, y=1.0, name='long_pipe2')
long_pipe2.reflect(axis='y')
circuit = Graph(name='circuit', graphs=[long_pipe1, long_pipe2])
circuit.connect('long_pipe1:pipe2:outlet',
'long_pipe2:pipe1:inlet',
name="junction1")
circuit.connect('long_pipe2:pipe2:outlet',
'long_pipe1:pipe1:inlet',
name="junction2")
nodes = [('long_pipe1:pipe1:inlet', Node(0.0, 0.0)),
('long_pipe1:pipe1:outlet', Node(1.0, 0.0)),
('long_pipe1:pipe2:inlet', Node(1.5, 0.0)),
('long_pipe1:pipe2:outlet', Node(2.5, 0.0)),
('long_pipe2:pipe1:inlet', Node(2.5, 1.0)),
('long_pipe2:pipe1:outlet', Node(1.5, 1.0)),
('long_pipe2:pipe2:inlet', Node(1.0, 1.0)),
('long_pipe2:pipe2:outlet', Node(0.0, 1.0))]
edges = [('long_pipe1:junction',
Edge('long_pipe1:pipe1:outlet',
'long_pipe1:pipe2:inlet',
directional=True)),
('long_pipe1:internal-connection1',
Edge('long_pipe1:pipe1:inlet',
'long_pipe1:pipe1:outlet',
directional=False)),
('long_pipe1:internal-connection2',
Edge('long_pipe1:pipe2:inlet',
'long_pipe1:pipe2:outlet',
directional=False)),
('long_pipe2:junction',
Edge('long_pipe2:pipe1:outlet',
'long_pipe2:pipe2:inlet',
directional=True)),
('long_pipe2:internal-connection1',
Edge('long_pipe2:pipe1:inlet',
'long_pipe2:pipe1:outlet',
directional=False)),
('long_pipe2:internal-connection2',
Edge('long_pipe2:pipe2:inlet',
'long_pipe2:pipe2:outlet',
directional=False)),
('junction1',
Edge('long_pipe1:pipe2:outlet',
'long_pipe2:pipe1:inlet',
directional=True)),
('junction2',
Edge('long_pipe2:pipe2:outlet',
'long_pipe1:pipe1:inlet',
directional=True))]
numbers = (
8, # anchored_nodes
8, # anchored_edges
0, # unique_nodes
2, # unique_anchored_edges
0, # unique_unanchored_edges
2, # subgraphs
2 # anchored_subgraphs
)
self._check_graph(circuit, 'circuit', 'long_pipe1:pipe1:inlet', True,
nodes, edges, numbers)
self._check_numbers(original_numbers, 16, 16, 7)
def _already_existing_edge(self, nodeA, nodeB):
tmp_edge = Edge(nodeA, nodeB)
for edge in self.unique_edges:
if tmp_edge == self.graph.edges[edge]:
return edge
return None