def _getStepsInProdDAG(self,
prodDict,
stepsListDict,
stepsOrder='sequential'):
""" Builds the DAG of steps in a production
:params dict prodDict: dictionary representing one production
:params list stepsListDict: list of steps (which are dictionaries) that should be in the production
:returns: stepsInProd (DAG)
"""
stepsInProd = DAG()
inserted = None
for stepID in prodDict['stepsInProd-ProdName']:
for step in stepsListDict:
if step['prodStepID'] == stepID:
ind = stepsListDict.index(step)
step = stepsListDict.pop(ind)
stepsInProd.addNode(step)
if inserted and stepsOrder == 'sequential':
stepsInProd.addEdge(inserted, step)
inserted = step
return stepsInProd
def test_getList(self):
"""test dag to list"""
dag = DAG()
dag.addNode("A")
l = dag.getList()
self.assertEqual(l, ["A"])
dag.addNode("C")
dag.addEdge("A", "C")
l = dag.getList()
self.assertEqual(l, ["A", "C"])
dag.addNode("B")
dag.addEdge("C", "B")
l = dag.getList()
self.assertEqual(l, ["A", "C", "B"])
d = dict(zip("ab", range(2)))
dag.addNode(d)
dag.addEdge("B", d)
l = dag.getList()
self.assertEqual(l, ["A", "C", "B", d])
l1 = list(range(2))
dag.addNode(l1)
dag.addEdge(d, l1)
l = dag.getList()
self.assertEqual(l, ["A", "C", "B", d, l1])
dag.addNode("E")
dag.addEdge(l1, "E")
l = dag.getList()
self.assertEqual(l, ["A", "C", "B", d, l1, "E"])
dag1 = DAG()
dag1.addNode(d)
dag1.addNode(l1)
dag1.addEdge(d, l1)
l = dag1.getList()
self.assertEqual(l, [d, l1])
def test_full(self):
"""test dag creation and more"""
dag = DAG()
i_n = dag.getIndexNodes()
self.assertEqual(i_n, [])
dag.addNode("A")
self.assertEqual(dag.graph, {"A": set()})
dag.addNode("A")
self.assertEqual(dag.graph, {"A": set()})
dag.addNode("B")
self.assertEqual(dag.graph, {"A": set(), "B": set()})
l = dag.getList()
self.assertEqual(l, [])
dag.addEdge("A", "B")
self.assertEqual(dag.graph, {"A": {"B"}, "B": set()})
l = dag.getList()
self.assertEqual(set(l), {"A", "B"})
dag.addEdge("A", "B")
self.assertEqual(dag.graph, {"A": {"B"}, "B": set()})
dag.addEdge("A", "C")
self.assertEqual(dag.graph, {"A": {"B"}, "B": set()})
dag.addNode("C")
dag.addEdge("A", "C")
self.assertEqual(dag.graph, {"A": {"B", "C"}, "B": set(), "C": set()})
l = dag.getList()
self.assertEqual(l, ["A"])
dag.addEdge("C", "A") # this would be cyclic, so it should not change the graph
self.assertEqual(dag.graph, {"A": {"B", "C"}, "B": set(), "C": set()})
dag.addNode("D")
i_n = dag.getIndexNodes()
self.assertEqual(set(i_n), {"A", "D"})
dag.addNode("E")
i_n = dag.getIndexNodes()
self.assertEqual(listToSet(i_n), listToSet(["A", "D", "E"]))
dag.addEdge("A", "D")
dag.addEdge("D", "E")
self.assertEqual(dag.graph, {"A": {"B", "C", "D"}, "B": set(), "C": set(), "D": {"E"}, "E": set()})
i_n = dag.getIndexNodes()
self.assertEqual(i_n, ["A"])
dag.addEdge("E", "A")
self.assertEqual(dag.graph, {"A": {"B", "C", "D"}, "B": set(), "C": set(), "D": {"E"}, "E": {"A"}})
# now an object
class forTest(object):
pass
ft = forTest()
dag.addNode(ft)
self.assertEqual(dag.graph, {"A": {"B", "C", "D"}, "B": set(), "C": set(), "D": {"E"}, "E": {"A"}, ft: set()})
dag.addEdge("B", ft)
self.assertEqual(dag.graph, {"A": {"B", "C", "D"}, "B": {ft}, "C": set(), "D": {"E"}, "E": {"A"}, ft: set()})
# now sets, dicts and lists as nodes
d = dict(zip("ab", range(2)))
dag.addNode(d)
self.assertEqual(
dag.graph,
{
"A": {"B", "C", "D"},
"B": {ft},
"C": set(),
"D": {"E"},
"E": {"A"},
ft: set(),
frozenset({("a", 0), ("b", 1)}): set(),
},
)
dag.addEdge(ft, d)
self.assertEqual(
dag.graph,
{
"A": {"B", "C", "D"},
"B": {ft},
"C": set(),
"D": {"E"},
"E": {"A"},
ft: set([frozenset({("a", 0), ("b", 1)})]),
frozenset({("a", 0), ("b", 1)}): set(),
},
)
l = list(range(2))
dag.addNode(l)
self.assertEqual(
dag.graph,
{
"A": {"B", "C", "D"},
"B": {ft},
"C": set(),
"D": {"E"},
"E": {"A"},
ft: set([frozenset({("a", 0), ("b", 1)})]), # ft -> d
frozenset({("a", 0), ("b", 1)}): set(), # d
frozenset({0, 1}): set(), # l
},
)
dag.addEdge(d, l)
self.assertEqual(
dag.graph,
{
"A": {"B", "C", "D"},
"B": {ft},
"C": set(),
"D": {"E"},
"E": {"A"},
ft: set([frozenset({("a", 0), ("b", 1)})]), # ft -> d
frozenset({("a", 0), ("b", 1)}): set([frozenset({0, 1})]), # d->l
frozenset({0, 1}): set(), # l
},
)
del dag.graph["E"]
del dag.graph["D"]
del dag.graph[ft]
del dag.graph[frozenset({("a", 0), ("b", 1)})]
dag.graph["A"] = {"B", "C"}
self.assertEqual(
dag.graph,
{
"A": {"B", "C"},
"B": {ft},
"C": set(),
frozenset({0, 1}): set(), # l
},
)
i_n = dag.getIndexNodes()
self.assertEqual(listToSet(i_n), listToSet(["A", l]))
d1 = {"a": "b"}
dag.addNode(d1)
self.assertEqual(
dag.graph,
{
"A": {"B", "C"},
"B": {ft},
"C": set(),
frozenset({0, 1}): set(), # l
frozenset({("a", "b")}): set(), # d1
},
)
l1 = ["a", "b"]
dag.addNode(l1)
self.assertEqual(
dag.graph,
{
"A": {"B", "C"},
"B": {ft},
"C": set(),
frozenset({0, 1}): set(), # l
frozenset({("a", "b")}): set(), # d1
frozenset({"a", "b"}): set(), # l1
},
)
i_n = dag.getIndexNodes()
self.assertEqual(listToSet(i_n, recursive=True), listToSet(["A", l, d1, l1], recursive=True))
s1 = set()
dag.addNode(s1)
self.assertEqual(
dag.graph,
{
"A": {"B", "C"},
"B": {ft},
"C": set(),
frozenset({0, 1}): set(), # l
frozenset({("a", "b")}): set(), # d1
frozenset({"a", "b"}): set(), # l1
frozenset({}): set(), # s1
},
)
# dict with frozenset in
dFSet1 = {"a": frozenset()}
dag.addNode(dFSet1)
self.assertEqual(
dag.graph,
{
"A": {"B", "C"},
"B": {ft},
"C": set(),
frozenset({0, 1}): set(), # l
frozenset({("a", "b")}): set(), # d1
frozenset({"a", "b"}): set(), # l1
frozenset({}): set(), # s1
frozenset([("a", frozenset([]))]): set(), # dFSet1
},
)
def test_getList(self):
""" test dag to list
"""
dag = DAG()
dag.addNode('A')
l = dag.getList()
self.assertEqual(l, ['A'])
dag.addNode('C')
dag.addEdge('A', 'C')
l = dag.getList()
self.assertEqual(l, ['A', 'C'])
dag.addNode('B')
dag.addEdge('C', 'B')
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B'])
d = dict(zip('ab', range(2)))
dag.addNode(d)
dag.addEdge('B', d)
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B', d])
l1 = list(range(2))
dag.addNode(l1)
dag.addEdge(d, l1)
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B', d, l1])
dag.addNode('E')
dag.addEdge(l1, 'E')
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B', d, l1, 'E'])
dag1 = DAG()
dag1.addNode(d)
dag1.addNode(l1)
dag1.addEdge(d, l1)
l = dag1.getList()
self.assertEqual(l, [d, l1])
def test_full(self):
""" test dag creation and more
"""
dag = DAG()
i_n = dag.getIndexNodes()
self.assertEqual(i_n, [])
dag.addNode('A')
self.assertEqual(dag.graph, {'A': set()})
dag.addNode('A')
self.assertEqual(dag.graph, {'A': set()})
dag.addNode('B')
self.assertEqual(dag.graph, {'A': set(), 'B': set()})
l = dag.getList()
self.assertEqual(l, [])
dag.addEdge('A', 'B')
self.assertEqual(dag.graph, {'A': {'B'}, 'B': set()})
l = dag.getList()
self.assertEqual(l, ['A', 'B'])
dag.addEdge('A', 'B')
self.assertEqual(dag.graph, {'A': {'B'}, 'B': set()})
dag.addEdge('A', 'C')
self.assertEqual(dag.graph, {'A': {'B'}, 'B': set()})
dag.addNode('C')
dag.addEdge('A', 'C')
self.assertEqual(dag.graph, {'A': {'B', 'C'}, 'B': set(), 'C': set()})
l = dag.getList()
self.assertEqual(l, ['A'])
dag.addEdge(
'C', 'A') #this would be cyclic, so it should not change the graph
self.assertEqual(dag.graph, {'A': {'B', 'C'}, 'B': set(), 'C': set()})
dag.addNode('D')
i_n = dag.getIndexNodes()
self.assertEqual(i_n, ['A', 'D'])
dag.addNode('E')
i_n = dag.getIndexNodes()
self.assertEqual(sorted(i_n), sorted(['A', 'D', 'E']))
dag.addEdge('A', 'D')
dag.addEdge('D', 'E')
self.assertEqual(dag.graph, {
'A': {'B', 'C', 'D'},
'B': set(),
'C': set(),
'D': {'E'},
'E': set()
})
i_n = dag.getIndexNodes()
self.assertEqual(i_n, ['A'])
dag.addEdge('E', 'A')
self.assertEqual(dag.graph, {
'A': {'B', 'C', 'D'},
'B': set(),
'C': set(),
'D': {'E'},
'E': {'A'}
})
#now an object
class forTest(object):
pass
ft = forTest()
dag.addNode(ft)
self.assertEqual(
dag.graph, {
'A': {'B', 'C', 'D'},
'B': set(),
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set()
})
dag.addEdge('B', ft)
self.assertEqual(
dag.graph, {
'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set()
})
#now sets, dicts and lists as nodes
d = dict(zip('ab', range(2)))
dag.addNode(d)
self.assertEqual(
dag.graph, {
'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set(),
frozenset({('a', 0), ('b', 1)}): set()
})
dag.addEdge(ft, d)
self.assertEqual(
dag.graph, {
'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set([frozenset({('a', 0), ('b', 1)})]),
frozenset({('a', 0), ('b', 1)}): set()
})
l = list(range(2))
dag.addNode(l)
self.assertEqual(
dag.graph,
{
'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set([frozenset({('a', 0), ('b', 1)})]), #ft -> d
frozenset({('a', 0), ('b', 1)}): set(), #d
frozenset({0, 1}): set() #l
})
dag.addEdge(d, l)
self.assertEqual(
dag.graph,
{
'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set([frozenset({('a', 0), ('b', 1)})]), #ft -> d
frozenset({('a', 0), ('b', 1)}): set([frozenset({0, 1})
]), #d->l
frozenset({0, 1}): set() #l
})
del dag.graph['E']
del dag.graph['D']
del dag.graph[ft]
del dag.graph[frozenset({('a', 0), ('b', 1)})]
dag.graph['A'] = {'B', 'C'}
self.assertEqual(
dag.graph,
{
'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0, 1}): set(), #l
})
i_n = dag.getIndexNodes()
self.assertEqual(i_n, ['A', l])
d1 = {'a': 'b'}
dag.addNode(d1)
self.assertEqual(
dag.graph,
{
'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0, 1}): set(), #l
frozenset({('a', 'b')}): set(), #d1
})
l1 = ['a', 'b']
dag.addNode(l1)
self.assertEqual(
dag.graph,
{
'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0, 1}): set(), #l
frozenset({('a', 'b')}): set(), #d1
frozenset({'a', 'b'}): set() #l1
})
i_n = dag.getIndexNodes()
self.assertEqual(sorted(i_n), sorted(['A', l, d1, l1]))
s1 = set()
dag.addNode(s1)
self.assertEqual(
dag.graph,
{
'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0, 1}): set(), #l
frozenset({('a', 'b')}): set(), #d1
frozenset({'a', 'b'}): set(), #l1
frozenset({}): set() # s1
})
#dict with frozenset in
dFSet1 = {'a': frozenset()}
dag.addNode(dFSet1)
self.assertEqual(
dag.graph,
{
'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0, 1}): set(), #l
frozenset({('a', 'b')}): set(), #d1
frozenset({'a', 'b'}): set(), #l1
frozenset({}): set(), # s1
frozenset([('a', frozenset([]))]): set() #dFSet1
})
def test_getList(self):
""" test dag to list
"""
dag = DAG()
dag.addNode('A')
l = dag.getList()
self.assertEqual(l, ['A'])
dag.addNode('C')
dag.addEdge('A', 'C')
l = dag.getList()
self.assertEqual(l, ['A', 'C'])
dag.addNode('B')
dag.addEdge('C', 'B')
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B'])
d = dict(zip('ab', range(2)))
dag.addNode(d)
dag.addEdge('B', d)
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B', d])
l1 = list(range(2))
dag.addNode(l1)
dag.addEdge(d, l1)
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B', d, l1])
dag.addNode('E')
dag.addEdge(l1, 'E')
l = dag.getList()
self.assertEqual(l, ['A', 'C', 'B', d, l1, 'E'])
dag1 = DAG()
dag1.addNode(d)
dag1.addNode(l1)
dag1.addEdge(d, l1)
l = dag1.getList()
self.assertEqual(l, [d, l1])
def test_full(self):
""" test dag creation and more
"""
dag = DAG()
i_n = dag.getIndexNodes()
self.assertEqual(i_n, [])
dag.addNode('A')
self.assertEqual(dag.graph, {'A': set()})
dag.addNode('A')
self.assertEqual(dag.graph, {'A': set()})
dag.addNode('B')
self.assertEqual(dag.graph, {'A': set(), 'B': set()})
l = dag.getList()
self.assertEqual(l, [])
dag.addEdge('A', 'B')
self.assertEqual(dag.graph, {'A': {'B'}, 'B': set()})
l = dag.getList()
self.assertEqual(l, ['A', 'B'])
dag.addEdge('A', 'B')
self.assertEqual(dag.graph, {'A': {'B'}, 'B': set()})
dag.addEdge('A', 'C')
self.assertEqual(dag.graph, {'A': {'B'}, 'B': set()})
dag.addNode('C')
dag.addEdge('A', 'C')
self.assertEqual(dag.graph, {'A': {'B', 'C'}, 'B': set(), 'C': set()})
l = dag.getList()
self.assertEqual(l, ['A'])
dag.addEdge('C', 'A') #this would be cyclic, so it should not change the graph
self.assertEqual(dag.graph, {'A': {'B', 'C'}, 'B': set(), 'C': set()})
dag.addNode('D')
i_n = dag.getIndexNodes()
self.assertEqual(i_n, ['A', 'D'])
dag.addNode('E')
i_n = dag.getIndexNodes()
self.assertEqual(sorted(i_n), sorted(['A', 'D', 'E']))
dag.addEdge('A', 'D')
dag.addEdge('D', 'E')
self.assertEqual(dag.graph, {'A': {'B', 'C', 'D'}, 'B': set(), 'C': set(), 'D': {'E'}, 'E': set()} )
i_n = dag.getIndexNodes()
self.assertEqual(i_n, ['A'])
dag.addEdge('E', 'A')
self.assertEqual(dag.graph, {'A': {'B', 'C', 'D'}, 'B': set(), 'C': set(), 'D': {'E'}, 'E': {'A'}} )
#now an object
class forTest(object):
pass
ft = forTest()
dag.addNode(ft)
self.assertEqual(dag.graph, {'A': {'B', 'C', 'D'}, 'B': set(), 'C': set(), 'D': {'E'}, 'E': {'A'}, ft: set()} )
dag.addEdge('B', ft)
self.assertEqual( dag.graph,
{'A': {'B', 'C', 'D'}, 'B': {ft}, 'C': set(), 'D': {'E'}, 'E': {'A'}, ft: set()}
)
#now sets, dicts and lists as nodes
d = dict(zip('ab', range(2)))
dag.addNode(d)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set(),
frozenset({('a',0), ('b',1)}): set()})
dag.addEdge(ft, d)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set([frozenset({('a',0), ('b',1)})]),
frozenset({('a',0), ('b',1)}): set()
}
)
l = list(range(2))
dag.addNode(l)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set([frozenset({('a',0), ('b',1)})]), #ft -> d
frozenset({('a',0), ('b',1)}): set(), #d
frozenset({0,1}): set() #l
}
)
dag.addEdge(d, l)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C', 'D'},
'B': {ft},
'C': set(),
'D': {'E'},
'E': {'A'},
ft: set([frozenset({('a',0), ('b',1)})]), #ft -> d
frozenset({('a',0), ('b',1)}): set([frozenset({0,1})]), #d->l
frozenset({0,1}): set() #l
}
)
del dag.graph['E']
del dag.graph['D']
del dag.graph[ft]
del dag.graph[frozenset({('a',0), ('b',1)})]
dag.graph['A'] = {'B', 'C'}
self.assertEqual( dag.graph,
{ 'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0,1}): set(), #l
}
)
i_n = dag.getIndexNodes()
self.assertEqual(i_n, ['A', l])
d1 = {'a':'b'}
dag.addNode(d1)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0,1}): set(), #l
frozenset({('a','b')}): set(), #d1
}
)
l1 = ['a', 'b']
dag.addNode(l1)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0,1}): set(), #l
frozenset({('a', 'b')}): set(), #d1
frozenset({'a', 'b'}): set() #l1
}
)
i_n = dag.getIndexNodes()
self.assertEqual(sorted(i_n), sorted(['A', l, d1, l1]))
s1 = set()
dag.addNode(s1)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0,1}): set(), #l
frozenset({('a', 'b')}): set(), #d1
frozenset({'a', 'b'}): set(), #l1
frozenset({}): set() # s1
}
)
#dict with frozenset in
dFSet1 = {'a':frozenset()}
dag.addNode(dFSet1)
self.assertEqual( dag.graph,
{ 'A': {'B', 'C'},
'B': {ft},
'C': set(),
frozenset({0,1}): set(), #l
frozenset({('a', 'b')}): set(), #d1
frozenset({'a', 'b'}): set(), #l1
frozenset({}): set(), # s1
frozenset([('a', frozenset([]))]): set() #dFSet1
}
)
