def testGraphFromDictIterator(self):
g = Graph.DictList(iter(self.vertices), iter(self.edges))
self.checkIfOK(g, "name")
g = Graph.DictList(iter(self.vertices),
iter(self.edges),
iterative=True)
self.checkIfOK(g, "name")
def testGraphFromDictListAlternativeName(self):
for vdata in self.vertices:
vdata["name_alternative"] = vdata["name"]
del vdata["name"]
g = Graph.DictList(
self.vertices, self.edges, vertex_name_attr="name_alternative"
)
self.checkIfOK(g, "name_alternative")
g = Graph.DictList(
self.vertices, self.edges, vertex_name_attr="name_alternative",
iterative=True
)
self.checkIfOK(g, "name_alternative")
def testGraphFromDictListExtraVertexName(self):
del self.vertices[2:] # No data for "Cecil" and "David"
g = Graph.DictList(self.vertices, self.edges)
self.assertTrue(g.vcount() == 4 and g.ecount() == 5 and not g.is_directed())
self.assertTrue(g.vs["name"] == ["Alice", "Bob", "Cecil", "David"])
self.assertTrue(g.vs["age"] == [48, 33, None, None])
self.assertTrue(g.vs["gender"] == ["F", "M", None, None])
self.assertTrue(g.es["friendship"] == [4, 5, 5, 2, 1])
self.assertTrue(g.es["advice"] == [4, 5, 5, 4, 2])
self.assertTrue(g.get_edgelist() == [(0, 1), (1, 2), (0, 2), (0, 3), (1, 3)])
def testGraphFromDictIteratorNoVertices(self):
g = Graph.DictList(None, iter(self.edges))
self.checkIfOK(g, "name", check_vertex_attrs=False)
g = Graph.DictList(None, iter(self.edges), iterative=True)
self.checkIfOK(g, "name", check_vertex_attrs=False)
def createConceptGraph(self):
def getSubClassEdgeWeight(edge, elist):
def getPosToTop(elist, n, visited):
for e in elist:
if not e['type'] == RDFS.subClassOf:
continue
if (e['source'] == n) & (not n in visited):
visited.append(n)
return getPosToTop(elist, e['target'], visited) + 1
return 0
def getPosToBottom(elist, n, visited):
max = 0
for e in elist:
if not e['type'] == RDFS.subClassOf:
continue
if (e['target'] == n) & (not n in visited):
visited.append(n)
depth = getPosToBottom(elist, e['source'], visited) + 1
if (depth > max):
max = depth
return max
posToTop = getPosToTop(elist, edge['target'], []) + 1
posToBottom = getPosToBottom(elist, edge['source'], [])
height = posToTop + posToBottom
if (height == 1):
relPosInHierachie = 0
else:
relPosInHierachie = float(posToTop) / float(height)
abw = relPosInHierachie - baseline
abwNorm = abw * trange
res = multi * (math.atan(abwNorm) + math.pi / 2)
return res
def filter(subject, classlist):
if isinstance(subject, BNode): return True
if (str(subject) in classlist): return True
for ns in NSBLACKLIST:
if str(subject).startswith(ns):
return True
return False
graph = self.spec.graph
classtypes = [RDFS.Class, OWL.Class]
classlist = []
classObj = []
nlist = []
elist = []
#create nodes
for onetype in classtypes:
for classSub in graph.subjects(predicate=RDF.type, object=onetype):
#print("checking: " +str(classSub));
if not filter(classSub, classlist):
uri = str(classSub)
classlist.append(uri)
classObj.append(classSub)
#print("adding node: "+ uri);
nlist.append({
'node': classSub,
'uri': uri,
'name': self.gen[uri],
'label': str(uri).replace(self.ns, ""),
"type": "Class"
})
#else: print("filtered")
#print classObj
#if class != null create owl:Thing node
thing = OWL.Thing
uri = str(thing)
classlist.append(uri)
classObj.append(thing)
nlist.append({
'node':
thing,
'uri':
uri,
'name':
self.gen[uri],
'label':
str(uri).replace("http://www.w3.org/2002/07/owl#", ""),
"type":
"ExternalClass"
})
#create edges
for c in classObj:
if (c == OWL.Thing):
continue
found = False
#build concept hierachy
for obj in graph.objects(c, RDFS.subClassOf):
if (obj in classObj):
found = True
#get source and target id
source = self.gen[str(c)]
target = self.gen[str(obj)]
elist.append({
"type": RDFS.subClassOf,
'source': source,
'target': target,
"proptype": "language"
})
#add link to owl:thing if top node
if not found:
#print("add subclass link for level1 class " + str(c.uri));
source = self.gen[str(c)]
target = self.gen[str(OWL.Thing)]
elist.append({
"type": RDFS.subClassOf,
'source': source,
'target': target,
"proptype": "language"
})
#add domain level edges
for sub, obj in graph.subject_objects(RDFS.domain):
#test if obj in classlist
if (obj in classObj):
prop = sub
for rObj in graph.objects(prop, RDFS.range):
if (rObj in classObj):
#add a edge
dom = obj
range = rObj
source = self.gen[str(dom)]
target = self.gen[str(range)]
#print("Adding edge from "+ str(dom.uri) + " to " + str(range.uri) + " with Prop: "+str(prop.uri));
elist.append({
"type": prop,
'source': source,
'target': target,
"proptype": "domain"
})
#add some other language level edges
for sub, obj in graph.subject_objects(OWL.equivalentClass):
if (sub in classObj) and (obj in classObj):
source = self.gen[str(sub)]
target = self.gen[str(obj)]
elist.append({
"type": OWL.equivalentClass,
'source': source,
'target': target,
"proptype": "language"
})
for sub, obj in graph.subject_objects(OWL.disjointWith):
if (sub in classObj) and (obj in classObj):
source = self.gen[str(sub)]
target = self.gen[str(obj)]
elist.append({
"type": OWL.disjointWith,
'source': source,
'target': target,
"proptype": "language"
})
#nodes and edges created
#weighting them
for edge in elist:
if (edge['type'] == RDFS.subClassOf):
weight = getSubClassEdgeWeight(edge, elist)
edge['weight'] = weight
elif edge['proptype'] == 'domain':
weight = (edgeWeights[RDFS.domain] +
edgeWeights[RDFS.range]) / 2
edge['weight'] = weight
else:
weight = edgeWeights[edge['type']]
if weight == None: weight = 1
edge['weight'] = weight
#print nlist;
#print elist;
g = Graph.DictList(vertices=nlist, edges=elist, directed=True)
return g, classObj
