def get_structure_renaming(state):
"""
state is an ivy_interp.State with a .universe
result is a dictionary mapping universe constant names to prettier
names that should be used for displaying to the user
"""
from ivy_utils import topological_sort
# add node_info results for universe elements
elements = list(set([uc for s in state.universe for uc in state.universe[s]]))
# name according to topological sort
# TODO: make this not specific to leader example
state_formula = state.clauses.to_formula()
assert type(state_formula) is And
order = []
for lit in state_formula:
if type(lit) is Apply and lit.func.sort.arity == 2 and lit.func.name in ('reach', 'le'):
order.append(lit.terms)
elements = topological_sort(elements, order, lambda c: c.name)
result = dict()
count = defaultdict(int)
for c in elements:
prefix = str(c.sort).lower()
result[c.name] = prefix + str(count[prefix])
count[prefix] += 1
return result
def get_mixin_order(iso, mod):
arcs = [(rdf.args[0].relname, rdf.args[1].relname) for rdf in mod.mixord]
actions = mod.mixins.keys()
for action in actions:
mixins = mod.mixins[action]
implements = [
m for m in mixins if isinstance(m, ivy_ast.MixinImplementDef)
]
if len(implements) > 1:
raise iu.IvyError(implements[1],
'Multiple implementations for {}'.format(action))
mixins = [
m for m in mixins if not isinstance(m, ivy_ast.MixinImplementDef)
]
mixers = iu.topological_sort(list(set(m.mixer() for m in mixins)),
arcs)
keymap = dict((x, y) for y, x in enumerate(mixers))
key = lambda m: keymap[m.mixer()]
before = sorted(
[m for m in mixins if isinstance(m, ivy_ast.MixinBeforeDef)],
key=key)
after = sorted(
[m for m in mixins if isinstance(m, ivy_ast.MixinAfterDef)],
key=key)
# order = SortOrder(arcs)
# before = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinBeforeDef)],order)
# after = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinAfterDef)],order)
before.reverse() # add the before mixins in reverse order
mixins = implements + before + after
# print 'mixin order for action {}:'
# for m in mixins:
# print m.args[0]
mod.mixins[action] = mixins
def sort_nodes(self,nodes):
g = self.g
order = []
nodes_by_name = dict((x.name,x) for x in nodes)
for r in g.relations:
if r.arity() != 2:
continue
ena = self.get_enabled(r)
if ena[0].get() and ena[3].get(): # if positive arcs enabled and transitive
r.properties['reflexive'] = False
r.properties['transitive'] = False
for e in r.get_edges():
(x,y),status = e
if status == 'true':
order.append((nodes_by_name[x.name],nodes_by_name[y.name]))
nodes = topological_sort(nodes,order,lambda n: n.name)
return nodes
def sort_nodes(self,nodes):
g = self.g
order = []
nodes_by_name = dict((x.name,x) for x in nodes)
for r in g.relations:
if r.arity() != 2:
continue
ena = self.get_enabled(r)
if ena[0].get() and ena[3].get(): # if positive arcs enabled and transitive
r.properties['reflexive'] = False
r.properties['transitive'] = False
for e in r.get_edges():
(x,y),status = e
if status == 'true':
order.append((nodes_by_name[x.name],nodes_by_name[y.name]))
nodes = topological_sort(nodes,order,lambda n: n.name)
return nodes
def get_mixin_order(iso,mod):
arcs = [(rdf.args[0].relname,rdf.args[1].relname) for rdf in mod.mixord]
actions = mod.mixins.keys()
for action in actions:
mixins = mod.mixins[action]
mixers = iu.topological_sort(list(set(m.mixer() for m in mixins)),arcs)
keymap = dict((x,y) for y,x in enumerate(mixers))
key = lambda m: keymap[m.mixer()]
before = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinBeforeDef)],key=key)
after = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinAfterDef)],key=key)
# order = SortOrder(arcs)
# before = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinBeforeDef)],order)
# after = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinAfterDef)],order)
before.reverse() # add the before mixins in reverse order
mixins = before + after
# print 'mixin order for action {}:'
# for m in mixins:
# print m.args[0]
mod.mixins[action] = mixins
def get_mixin_order(iso,mod):
arcs = [(rdf.args[0].relname,rdf.args[1].relname) for rdf in mod.mixord]
actions = mod.mixins.keys()
for action in actions:
mixins = mod.mixins[action]
mixers = iu.topological_sort(list(set(m.mixer() for m in mixins)),arcs)
keymap = dict((x,y) for y,x in enumerate(mixers))
key = lambda m: keymap[m.mixer()]
before = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinBeforeDef)],key=key)
after = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinAfterDef)],key=key)
# order = SortOrder(arcs)
# before = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinBeforeDef)],order)
# after = sorted([m for m in mixins if isinstance(m,ivy_ast.MixinAfterDef)],order)
before.reverse() # add the before mixins in reverse order
mixins = before + after
# print 'mixin order for action {}:'
# for m in mixins:
# print m.args[0]
mod.mixins[action] = mixins
def dot_layout(cy_elements, edge_labels=False, subgraph_boxes=False, node_gt=None):
"""
Get a CyElements object and augment it (in-place) with positions,
widths, heights, and spline data from a dot based layout.
edge_labels is true if labels should appear on edges
subgraph_boxes is true if boxes should be drawn around subgraphs
Returns the object.
"""
elements = cy_elements.elements
# g = AGraph(directed=True, strict=False)
g = AGraph(directed=True, strict=False, forcelabels=True)
# make transitive relations appear top to bottom
elements = list(elements)
nodes_by_id = dict((e["data"]["id"], e) for e in elements if e["group"] == "nodes")
order = [
(nodes_by_id[e["data"]["source"]], nodes_by_id[e["data"]["target"]])
for e in elements
if e["group"] == "edges" and "transitive" in e["data"] and e["data"]["transitive"]
]
elements = topological_sort(elements, order, lambda e: e["data"]["id"])
# get the node id's and stable sort them by cluster
# the idea here is to convert the graph into a dag by sorting
# the nodes, then reversing the back edges. In particular, we try to make
# all the edges between two clusters go in the same direction so clustering
# doesn't result in horizontal edges, which dot renders badly.
sorted_nodes = [e["data"]["id"] for e in elements if e["group"] == "nodes"]
sorted_nodes = sorted(enumerate(sorted_nodes), key=lambda x: (nodes_by_id[x[1]]["data"]["cluster"], x[0]))
sorted_nodes = [y for idx, y in sorted_nodes]
node_key = dict((id, idx) for idx, id in enumerate(sorted_nodes))
if node_gt is None:
node_gt = lambda X, y: False
else:
node_gt = lambda x, y: node_key[x] > node_key[y]
# add nodes to the graph
for e in elements:
if e["group"] == "nodes" and e["classes"] != "non_existing":
g.add_node(e["data"]["id"], label=e["data"]["label"].replace("\n", "\\n"))
# TODO: remove this, it's specific to leader_demo
weight = {"reach": 10, "le": 10, "id": 1}
constraint = {"pending": False}
# add edges to the graph
for e in elements:
if e["group"] == "edges":
# kwargs = {'weight': weight.get(e["data"]["obj"], 0)},
kwargs = {"label": e["data"]["label"]} if edge_labels else {}
if node_gt(e["data"]["source"], e["data"]["target"]):
g.add_edge(
e["data"]["target"],
e["data"]["source"],
e["data"]["id"],
dir="back",
**kwargs
# constraint=constraint.get(e["data"]["obj"], True),
)
else:
g.add_edge(
e["data"]["source"],
e["data"]["target"],
e["data"]["id"],
**kwargs
# constraint=constraint.get(e["data"]["obj"], True),
)
# add clusters
clusters = defaultdict(list)
for e in elements:
if e["group"] == "nodes" and e["data"]["cluster"] is not None and e["classes"] != "non_existing":
clusters[e["data"]["cluster"]].append(e["data"]["id"])
for i, k in enumerate(sorted(clusters.keys())):
g.add_subgraph(name="cluster_{}".format(i), nbunch=clusters[k], rank="min")
# now get positions, heights, widths, and bsplines
g.layout(prog="dot")
# get the y origin. we want the top left of the graph to be a
# fixed coordinate (hopefully (0,0)) so the graph doesn't jump when
# its height changes. Unfortunately, pygraphviz has a bug a gives
# the wrong bbox, so we compute the max y coord.
# bbox = pygraphviz.graphviz.agget(g.handle,'bb')
global y_origin
y_origin = 0.0
for n in g.nodes():
top = float(n.attr["pos"].split(",")[1]) + float(n.attr["height"]) / 2
if top > y_origin:
y_origin = top
if subgraph_boxes:
for sg in g.subgraphs():
top = float(sg.graph_attr["bb"].split(",")[3])
if top > y_origin:
y_origin = top
for e in elements:
if e["group"] == "nodes" and e["classes"] != "non_existing":
attr = g.get_node(e["data"]["id"]).attr
e["position"] = _to_position(attr["pos"])
e["data"]["width"] = 72 * float(attr["width"])
e["data"]["height"] = 72 * float(attr["height"])
elif e["group"] == "edges":
if node_gt(e["data"]["source"], e["data"]["target"]):
attr = g.get_edge(e["data"]["target"], e["data"]["source"], e["data"]["id"]).attr
pos = attr["pos"]
pe = pos.split()
ppe = pe[1:]
ppe.reverse()
pos = " ".join([pe[0].replace("s", "e")] + ppe)
else:
attr = g.get_edge(e["data"]["source"], e["data"]["target"], e["data"]["id"]).attr
pos = attr["pos"]
e["data"].update(_to_edge_position(pos))
if edge_labels and e["data"]["label"] != "":
e["data"]["lp"] = _to_position(attr["lp"])
# g.draw('g.png')
if subgraph_boxes:
for sg in g.subgraphs():
box = cy_elements.add_shape(sg.name, classes="subgraphs")
coords = _to_coord_list(sg.graph_attr["bb"])
box["data"]["coords"] = coords
return cy_elements
def dot_layout(cy_elements):
"""
Get a CyElements object and augment it (in-place) with positions,
widths, heights, and spline data from a dot based layout.
Returns the object.
"""
elements = cy_elements.elements
g = AGraph(directed=True, strict=False)
# make transitive relations appear top to bottom
# TODO: make this not specific to leader example
elements = list(elements)
nodes_by_id = dict(
(e["data"]["id"], e) for e in elements if e["group"] == "nodes")
order = [(nodes_by_id[e["data"]["source"]],
nodes_by_id[e["data"]["target"]]) for e in elements
if e["group"] == "edges" and e["data"]["obj"] in ('reach', 'le')]
elements = topological_sort(elements, order, lambda e: e["data"]["id"])
# add nodes to the graph
for e in elements:
if e["group"] == "nodes":
g.add_node(e["data"]["id"],
label=e["data"]["label"].replace('\n', '\\n'))
# TODO: remove this, it's specific to leader_demo
weight = {
'reach': 10,
'le': 10,
'id': 1,
}
constraint = {
'pending': False,
}
# add edges to the graph
for e in elements:
if e["group"] == "edges":
g.add_edge(
e["data"]["source"],
e["data"]["target"],
e["data"]["id"],
weight=weight.get(e["data"]["obj"], 0),
#constraint=constraint.get(e["data"]["obj"], True),
)
# add clusters
clusters = defaultdict(list)
for e in elements:
if e["group"] == "nodes" and e["data"]["cluster"] is not None:
clusters[e["data"]["cluster"]].append(e["data"]["id"])
for i, k in enumerate(sorted(clusters.keys())):
g.add_subgraph(
name='cluster_{}'.format(i),
nbunch=clusters[k],
)
# now get positions, heights, widths, and bsplines
g.layout(prog='dot')
for e in elements:
if e["group"] == "nodes":
attr = g.get_node(e["data"]["id"]).attr
e["position"] = _to_position(attr['pos'])
e["data"]["width"] = 72 * float(attr['width'])
e["data"]["height"] = 72 * float(attr['height'])
elif e["group"] == "edges":
attr = g.get_edge(e["data"]["source"], e["data"]["target"],
e["data"]["id"]).attr
e["data"].update(_to_edge_position(attr['pos']))
g.draw('g.png')
return cy_elements
def dot_layout(cy_elements,
edge_labels=False,
subgraph_boxes=False,
node_gt=None):
"""
Get a CyElements object and augment it (in-place) with positions,
widths, heights, and spline data from a dot based layout.
edge_labels is true if labels should appear on edges
subgraph_boxes is true if boxes should be drawn around subgraphs
Returns the object.
"""
elements = cy_elements.elements
# g = AGraph(directed=True, strict=False)
g = AGraph(directed=True, strict=False, forcelabels=True)
# make transitive relations appear top to bottom
elements = list(elements)
nodes_by_id = dict(
(e["data"]["id"], e) for e in elements if e["group"] == "nodes")
order = [(nodes_by_id[e["data"]["source"]],
nodes_by_id[e["data"]["target"]]) for e in elements
if e["group"] == "edges" and "transitive" in e["data"]
and e["data"]["transitive"]]
elements = topological_sort(elements, order, lambda e: e["data"]["id"])
# get the node id's and stable sort them by cluster
# the idea here is to convert the graph into a dag by sorting
# the nodes, then reversing the back edges. In particular, we try to make
# all the edges between two clusters go in the same direction so clustering
# doesn't result in horizontal edges, which dot renders badly.
sorted_nodes = [e["data"]["id"] for e in elements if e["group"] == "nodes"]
sorted_nodes = sorted(enumerate(sorted_nodes),
key=lambda x:
(nodes_by_id[x[1]]["data"]["cluster"], x[0]))
sorted_nodes = [y for idx, y in sorted_nodes]
node_key = dict((id, idx) for idx, id in enumerate(sorted_nodes))
if node_gt is None:
node_gt = lambda X, y: False
else:
node_gt = lambda x, y: node_key[x] > node_key[y]
# add nodes to the graph
for e in elements:
if e["group"] == "nodes" and e["classes"] != 'non_existing':
g.add_node(e["data"]["id"],
label=e["data"]["label"].replace('\n', '\\n'))
# TODO: remove this, it's specific to leader_demo
weight = {
'reach': 10,
'le': 10,
'id': 1,
}
constraint = {
'pending': False,
}
# add edges to the graph
for e in elements:
if e["group"] == "edges":
# kwargs = {'weight': weight.get(e["data"]["obj"], 0)},
kwargs = {'label': e["data"]["label"]} if edge_labels else {}
if node_gt(e["data"]["source"], e["data"]["target"]):
g.add_edge(e["data"]["target"],
e["data"]["source"],
e["data"]["id"],
dir='back',
**kwargs
#constraint=constraint.get(e["data"]["obj"], True),
)
else:
g.add_edge(e["data"]["source"], e["data"]["target"],
e["data"]["id"], **kwargs
#constraint=constraint.get(e["data"]["obj"], True),
)
# add clusters
clusters = defaultdict(list)
for e in elements:
if e["group"] == "nodes" and e["data"][
"cluster"] is not None and e["classes"] != 'non_existing':
clusters[e["data"]["cluster"]].append(e["data"]["id"])
for i, k in enumerate(sorted(clusters.keys())):
g.add_subgraph(
name='cluster_{}'.format(i),
nbunch=clusters[k],
rank='min',
)
# now get positions, heights, widths, and bsplines
g.layout(prog='dot')
# get the y origin. we want the top left of the graph to be a
# fixed coordinate (hopefully (0,0)) so the graph doesn't jump when
# its height changes. Unfortunately, pygraphviz has a bug a gives
# the wrong bbox, so we compute the max y coord.
# bbox = pygraphviz.graphviz.agget(g.handle,'bb')
global y_origin
y_origin = 0.0
for n in g.nodes():
top = float(n.attr['pos'].split(',')[1]) + float(n.attr['height']) / 2
if top > y_origin:
y_origin = top
if subgraph_boxes:
for sg in g.subgraphs():
top = float(sg.graph_attr['bb'].split(',')[3])
if top > y_origin:
y_origin = top
for e in elements:
if e["group"] == "nodes" and e["classes"] != 'non_existing':
attr = g.get_node(e["data"]["id"]).attr
e["position"] = _to_position(attr['pos'])
e["data"]["width"] = 72 * float(attr['width'])
e["data"]["height"] = 72 * float(attr['height'])
elif e["group"] == "edges":
if node_gt(e["data"]["source"], e["data"]["target"]):
attr = g.get_edge(e["data"]["target"], e["data"]["source"],
e["data"]["id"]).attr
pos = attr['pos']
pe = pos.split()
ppe = pe[1:]
ppe.reverse()
pos = ' '.join([pe[0].replace('s', 'e')] + ppe)
else:
attr = g.get_edge(e["data"]["source"], e["data"]["target"],
e["data"]["id"]).attr
pos = attr['pos']
e["data"].update(_to_edge_position(pos))
if edge_labels and e["data"]["label"] != '':
e["data"]["lp"] = _to_position(attr['lp'])
# g.draw('g.png')
if subgraph_boxes:
for sg in g.subgraphs():
box = cy_elements.add_shape(sg.name, classes='subgraphs')
coords = _to_coord_list(sg.graph_attr['bb'])
box["data"]["coords"] = coords
return cy_elements
def dot_layout(cy_elements):
"""
Get a CyElements object and augment it (in-place) with positions,
widths, heights, and spline data from a dot based layout.
Returns the object.
"""
elements = cy_elements.elements
g = AGraph(directed=True, strict=False)
# make transitive relations appear top to bottom
# TODO: make this not specific to leader example
elements = list(elements)
nodes_by_id = dict(
(e["data"]["id"], e)
for e in elements if e["group"] == "nodes"
)
order = [
(nodes_by_id[e["data"]["source"]], nodes_by_id[e["data"]["target"]])
for e in elements if
e["group"] == "edges" and
e["data"]["obj"] in ('reach', 'le')
]
elements = topological_sort(elements, order, lambda e: e["data"]["id"])
# add nodes to the graph
for e in elements:
if e["group"] == "nodes":
g.add_node(e["data"]["id"], label=e["data"]["label"].replace('\n', '\\n'))
# TODO: remove this, it's specific to leader_demo
weight = {
'reach': 10,
'le': 10,
'id': 1,
}
constraint = {
'pending': False,
}
# add edges to the graph
for e in elements:
if e["group"] == "edges":
g.add_edge(
e["data"]["source"],
e["data"]["target"],
e["data"]["id"],
weight=weight.get(e["data"]["obj"], 0),
#constraint=constraint.get(e["data"]["obj"], True),
)
# add clusters
clusters = defaultdict(list)
for e in elements:
if e["group"] == "nodes" and e["data"]["cluster"] is not None:
clusters[e["data"]["cluster"]].append(e["data"]["id"])
for i, k in enumerate(sorted(clusters.keys())):
g.add_subgraph(
name='cluster_{}'.format(i),
nbunch=clusters[k],
)
# now get positions, heights, widths, and bsplines
g.layout(prog='dot')
for e in elements:
if e["group"] == "nodes":
attr = g.get_node(e["data"]["id"]).attr
e["position"] = _to_position(attr['pos'])
e["data"]["width"] = 72 * float(attr['width'])
e["data"]["height"] = 72 * float(attr['height'])
elif e["group"] == "edges":
attr = g.get_edge(e["data"]["source"], e["data"]["target"], e["data"]["id"]).attr
e["data"].update(_to_edge_position(attr['pos']))
g.draw('g.png')
return cy_elements