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)