def dot_to_json(file_in, file_out, indent=1):
import json
try:
import networkx
import pygraphviz
from networkx.readwrite import json_graph
except ImportError:
print("Install pygraphviz and networkx:")
print("sudo apt-get install python-pygraphviz python-networkx")
return 1
graph_dot = pygraphviz.AGraph( file_in )
graph_netx = networkx.from_agraph( graph_dot )
graph_json = json_graph.node_link_data( graph_netx )
# fix formatting [graphviz to d3.js]
for node in graph_json["nodes"]:
# replace label by name
node['name'] = node.pop('label')
# id from string to integer
node['id'] = int(node['id'])
with open(file_out, 'w') as f:
json.dump(graph_json, f, indent=indent)
return 0
def __init__(self, topology_file = "gates_topology.dot"):
frenetic.App.__init__(self)
logging.info("---> Reading Topology from "+topology_file)
self.agraph = pgv.AGraph(topology_file)
for sw in self.agraph.nodes():
dpid = str(sw.attr['dpid'])
self.dpid_to_switch_dict[ dpid ] = str(sw)
self.switch_to_dpid_dict[ str(sw) ] = dpid
if sw.attr['core']:
self.core_switches.add (str(sw))
# It's faster to denormalize this now
logging.info("---> Remembering internal ports")
self.switch_internal_ports = { sw: set([]) for sw in self.switch_to_dpid_dict }
for e in self.agraph.edges():
source_sw = str(e[0])
dest_sw = str(e[1])
source_port = int(e.attr["src_port"])
dest_port = int(e.attr["dport"])
self.switch_internal_ports[ source_sw ].add( source_port )
if source_sw not in self.port_mappings:
self.port_mappings[source_sw] = {}
self.port_mappings[source_sw][dest_sw] = source_port
self.switch_internal_ports[ dest_sw ].add( dest_port )
if dest_sw not in self.port_mappings:
self.port_mappings[dest_sw] = {}
self.port_mappings[dest_sw][source_sw] = dest_port
logging.info("---> Calculating spanning tree")
nxgraph = nx.from_agraph(self.agraph)
self.nx_topo = nx.minimum_spanning_tree(nxgraph)
def draw_lineage(self, recs, nodecolor="mediumseagreen",
edgecolor="lightslateblue", dpi=96,
lineage_img="GO_lineage.png", engine="pygraphviz",
gml=False, draw_parents=True, draw_children=True):
"""Draw GO DAG subplot."""
assert engine in GraphEngines
grph = None
if engine == "pygraphviz":
grph = self.make_graph_pygraphviz(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents,
draw_children=draw_children)
else:
grph = self.make_graph_pydot(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents, draw_children=draw_children)
if gml:
import networkx as nx # use networkx to do the conversion
gmlbase = lineage_img.rsplit(".", 1)[0]
NG = nx.from_agraph(grph) if engine == "pygraphviz" else nx.from_pydot(grph)
del NG.graph['node']
del NG.graph['edge']
gmlfile = gmlbase + ".gml"
nx.write_gml(Nself._label_wrapG, gmlfile)
sys.stderr.write("GML graph written to {0}\n".format(gmlfile))
sys.stderr.write(("lineage info for terms %s written to %s\n" %
([rec.id for rec in recs], lineage_img)))
if engine == "pygraphviz":
grph.draw(lineage_img, prog="dot")
else:
grph.write_png(lineage_img)
def draw_lineage(self, recs, nodecolor="mediumseagreen",
edgecolor="lightslateblue", dpi=96,
lineage_img="GO_lineage.png", engine="pygraphviz",
gml=False, draw_parents=True, draw_children=True):
assert engine in GraphEngines
if engine == "pygraphviz":
G = self.make_graph_pygraphviz(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents, draw_children=draw_children)
else:
G = self.make_graph_pydot(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents, draw_children=draw_children)
if gml:
import networkx as nx # use networkx to do the conversion
pf = lineage_img.rsplit(".", 1)[0]
NG = nx.from_agraph(G) if engine == "pygraphviz" else nx.from_pydot(G)
del NG.graph['node']
del NG.graph['edge']
gmlfile = pf + ".gml"
nx.write_gml(NG, gmlfile)
print("GML graph written to {0}".format(gmlfile), file=sys.stderr)
print(("lineage info for terms %s written to %s" %
([rec.id for rec in recs], lineage_img)), file=sys.stderr)
if engine == "pygraphviz":
G.draw(lineage_img, prog="dot")
else:
G.write_png(lineage_img)
def draw_lineage(self, recs, nodecolor="mediumseagreen",
edgecolor="lightslateblue", dpi=96,
lineage_img="GO_lineage.png", engine="pygraphviz",
gml=False, draw_parents=True, draw_children=True):
assert engine in GraphEngines
if engine == "pygraphviz":
G = self.make_graph_pygraphviz(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents, draw_children=draw_children)
else:
G = self.make_graph_pydot(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents, draw_children=draw_children)
if gml:
import networkx as nx # use networkx to do the conversion
pf = lineage_img.rsplit(".", 1)[0]
NG = nx.from_agraph(G) if engine == "pygraphviz" else nx.from_pydot(G)
del NG.graph['node']
del NG.graph['edge']
gmlfile = pf + ".gml"
nx.write_gml(NG, gmlfile)
print("GML graph written to {0}".format(gmlfile), file=sys.stderr)
print(("lineage info for terms %s written to %s" %
([rec.id for rec in recs], lineage_img)), file=sys.stderr)
if engine == "pygraphviz":
G.draw(lineage_img, prog="dot")
else:
G.write_png(lineage_img)
def draw_lineage(self, recs, nodecolor="mediumseagreen",
edgecolor="lightslateblue", dpi=96,
lineage_img="GO_lineage.png", engine="pygraphviz",
gml=False, draw_parents=True, draw_children=True):
"""Draw GO DAG subplot."""
assert engine in GraphEngines
grph = None
if engine == "pygraphviz":
grph = self.make_graph_pygraphviz(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents,
draw_children=draw_children)
else:
grph = self.make_graph_pydot(recs, nodecolor, edgecolor, dpi,
draw_parents=draw_parents, draw_children=draw_children)
if gml:
import networkx as nx # use networkx to do the conversion
gmlbase = lineage_img.rsplit(".", 1)[0]
obj = nx.from_agraph(grph) if engine == "pygraphviz" else nx.from_pydot(grph)
del obj.graph['node']
del obj.graph['edge']
gmlfile = gmlbase + ".gml"
nx.write_gml(self.label_wrap, gmlfile)
sys.stderr.write("GML graph written to {0}\n".format(gmlfile))
sys.stderr.write(("lineage info for terms %s written to %s\n" %
([rec.item_id for rec in recs], lineage_img)))
if engine == "pygraphviz":
grph.draw(lineage_img, prog="dot")
else:
grph.write_png(lineage_img)
def draw_lineage(self,
recs,
nodecolor="mediumseagreen",
edgecolor="lightslateblue",
dpi=96,
lineage_img="GO_lineage.png",
gml=False):
# draw AMIGO style network, lineage containing one query record
try:
import pygraphviz as pgv
except:
logging.error("pygraphviz not installed, lineage not drawn!")
logging.error("try `easy_install pygraphviz`")
return
G = pgv.AGraph()
edgeset = set()
for rec in recs:
edgeset.update(rec.get_all_parent_edges())
edgeset.update(rec.get_all_child_edges())
edgeset = [(self._label_wrap(a), self._label_wrap(b))
for (a, b) in edgeset]
for src, target in edgeset:
# default layout in graphviz is top->bottom, so we invert
# the direction and plot using dir="back"
G.add_edge(target, src)
G.graph_attr.update(dpi="%d" % dpi)
G.node_attr.update(shape="box",
style="rounded,filled",
fillcolor="beige",
color=nodecolor)
G.edge_attr.update(shape="normal",
color=edgecolor,
dir="back",
label="is_a")
# highlight the query terms
for rec in recs:
try:
q = G.get_node(self._label_wrap(rec.id))
q.attr.update(fillcolor="plum")
except:
continue
if gml:
import networkx as nx # use networkx to do the conversion
pf = lineage_img.rsplit(".", 1)[0]
G.name = "GO tree"
NG = nx.from_agraph(G)
del NG.graph['node']
del NG.graph['edge']
gmlfile = pf + ".gml"
nx.write_gml(NG, gmlfile)
logging.info("lineage info for terms %s written to %s" %
([rec.id for rec in recs], lineage_img))
G.draw(lineage_img, prog="dot")
def drawPlot(self):
a = nx.to_agraph(self.g)
self.g = nx.from_agraph(a)
self.fig = pylab.figure()
nx.draw_graphviz(self.g, prog='neato')
plt.savefig("path.png")
self.image.set_from_file("path.png")
def handleTopology(self, rpc):
dotStr = rpc.Extensions[Topology.msg].dot
pyGraph = pydot.graph_from_dot_data(dotStr)
aGraph = pygraphviz.AGraph(string = dotStr)
self.graph = networkx.from_agraph(aGraph)
for node in pyGraph.get_nodes():
self.attr[node.get_name()] = node.obj_dict['attributes']
def test_graphviz():
G=nx.complete_graph(5) # start with K5 in networkx
A=nx.to_agraph(G) # convert to a graphviz graph
X1=nx.from_agraph(A) # convert back to networkx (but as Graph)
X2=nx.Graph(A) # fancy way to do conversion
G1=nx.Graph(X1) # now make it a Graph
A.write('k5.dot') # write to dot file
X3=nx.read_dot('k5.dot') # read from dotfile
pass
def draw_lineage(
self,
recs,
nodecolor="mediumseagreen",
edgecolor="lightslateblue",
dpi=96,
lineage_img="GO_lineage.png",
gml=False,
):
# draw AMIGO style network, lineage containing one query record
try:
import pygraphviz as pgv
except:
print >>sys.stderr, "pygraphviz not installed, lineage not drawn!"
print >>sys.stderr, "try `easy_install pygraphviz`"
return
G = pgv.AGraph()
edgeset = set()
for rec in recs:
edgeset.update(rec.get_all_parent_edges())
edgeset.update(rec.get_all_child_edges())
edgeset = [(self._label_wrap(a), self._label_wrap(b)) for (a, b) in edgeset]
for src, target in edgeset:
# default layout in graphviz is top->bottom, so we invert
# the direction and plot using dir="back"
G.add_edge(target, src)
G.graph_attr.update(dpi="%d" % dpi)
G.node_attr.update(shape="box", style="rounded,filled", fillcolor="beige", color=nodecolor)
G.edge_attr.update(shape="normal", color=edgecolor, dir="back", label="is_a")
# highlight the query terms
for rec in recs:
try:
q = G.get_node(self._label_wrap(rec.id))
q.attr.update(fillcolor="plum")
except:
continue
if gml:
import networkx as nx # use networkx to do the conversion
pf = lineage_img.rsplit(".", 1)[0]
G.name = "GO tree"
NG = nx.from_agraph(G)
del NG.graph["node"]
del NG.graph["edge"]
gmlfile = pf + ".gml"
nx.write_gml(NG, gmlfile)
print >>sys.stderr, ("lineage info for terms %s written to %s" % ([rec.id for rec in recs], lineage_img))
G.draw(lineage_img, prog="dot")
def __init__(self, logger, topology_file="multiswitch_topo.dot"):
self.logger = logger
self.logger.info("---> Reading Topology from "+topology_file)
self.agraph = pgv.AGraph(topology_file)
# It's faster to denormalize this now
self.logger.info("---> Remembering internal ports")
switches = [ int(sw) for sw in self.agraph.nodes()]
for e in self.agraph.edges():
# Parse the source and destination switches
source_dpid = int(e[0])
dest_dpid = int(e[1])
source_port = int(e.attr["src_port"])
dest_port = int(e.attr["dport"])
# Add a mapping for the forward directions source->dest
self.add_port_mapping(source_dpid, dest_dpid, source_port)
# Add a mapping for the reverse direction dest->source
self.add_port_mapping(dest_dpid, source_dpid, dest_port)
# Calculate the core/edge attribute. Edge switches have only one
# connection to another switch
for sw in self.port_mappings:
if len(self.port_mappings[sw]) == 1:
self.edge_switches.add(sw)
# Edge switches have only one entry in port_mappings[dpid], so we get it here
connected_sw = self.port_mappings[sw].keys()[0]
self.uplink_port[sw] = self.port_mappings[sw][connected_sw]
else:
self.core_switches.add(sw)
self.logger.info("---> Calculating spanning tree")
nxgraph = nx.from_agraph(self.agraph)
self.nx_topo = nx.minimum_spanning_tree(nxgraph)
nx.write_edgelist(self.nx_topo, sys.stdout)
self.logger.info("---> Enabling only those ports on the spanning tree")
for (from_dpid, to_dpid) in self.nx_topo.edges():
# We look up the port mapping from the port-mapping dictionary instead of
# from the graph attributes because NetworkX flips the src and dest node
# arbitrarily in an undirected graph
from_dpid_int = int(from_dpid)
to_dpid_int = int(to_dpid)
from_port = self.port_mappings[from_dpid_int][to_dpid_int]
if from_dpid_int not in self.enabled_ports:
self.enabled_ports[from_dpid_int] = []
self.enabled_ports[from_dpid_int].append(from_port)
to_port = self.port_mappings[to_dpid_int][from_dpid_int]
if to_dpid_int not in self.enabled_ports:
self.enabled_ports[to_dpid_int] = []
self.enabled_ports[to_dpid_int].append(to_port)
def __init__(self, logger, topology_file="multiswitch_topo.dot"):
self.logger = logger
self.logger.info("---> Reading Topology from " + topology_file)
self.agraph = pgv.AGraph(topology_file)
# It's faster to denormalize this now
self.logger.info("---> Remembering internal ports")
switches = [int(sw) for sw in self.agraph.nodes()]
for e in self.agraph.edges():
# Parse the source and destination switches
source_dpid = int(e[0])
dest_dpid = int(e[1])
source_port = int(e.attr["src_port"])
dest_port = int(e.attr["dport"])
# Add a mapping for the forward directions source->dest
self.add_port_mapping(source_dpid, dest_dpid, source_port)
# Add a mapping for the reverse direction dest->source
self.add_port_mapping(dest_dpid, source_dpid, dest_port)
# Calculate the core/edge attribute. Edge switches have only one
# connection to another switch
for sw in self.port_mappings:
if len(self.port_mappings[sw]) == 1:
self.edge_switches.add(sw)
# Edge switches have only one entry in port_mappings[dpid], so we get it here
connected_sw = self.port_mappings[sw].keys()[0]
self.uplink_port[sw] = self.port_mappings[sw][connected_sw]
else:
self.core_switches.add(sw)
self.logger.info("---> Calculating spanning tree")
nxgraph = nx.from_agraph(self.agraph)
self.nx_topo = nx.minimum_spanning_tree(nxgraph)
nx.write_edgelist(self.nx_topo, sys.stdout)
self.logger.info("---> Enabling only those ports on the spanning tree")
for (from_dpid, to_dpid) in self.nx_topo.edges():
# We look up the port mapping from the port-mapping dictionary instead of
# from the graph attributes because NetworkX flips the src and dest node
# arbitrarily in an undirected graph
from_dpid_int = int(from_dpid)
to_dpid_int = int(to_dpid)
from_port = self.port_mappings[from_dpid_int][to_dpid_int]
if from_dpid_int not in self.enabled_ports:
self.enabled_ports[from_dpid_int] = []
self.enabled_ports[from_dpid_int].append(from_port)
to_port = self.port_mappings[to_dpid_int][from_dpid_int]
if to_dpid_int not in self.enabled_ports:
self.enabled_ports[to_dpid_int] = []
self.enabled_ports[to_dpid_int].append(to_port)
def topo_parser(filename):
"""Parse dot lanague defined topologies and return a parsed graph.
Keyword Arguments:
------------------
filename -- .dot file for a defined topology.
Returns:
--------
graph -- networkx graph, see networkx.
"""
agraph = pgv.AGraph(filename)
G = nx.from_agraph(agraph)
G.name = agraph.graph_attr['label']
return G
def topo_parser(filename):
"""Parse dot lanague defined topologies and return a parsed graph.
Keyword Arguments:
------------------
filename -- .dot file for a defined topology.
Returns:
--------
graph -- networkx graph, see networkx.
"""
agraph = pgv.AGraph(filename)
G = nx.from_agraph(agraph)
G.name = agraph.graph_attr['label']
return G
def addScan(self, mech, fileName, newDate):
if self.myCrypto.disabled:
newScan = scan(network=self.pluginName, time=newDate)
else:
newScan = scan(network=self.pluginName, time=newDate,
encrypted=True)
try:
topoFile = mech.retrieve(fileName)
except:
self.logger.error("Could not retrieve file "+fileName)
return
try:
f = gzip.open(topoFile[0])
except:
self.logger.error("Could not open temporary file "+topoFile[0])
return
graphString = ""
for l in f:
graphString += l
G = pg.AGraph(encoding='UTF-8')
Ga = G.from_string(graphString)
pG = nx.from_agraph(Ga)
# note that FFGraz nodes are taken from the .dot file,
# so we don't have numerical IDs. In the DB the node_Id
# will be just the node name
toBeRemoved = []
for e in pG.edges(data=True):
if str(e[2]['label']) != 'HNA':
if e[2]['label'] == 'INFINITE':
e[2]['weight'] = 1000
else:
e[2]['weight'] = float(e[2]['label'])
else:
toBeRemoved.append([e[0], e[1]])
for l in toBeRemoved:
pG.remove_edge(l[0], l[1])
simpleG = self.aggregateNodesByName(pG)
for e in simpleG.edges():
if e[0] == e[1]:
simpleG.remove_edge(e[0], e[1])
newFile = topo_file(file_url=fileName, scan_Id_r=newScan, time=newDate)
self.localSession.add(newFile)
#FIXME NEed to add owners and emails here
addGraphToDB(simpleG, self.localSession, newScan, self.myCrypto)
f.close()
os.remove(topoFile[0])
def draw_ugraph(k, fname, report):
""" actually build a graph
#A.graph_attr['label']='known universe topology'
#nx.draw_random(G) #nx.draw_circular(G)
#nx.draw_graphviz(G) #nx.write_dot(G,'file.dot')
#nx.draw(A) #nx.draw_random(G) #nx.draw_spectral(G)
"""
import networkx as nx
from pygraphviz import *
G = nx.Graph()
G.add_edges_from(k)
A=nx.to_agraph(G)
H = nx.from_agraph(A)
A.edge_attr['color']='red'
A.layout()
A.draw(fname)
def consensus_network_image(self, net, outfile, cm, node_positions):
def colorize_edge(weight):
colors = "9876543210"
breakpoints = [.1, .2, .3, .4, .5, .6, .7, .8, .9]
return "#" + str(colors[bisect(breakpoints, weight)]) * 6
def node(n, position):
s = "\t\"%s\"" % n.name
if position:
x, y = position
s += " [pos=\"%d,%d\"]" % (x, y)
return s + ";"
nodes = net.nodes
positions = node_positions
dotstr = "\n".join(
["digraph G {"] +
[node(n, pos) for n,pos in zip(nodes, positions)] +
["\t\"%s\" -> \"%s\" [color=\"%s\"];" % \
(nodes[src].name, nodes[dest].name, colorize_edge(cm[src][dest])) \
for src,dest in net.edges
] +
["}"]
)
fd, fname = tempfile.mkstemp()
open(fname, 'w').write(dotstr)
# needless repitition of network.as_gml() here:
A = AGraph()
net = A.from_string(string=dotstr)
G = nx.from_agraph(net)
nx.write_gml(G, outfile.replace(".png", ".gml"))
os.system("dot -n1 -Tpng -o%s %s" % (outfile, fname))
os.system("dot -n1 -Tsvg -o%s %s" %
(outfile.replace(".png", ".svg"), fname))
os.remove(fname)
def agraph_checks(self, G):
G = self.build_graph(G)
A = nx.to_agraph(G)
H = nx.from_agraph(A)
self.assert_equal(G, H)
fname = tempfile.mktemp()
nx.drawing.nx_agraph.write_dot(H, fname)
Hin = nx.drawing.nx_agraph.read_dot(fname)
os.unlink(fname)
self.assert_equal(H, Hin)
(fd, fname) = tempfile.mkstemp()
fh = open(fname, 'w')
nx.drawing.nx_agraph.write_dot(H, fh)
fh.close()
fh = open(fname, 'r')
Hin = nx.drawing.nx_agraph.read_dot(fh)
fh.close()
os.unlink(fname)
self.assert_equal(H, Hin)
def agraph_checks(self, G):
G = self.build_graph(G)
A=nx.to_agraph(G)
H=nx.from_agraph(A)
self.assert_equal(G, H)
fname=tempfile.mktemp()
nx.drawing.nx_agraph.write_dot(H,fname)
Hin=nx.drawing.nx_agraph.read_dot(fname)
os.unlink(fname)
self.assert_equal(H,Hin)
(fd,fname)=tempfile.mkstemp()
fh=open(fname,'w')
nx.drawing.nx_agraph.write_dot(H,fh)
fh.close()
fh=open(fname,'r')
Hin=nx.drawing.nx_agraph.read_dot(fh)
fh.close()
os.unlink(fname)
self.assert_equal(H,Hin)
def draw_network(graph,sg=None):
G = nx.from_agraph(graph)
pos=nx.spring_layout(G)
ax=plt.gca()
ax.set_xmargin(0.25)
ax.set_ymargin(0.25)
ax.autoscale()
plt.axis('equal')
plt.axis('off')
for n in G:
c=Circle(pos[n],radius=0.05,alpha=0.5)
ax.add_patch(c)
ax.text(pos[n][0]+0.15, pos[n][1], n, verticalalignment='center')
G.node[n]['patch']=c
x,y=pos[n]
seen={}
for (u,v,d) in G.edges(data=True):
n1=G.node[u]['patch']
n2=G.node[v]['patch']
rad=random.random()
if (u,v) in seen:
rad=seen.get((u,v))
rad=(rad+np.sign(rad)*0.1)*-1
alpha=0.5
color='k'
e = FancyArrowPatch(n1.center,n2.center,patchA=n1,patchB=n2,
arrowstyle='-|>',
connectionstyle='arc3,rad=%s'%rad,
mutation_scale=10.0,
lw=2,
alpha=alpha,
color=color)
seen[(u,v)]=rad
ax.add_patch(e)
def tred(graph):
A=nx.to_agraph(graph)
I=A.tred(copy=true)
new_graph=nx.from_agraph(I)
return new_graph
def test_from_agraph_name(self):
G=nx.Graph(name='test')
A=nx.to_agraph(G)
H=nx.from_agraph(A)
assert_equal(G.name,'test')
def test_from_agraph_name(self):
G = nx.Graph(name='test')
A = nx.to_agraph(G)
H = nx.from_agraph(A)
assert_equal(G.name, 'test')
def to_networkx_graph(data, create_using=None, multigraph_input=False):
"""Make a NetworkX graph from a known data structure.
The preferred way to call this is automatically
from the class constructor
>>> d={0: {1: {'weight':1}}} # dict-of-dicts single edge (0,1)
>>> G=nx.Graph(d)
instead of the equivalent
>>> G=nx.from_dict_of_dicts(d)
Parameters
----------
data : a object to be converted
Current known types are:
any NetworkX graph
dict-of-dicts
dist-of-lists
list of edges
numpy matrix
numpy ndarray
scipy sparse matrix
pygraphviz agraph
create_using : NetworkX graph
Use specified graph for result. Otherwise a new graph is created.
multigraph_input : bool (default False)
If True and data is a dict_of_dicts,
try to create a multigraph assuming dict_of_dict_of_lists.
If data and create_using are both multigraphs then create
a multigraph from a multigraph.
"""
# NX graph
if hasattr(data, "adj"):
try:
result= from_dict_of_dicts(data.adj,\
create_using=create_using,\
multigraph_input=data.is_multigraph())
if hasattr(data, 'graph') and isinstance(data.graph, dict):
result.graph = data.graph.copy()
if hasattr(data, 'node') and isinstance(data.node, dict):
result.node = dict(
(n, dd.copy()) for n, dd in data.node.items())
return result
except:
raise nx.NetworkXError("Input is not a correct NetworkX graph.")
# pygraphviz agraph
if hasattr(data, "is_strict"):
try:
return nx.from_agraph(data, create_using=create_using)
except:
raise nx.NetworkXError("Input is not a correct pygraphviz graph.")
# dict of dicts/lists
if isinstance(data, dict):
try:
return from_dict_of_dicts(data,create_using=create_using,\
multigraph_input=multigraph_input)
except:
try:
return from_dict_of_lists(data, create_using=create_using)
except:
raise TypeError("Input is not known type.")
# list or generator of edges
if (isinstance(data, list) or hasattr(data, 'next')
or hasattr(data, '__next__')):
try:
return from_edgelist(data, create_using=create_using)
except:
raise nx.NetworkXError("Input is not a valid edge list")
# numpy matrix or ndarray
try:
import numpy
if isinstance(data,numpy.matrix) or \
isinstance(data,numpy.ndarray):
try:
return from_numpy_matrix(data, create_using=create_using)
except:
raise nx.NetworkXError(\
"Input is not a correct numpy matrix or array.")
except ImportError:
warnings.warn('numpy not found, skipping conversion test.',
ImportWarning)
# scipy sparse matrix - any format
try:
import scipy
if hasattr(data, "format"):
try:
return from_scipy_sparse_matrix(data,
create_using=create_using)
except:
raise nx.NetworkXError(\
"Input is not a correct scipy sparse matrix type.")
except ImportError:
warnings.warn('scipy not found, skipping conversion test.',
ImportWarning)
raise nx.NetworkXError(\
"Input is not a known data type for conversion.")
return
def from_whatever(thing, create_using=None, multigraph_input=False):
"""Make a NetworkX graph from an known type.
The preferred way to call this is automatically
from the class constructor
>>> d={0: {1: {'weight':1}}} # dict-of-dicts single edge (0,1)
>>> G=nx.Graph(d)
instead of the equivalent
>>> G=nx.from_dict_of_dicts(d)
Parameters
----------
thing : a object to be converted
Current known types are:
any NetworkX graph
dict-of-dicts
dist-of-lists
list of edges
numpy matrix
numpy ndarray
scipy sparse matrix
pygraphviz agraph
create_using : NetworkX graph
Use specified graph for result. Otherwise a new graph is created.
multigraph_input : bool (default False)
If True and thing is a dict_of_dicts,
try to create a multigraph assuming dict_of_dict_of_lists.
If thing and create_using are both multigraphs then create
a multigraph from a multigraph.
"""
# NX graph
if hasattr(thing, "adj"):
try:
result= from_dict_of_dicts(thing.adj,\
create_using=create_using,\
multigraph_input=thing.is_multigraph())
if hasattr(thing, 'graph') and isinstance(thing.graph, dict):
result.graph = thing.graph.copy()
if hasattr(thing, 'node') and isinstance(thing.node, dict):
result.node = dict(
(n, dd.copy()) for n, dd in thing.node.iteritems())
return result
except:
raise networkx.NetworkXError,\
"Input is not a correct NetworkX graph."
# pygraphviz agraph
if hasattr(thing, "is_strict"):
try:
return networkx.from_agraph(thing, create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct pygraphviz graph."
# dict of dicts/lists
if isinstance(thing, dict):
try:
return from_dict_of_dicts(thing,create_using=create_using,\
multigraph_input=multigraph_input)
except:
try:
return from_dict_of_lists(thing, create_using=create_using)
except:
raise TypeError("Input is not known type.")
# list or generator of edges
if isinstance(thing, list) or hasattr(thing, 'next'):
try:
return from_edgelist(thing, create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a valid edge list"
# numpy matrix or ndarray
# try:
# import numpy
if isinstance(thing,numpy.core.defmatrix.matrix) or \
isinstance(thing,numpy.ndarray):
try:
return from_numpy_matrix(thing, create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct numpy matrix or array."
# except ImportError:
# pass # fail silently
# scipy sparse matrix - any format
# try:
# import scipy
if hasattr(thing, "format"):
try:
return from_scipy_sparse_matrix(thing, create_using=create_using)
except:
raise networkx.NetworkXError, \
"Input is not a correct scipy sparse matrix type."
# except ImportError:
# pass # fail silently
raise networkx.NetworkXError, \
"Input is not a known data type for conversion."
return
def read_dot_file(self, filename): graph = pgv.AGraph(filename) network = nx.Graph(nx.from_agraph(graph)) mapping = dict([(n,int(n)) for n in network.nodes()]) result = nx.relabel_nodes(network, mapping) return result
def to_networkx_graph(data,create_using=None,multigraph_input=False):
"""Make a NetworkX graph from a known data structure.
The preferred way to call this is automatically
from the class constructor
>>> d={0: {1: {'weight':1}}} # dict-of-dicts single edge (0,1)
>>> G=nx.Graph(d)
instead of the equivalent
>>> G=nx.from_dict_of_dicts(d)
Parameters
----------
data : a object to be converted
Current known types are:
any NetworkX graph
dict-of-dicts
dist-of-lists
list of edges
numpy matrix
numpy ndarray
scipy sparse matrix
pygraphviz agraph
create_using : NetworkX graph
Use specified graph for result. Otherwise a new graph is created.
multigraph_input : bool (default False)
If True and data is a dict_of_dicts,
try to create a multigraph assuming dict_of_dict_of_lists.
If data and create_using are both multigraphs then create
a multigraph from a multigraph.
"""
# NX graph
if hasattr(data,"adj"):
try:
result= from_dict_of_dicts(data.adj,\
create_using=create_using,\
multigraph_input=data.is_multigraph())
if hasattr(data,'graph') and isinstance(data.graph,dict):
result.graph=data.graph.copy()
if hasattr(data,'node') and isinstance(data.node,dict):
result.node=dict( (n,dd.copy()) for n,dd in data.node.items() )
return result
except:
raise nx.NetworkXError("Input is not a correct NetworkX graph.")
# pygraphviz agraph
if hasattr(data,"is_strict"):
try:
return nx.from_agraph(data,create_using=create_using)
except:
raise nx.NetworkXError("Input is not a correct pygraphviz graph.")
# dict of dicts/lists
if isinstance(data,dict):
try:
return from_dict_of_dicts(data,create_using=create_using,\
multigraph_input=multigraph_input)
except:
try:
return from_dict_of_lists(data,create_using=create_using)
except:
raise TypeError("Input is not known type.")
# list or generator of edges
if (isinstance(data,list)
or hasattr(data,'next')
or hasattr(data, '__next__')):
try:
return from_edgelist(data,create_using=create_using)
except:
raise nx.NetworkXError("Input is not a valid edge list")
# numpy matrix or ndarray
try:
import numpy
if isinstance(data,numpy.matrix) or \
isinstance(data,numpy.ndarray):
try:
return from_numpy_matrix(data,create_using=create_using)
except:
raise nx.NetworkXError(\
"Input is not a correct numpy matrix or array.")
except ImportError:
warnings.warn('numpy not found, skipping conversion test.',
ImportWarning)
# scipy sparse matrix - any format
try:
import scipy
if hasattr(data,"format"):
try:
return from_scipy_sparse_matrix(data,create_using=create_using)
except:
raise nx.NetworkXError(\
"Input is not a correct scipy sparse matrix type.")
except ImportError:
warnings.warn('scipy not found, skipping conversion test.',
ImportWarning)
raise nx.NetworkXError(\
"Input is not a known data type for conversion.")
return
def from_whatever(thing, create_using=None, multigraph_input=False):
"""Attempt to make a NetworkX graph from an known type.
Current known types are:
any NetworkX graph
dict-of-dicts
dist-of-lists
numpy matrix
numpy ndarray
scipy sparse matrix
pygraphviz agraph
If multigraph_input is True and thing is a dict_of_dicts,
try to create a multigraph assuming dict_of_dict_of_lists.
If thing and create_using are both multigraphs then create
a multigraph from a multigraph.
"""
# NX graph
if hasattr(thing, "adj"):
try:
result= from_dict_of_dicts(thing.adj,\
create_using=create_using,\
multigraph_input=thing.multigraph)
result.weighted = thing.weighted
return result
except:
raise networkx.NetworkXError,\
"Input is not a correct NetworkX graph."
# pygraphviz agraph
if hasattr(thing, "is_strict"):
try:
return networkx.from_agraph(thing, create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct pygraphviz graph."
# dict of dicts/lists
if isinstance(thing, dict):
try:
return from_dict_of_dicts(thing,create_using=create_using,\
multigraph_input=multigraph_input)
except:
try:
return from_dict_of_lists(thing, create_using=create_using)
except:
raise TypeError("Input is not known type.")
# numpy matrix or ndarray
try:
import numpy
if isinstance(thing,numpy.core.defmatrix.matrix) or \
isinstance(thing,numpy.ndarray):
try:
return from_numpy_matrix(thing, create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct numpy matrix or array."
except ImportError:
pass # fail silently
# scipy sparse matrix - any format
try:
import scipy
if hasattr(thing, "format"):
try:
return from_scipy_sparse_matrix(thing,
create_using=create_using)
except:
raise networkx.NetworkXError, \
"Input is not a correct scipy sparse matrix type."
except ImportError:
pass # fail silently
raise networkx.NetworkXError, \
"Input is not a known data type for conversion."
return
G = pgv.AGraph(directed=True)
for node in nodes:
G.add_node(node, label=node.id + "\n" + node.title)
for edge in edges:
G.add_edge(edge[0], edge[1])
static_path = "webapp/static/webapp/"
G.write("graph.dot")
# Generating basic svg
G.draw(path=static_path + "graph.svg", prog="dot")
# Generating .dot with coordinate information for nodes
os.system(
"ccomps -x graph.dot | dot -Nshape=point -Granksep=1.0 -Gnodesep=1.0 -Gsize=10 | gvpack -array1 | neato -Tdot -n2 -o graphcoord.dot"
)
# Generating JSON from graph with coordinates
G = pgv.AGraph("graphcoord.dot")
nx_G = nx.from_agraph(G)
graph_json = json_graph.node_link_data(nx_G)
with open(static_path + "graph.json", "w") as f:
json.dump(graph_json, f, indent=1)
# Cleaning up
os.remove("graph.dot")
os.remove("graphcoord.dot")
def consensus_network(self, filename, threshold, write_gml=False):
"""
**Purpose**
Draw a consensus network for a specified threshold
**Arguments**
filename (Required)
filename to save the png and svg to.
threshold (Required)
threshold value 0..1.0 for the consensus network
write_gml (Optional, default=False)
write the GML file for loadinging into e.g. Cytoscape
"""
assert self.result, "bayes.consensus_network: Bayes network not learnt yet"
assert filename, "You must specify a filename"
assert threshold, "You must specify a threshold"
assert threshold <= 1.0, "threshold is >= 1.0!"
assert threshold >= 0.0, "threshold is <= 0.0!"
#print [n.score for n in list(reversed(self.result.networks))]
this_posterior = posterior.from_sorted_scored_networks(self.result.nodes, list(reversed(self.result.networks)))
net_this_threshold = this_posterior.consensus_network(threshold)
cm = this_posterior.consensus_matrix # A method/property...
top = this_posterior[0] # posterior object
top.layout()
nodes = net_this_threshold.nodes
A = AGraph()
net = A.from_string(string=net_this_threshold.as_dotstring()) # Load their Network into a AGraph and NX.
G = nx.from_agraph(net)
edge_cols = [colorize_edge(cm[src][dest]) for src, dest in net_this_threshold.edges]
#pos = nx.graphviz_layout(G, 'dot')
#fig = plot.figure()
#ax = fig.add_subplot(111)
#nx.draw_graphviz(G, 'dot', with_labels=True, edge_color=edge_cols, linewidths=0)
#fig.tight_layout()
#fig.savefig(filename.replace(".png", ".pgv.png"))
dotstr = "\n".join(
["digraph G {"] +
[node(n, pos) for n, pos in zip(nodes, top.node_positions)] +
["\t\"%s\" -> \"%s\" [color=\"%s\"];" % (nodes[src].name, nodes[dest].name, colorize_edge(cm[src][dest])) for src,dest in net_this_threshold.edges] +
["}"])
fd, fname = tempfile.mkstemp()
open(fname, 'w').write(dotstr)
if write_gml:
nx.write_gml(G, filename.replace(".png", ".gml"))
# Better done through pygraphviz gives different results...
os.system("dot -n1 -Tpng -o%s %s" % (filename, fname))
os.system("dot -n1 -Tsvg -o%s %s" % (filename.replace(".png", ".svg"), fname))
os.remove(fname)
config.log.info("bayes.consensus_network: Saved '%s'" % filename)
import networkx as nx
g = nx.DiGraph()
g.add_node("A:a", type="A", name="a")
g.add_node("B", type="B")
g.add_edge("A:a", "B", label="0,1")
g.add_node("B:b", type="B", name="b")
g.add_edge("A:a", "B:b", label="1,1")
dot = nx.to_agraph(g);
print "g:",dot
g2 = nx.from_agraph(dot)
print "g2:",nx.to_agraph(g2);
print g2["A:a"]["B:b"]
nx.write_dot(g,"test_nxdot.dot")
# Pieter Swart <*****@*****.**>
# All rights reserved.
# BSD license.
import networkx as nx
# networkx graph
G=nx.Graph()
# ad edges with red color
G.add_edge(1,2,color='red')
G.add_edge(2,3,color='red')
# add nodes 3 and 4
G.add_node(3)
G.add_node(4)
# convert to a graphviz agraph
A=nx.to_agraph(G)
# write to dot file
A.write('k5_attributes.dot')
# convert back to networkx Graph with attributes on edges and
# default attributes as dictionary data
X=nx.from_agraph(A)
print("edges")
print(X.edges(data=True))
print("default graph attributes")
print(X.graph)
print("node node attributes")
print(X.node)
# Pieter Swart <*****@*****.**>
# All rights reserved.
# BSD license.
import networkx as nx
# networkx graph
G = nx.Graph()
# ad edges with red color
G.add_edge(1, 2, color='red')
G.add_edge(2, 3, color='red')
# add nodes 3 and 4
G.add_node(3)
G.add_node(4)
# convert to a graphviz agraph
A = nx.to_agraph(G)
# write to dot file
A.write('k5_attributes.dot')
# convert back to networkx Graph with attributes on edges and
# default attributes as dictionary data
X = nx.from_agraph(A)
print("edges")
print(X.edges(data=True))
print("default graph attributes")
print(X.graph)
print("node node attributes")
print(X.node)
def from_whatever(thing,create_using=None,multigraph_input=False):
"""Make a NetworkX graph from an known type.
The preferred way to call this is automatically
from the class constructor
>>> d={0: {1: {'weight':1}}} # dict-of-dicts single edge (0,1)
>>> G=nx.Graph(d)
instead of the equivalent
>>> G=nx.from_dict_of_dicts(d)
Parameters
----------
thing : a object to be converted
Current known types are:
any NetworkX graph
dict-of-dicts
dist-of-lists
list of edges
numpy matrix
numpy ndarray
scipy sparse matrix
pygraphviz agraph
create_using : NetworkX graph
Use specified graph for result. Otherwise a new graph is created.
multigraph_input : bool (default False)
If True and thing is a dict_of_dicts,
try to create a multigraph assuming dict_of_dict_of_lists.
If thing and create_using are both multigraphs then create
a multigraph from a multigraph.
"""
# NX graph
if hasattr(thing,"adj"):
try:
result= from_dict_of_dicts(thing.adj,\
create_using=create_using,\
multigraph_input=thing.is_multigraph())
if hasattr(thing,'graph') and isinstance(thing.graph,dict):
result.graph=thing.graph.copy()
if hasattr(thing,'node') and isinstance(thing.node,dict):
result.node=dict( (n,dd.copy()) for n,dd in thing.node.iteritems() )
return result
except:
raise networkx.NetworkXError,\
"Input is not a correct NetworkX graph."
# pygraphviz agraph
if hasattr(thing,"is_strict"):
try:
return networkx.from_agraph(thing,create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct pygraphviz graph."
# dict of dicts/lists
if isinstance(thing,dict):
try:
return from_dict_of_dicts(thing,create_using=create_using,\
multigraph_input=multigraph_input)
except:
try:
return from_dict_of_lists(thing,create_using=create_using)
except:
raise TypeError("Input is not known type.")
# list or generator of edges
if isinstance(thing,list) or hasattr(thing,'next'):
try:
return from_edgelist(thing,create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a valid edge list"
# numpy matrix or ndarray
# try:
# import numpy
if isinstance(thing,numpy.core.defmatrix.matrix) or \
isinstance(thing,numpy.ndarray):
try:
return from_numpy_matrix(thing,create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct numpy matrix or array."
# except ImportError:
# pass # fail silently
# scipy sparse matrix - any format
# try:
# import scipy
if hasattr(thing,"format"):
try:
return from_scipy_sparse_matrix(thing,create_using=create_using)
except:
raise networkx.NetworkXError, \
"Input is not a correct scipy sparse matrix type."
# except ImportError:
# pass # fail silently
raise networkx.NetworkXError, \
"Input is not a known data type for conversion."
return
def from_whatever(thing,create_using=None,multigraph_input=False):
"""Attempt to make a NetworkX graph from an known type.
Current known types are:
any NetworkX graph
dict-of-dicts
dist-of-lists
numpy matrix
numpy ndarray
scipy sparse matrix
pygraphviz agraph
If multigraph_input is True and thing is a dict_of_dicts,
try to create a multigraph assuming dict_of_dict_of_lists.
If thing and create_using are both multigraphs then create
a multigraph from a multigraph.
"""
# NX graph
if hasattr(thing,"adj"):
try:
result= from_dict_of_dicts(thing.adj,\
create_using=create_using,\
multigraph_input=thing.multigraph)
result.weighted=thing.weighted
return result
except:
raise networkx.NetworkXError,\
"Input is not a correct NetworkX graph."
# pygraphviz agraph
if hasattr(thing,"is_strict"):
try:
return networkx.from_agraph(thing,create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct pygraphviz graph."
# dict of dicts/lists
if isinstance(thing,dict):
try:
return from_dict_of_dicts(thing,create_using=create_using,\
multigraph_input=multigraph_input)
except:
try:
return from_dict_of_lists(thing,create_using=create_using)
except:
raise TypeError("Input is not known type.")
# numpy matrix or ndarray
try:
import numpy
if isinstance(thing,numpy.core.defmatrix.matrix) or \
isinstance(thing,numpy.ndarray):
try:
return from_numpy_matrix(thing,create_using=create_using)
except:
raise networkx.NetworkXError,\
"Input is not a correct numpy matrix or array."
except ImportError:
pass # fail silently
# scipy sparse matrix - any format
try:
import scipy
if hasattr(thing,"format"):
try:
return from_scipy_sparse_matrix(thing,create_using=create_using)
except:
raise networkx.NetworkXError, \
"Input is not a correct scipy sparse matrix type."
except ImportError:
pass # fail silently
raise networkx.NetworkXError, \
"Input is not a known data type for conversion."
return
def tred(graph):
A = nx.to_agraph(graph)
I = A.tred(copy=true)
new_graph = nx.from_agraph(I)
return new_graph
def as_gml(self, filename):
dstr = self.as_dotstring()
A = AGraph()
net = A.from_string(string=dstr)
G = nx.from_agraph(net)
nx.write_gml(G, filename)
}
def hypernode_subgraph(self, node):
label = self.hypergraph.node_label(node)
if label.span[0] == label.span[1]:
return [("clust_terminals", label.span[0] + (0.5 if label.dir == Right else 0))]
return []
def subgraph_format(self, subgraph):
return {"rank": "same"}
def hyperedge_node_attrs(self, edge):
return {"shape": "point"}
def hyperedge_attrs(self, edge):
return {"arrowhead": "none",
"color": "orange" if edge in self.path else "black",
"penwidth": 5 if edge in self.path else 1}
ParseFormat(hypergraph, sentence, path).to_ipython()
# In[ ]:
import networkx as nx
from networkx.readwrite import json_graph
import json
G = ParseFormat(hypergraph, sentence, path).to_graphviz()
G2 = nx.from_agraph(G)
d = json_graph.node_link_data(G2) # node-link format to serialize
# write json
json.dump(d, open('force.json','w'))
#nx.write_gexf(G2, "test_graph.gexf")
