Python Graph.predicates方法代码示例

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import predicates [as 别名]
rdfs = Namespace('http://www.w3.org/2000/01/rdf-schema#')
dc = Namespace('http://purl.org/dc/elements/1.1/')
dct = Namespace('http://purl.org/dc/terms/')
rel = Namespace('http://www.perceive.net/schemas/20021119/relationship#')
pome = Namespace('http://prosopOnto.medieval.england/2006/04/pome#')
crm = Namespace('http://cidoc.ics.forth.gr/rdfs/cidoc_v4.2.rdfs#')
me = Namespace('file:///Users/jjc/Documents/Dissertation/Notes/1233HostageDeal/modelTesting/1233Hostages.rdf#')


exchanges = list(g.subjects(rdf['type'],crm['Event']))
people = list(g.subjects(rdf['type'], pome['Person']))

d = pydot.Dot(graph_name="testgraph", graph_type="digraph", strict=True, suppress_disconnected=False, rankdir="TB")
d.set_node_defaults(shape="box")
for ex in exchanges:
    if pome['hostage'] in g.predicates(ex):
        
        hostage = g.objects(ex,pome['hostage']).next().encode('utf-8').split('#')[-1]
        
        d.add_node(
            pydot.Node(hostage, style="filled", fillcolor="#cccc99")
        )

        
        d.add_edge(
            pydot.Edge(
                g.objects(ex,pome['hostageGiver']).next().encode('utf-8').split('#')[-1],
                hostage
            )
        )
        

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import predicates [as 别名]
numOfTables = 0

for subj, pred, obj in g:
	#print("\n New object\n")
	#print((subj,pred,obj))
 	if (subj, pred, obj) not in g:
		raise Exception("Iterator / Container Protocols are Broken!!")

print("\n\nChairs:\n\n")


for chairs in g.subjects(RDF.type,chair):
	print("Found a Chair\n"+ chairs +"\n\n")
	numOfChairs += 1
	print("Looking for predicates...\n\n")
	for pred in g.predicates(chairs,None):
		print(" Found a predicate: " + pred)
	print("\n\n")

for tables in g.subjects(RDF.type,table):
	print("Found a table",tables)
	numOfTables += 1

print("Total Number of Chairs:",numOfChairs) 
print("Total Number of Tables:",numOfTables) 


#print("--- printing mboxes ---")
for person in g.subjects(RDF.type, FOAF.Person):
    for mbox in g.objects(person, FOAF.mbox):
        #print(mbox)

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import predicates [as 别名]
class Model:

    def __init__(self):
        self.graph = Graph()
        self.loaded = set()

    def load(self, source, format=None):
        if source not in self.loaded:
            self.loaded.add(source)
            try:
                self.graph.parse(source, format=format)
            except Exception as e:
                print e
                return False
        return True

    def size(self):
        return len(self.graph)

    def pred(self, subj):
        return list(set(self.graph.predicates(subj)))

    def types(self):
        return set(self.graph.objects(predicate=RDF.type))

    def contains_resource(self, ref):
        resources = filter(lambda x: type(x) == URIRef, self.graph.all_nodes())
        return ref in resources

    def get_resource_objects(self, subj, pred):
        return filter(lambda x: type(x) == URIRef, self.graph.objects(subj, pred))

    def get_objects(self, subj, pred):
        return list(self.graph.objects(subj, pred))

    def get_subjects(self, pred, obj):
        return list(self.graph.subjects(pred, obj))

    def get_properties(self, subj):
        properties = {}
        for pred, obj in self.graph.predicate_objects(subj):
            if pred in properties:
                properties[pred].append(obj)
            else:
                properties[pred] = [obj]
        return properties

    def get_reverse_properties(self, obj):
        properties = {}
        for subj, pred in self.graph.subject_predicates(obj):
            if pred in properties:
                properties[pred].append(subj)
            else:
                properties[pred] = [subj]
        return properties

    def norm(self, ref):
        return self.graph.namespace_manager.normalizeUri(ref) if ref else None

    def to_uriref(self, string):
        """Expand QName to UriRef based on existing namespaces."""
        if not string:
            return None
        elif re.match('[^:/]*:[^:/]+', string):
            prefix, name = string.split(':')
            try:
                namespace = dict(self.graph.namespaces())[prefix]
                return namespace + name
            except:
                return None
        else:
            return URIRef(string)