def startElement(self, name, attrs):
""" Parses all currently relevant XML tags and retrieves data."""
if name == "graph":
# determine, if graph is directed:
if attrs.getValue("edgedefault") == "directed":
print("identified graph as directed")
self.directed = True
if "id" in attrs.getNames() and not attrs.getValue("id") == '':
self.graphName = attrs.getValue("id")
self.g = Graph(0, self.weighted, self.directed)
self.g.setName(self.graphName)
if name == "node":
u = self.g.addNode()
val = attrs.getValue("id")
self.mapping[val] = u
elif name == "edge":
u = attrs.getValue("source")
v = attrs.getValue("target")
self.edgestack.append((u, v))
elif name == "key":
#print("found element with tag KEY")
if (attrs.getValue("for") == 'edge'
and attrs.getValue("attr.name") == 'weight'
and attrs.getValue("attr.type") == 'double'):
self.weighted = True
self.weightedID = attrs.getValue("id")
print("identified graph as weighted")
elif name == "data" and attrs.getValue("key") == self.weightedID:
self.keepData = True
def setUp(self):
from _NetworKit import Graph
self.g = Graph(5)
self.g.addEdge(0, 1)
self.g.addEdge(0, 2)
self.g.addEdge(0, 3)
self.g.addEdge(0, 4)
def generate(self):
G = Graph(self.n)
for u in G.nodes():
if u is 0:
pass
else:
G.addEdge(u, 0)
return G
def __init__(self): """ Initializes the GEXFReader class """ self.mapping = dict() self.g = Graph(0) self.weighted = False self.directed = False self.dynamic = False self.hasDynamicWeights = False self.q = queue.Queue() self.eventStream = [] self.nInitialNodes = 0 self.timeFormat = ""
def __init__(self):
""" Initializes several important variables """
xml.sax.ContentHandler.__init__(self)
self.charBuffer = []
self.mapping = dict()
self.g = Graph(0)
self.graphName = 'unnamed'
self.weightedID = ''
self.weighted = False
self.directed = False
self.edgestack = []
self.edgeweight = 0.0
self.keepData = False
def graphFromStream(stream, weighted, directed):
""" Convenience function for creating a new graph from a stream of graph events
Parameters
----------
stream : list of GraphEvent
event stream
weighted : produce a weighted or unweighted graph
boolean
directed : produce a directed or undirected graph
boolean
"""
G = Graph(0, weighted, directed)
gu = GraphUpdater(G)
gu.update(stream)
return G
def read(self, fpath):
""" Reads and returns the graph object defined in fpath """
#0. Reset internal vars and parse the xml
self.__init__()
doc = minidom.parse(fpath)
#1. Determine if graph is dynamic, directed and has dynamically changing weights
graph = doc.getElementsByTagName("graph")[0]
if (graph.getAttribute("defaultedgetype") == "directed"):
self.directed = True
if (graph.getAttribute("mode") == "dynamic"):
self.dynamic = True
if self.dynamic:
self.timeFormat = graph.getAttribute("timeformat")
attributes = graph.getElementsByTagName("attribute")
for att in attributes:
if att.getAttribute("id") == "weight":
self.hasDynamicWeights = True
self.weighted = True
#2. Read nodes and map them to IDs defined in GEXF file
nodes = doc.getElementsByTagName("node")
for n in nodes:
u = n.getAttribute("id")
if self.dynamic:
"""
A GEXF ID can be a string. However, this version of parser accepts ids
in only 2 formats:
1. id = "0,1,2," etc.
2. id = "n0, n1, n2" etc.
So either an integer or an integer that has n prefix.
Gephi generates its random graphs in 2nd format for example.
"""
_id = ""
try:
_id = int(u)
except:
_id = int(u[1:])
# 2-way mapping to refer nodes back in mapDynamicNodes() method
self.mapping[u] = _id
self.mapping[_id] = u
controlList = {'elementAdded': False, 'elementDeleted': False}
spells = n.getElementsByTagName("spell")
if len(spells) > 0:
for s in spells:
self.parseDynamics(s, "n", controlList, u)
else:
self.parseDynamics(n, "n", controlList, u)
else:
self.mapping[u] = self.nInitialNodes
self.nInitialNodes +=1
if self.dynamic:
self.mapDynamicNodes()
#3. Read edges and determine if graph is weighted
edges = doc.getElementsByTagName("edge")
for e in edges:
u = e.getAttribute("source")
v = e.getAttribute("target")
w = "1.0"
if e.hasAttribute("weight"):
self.weighted = True
w = e.getAttribute("weight")
if self.dynamic:
controlList = {'elementAdded': False, 'elementDeleted': False}
spells = e.getElementsByTagName("spell")
if len(spells) > 0:
for s in spells:
self.parseDynamics(s, "e", controlList, u, v, w)
else:
self.parseDynamics(e, "e", controlList, u, v, w)
else:
self.q.put((u, v, w))
#4. Create graph object
self.g = Graph(self.nInitialNodes, self.weighted, self.directed)
#5. Add initial edges to the graph and sort the eventStream by time
#5.1 Adding initial edges
while not self.q.empty():
edge = self.q.get()
(u, v, w) = (edge[0], edge[1], float(edge[2]))
self.g.addEdge(self.mapping[u], self.mapping[v], w)
#5.2 Sorting the eventStream by time and adding timeStep between events that happen in different times
self.eventStream.sort(key=lambda x:x[1])
for i in range(1, len(self.eventStream)):
if self.eventStream[i][1] != self.eventStream[i-1][1]:
self.eventStream.append((GraphEvent(GraphEvent.TIME_STEP, 0, 0, 0), self.eventStream[i-1][1]))
self.eventStream.sort(key=lambda x:x[1])
self.eventStream = [event[0] for event in self.eventStream]
return (self.g, self.eventStream)
