def setup(self): # Create a namespace object for the Friend of a friend namespace. self.FOAF = Namespace("http://xmlns.com/foaf/0.1/") self.TRUST = Namespace("http://www.abundantplunder.com/trust/owl/trust.owl#") self.WOT = Namespace("http://xmlns.com/wot/0.1/") self.RDF = Namespace("http://www.w3.org/2000/01/rdf-schema#") # load trust values into list for later trust = TripleStore() trust.load("http://www.abundantplunder.com/trust/owl/trust.owl#") self.trustValues = [] for s in trust.subjects(self.RDF["subPropertyOf"], self.TRUST["trustValue"]): self.trustValues.append(s)
class rdfStore: """ Provides RDF parsing and output functions for CC license and work definitions. """ def __init__(self): # initialize the TripleStore for managing RDF self.store = TripleStore() def parse(self, rdf): """ Parse the given String, rdf, into it's component triples. """ self.store.parse( StringInputSource (rdf) ) def subjects(self): """A generator which successivly returns each subject contained in the store, wrapped in an instance of rdfDict.""" for subject in self.store.subjects(): yield rdfDict(subject, store=self.store) def output(self): """ Return a string containing the RDF representation of the licenses and works.""" if self.store is not None: rdf = cStringIO.StringIO() self.store.serialize(stream=rdf) return rdf.getvalue() else: return "" __str__ = output def append(self, newItem): """ Adds a new work or license to the RDF store. """ # make sure the stores aren't the same if (newItem.store is not self.store): # add each triple from the newItem's store to this store for triple in newItem.store.triples(): self.store.add(triple)
def load(self, source): # TODO: don't let duplicate trust levels on certain subjects be entered! print "Update Listener: parsing input" # this is the main object we're concerned with store = TripleStore() store.load(source) # For each foaf:Person in the store print out its mbox property. truster = store.subjects(self.TRUST["trusts"]).next() f = store.objects(truster, self.WOT["fingerprint"]).next() p = self.server.getPerson(f) for trustee in store.objects(truster, self.TRUST["trusts"]): f2 = store.objects(trustee, self.WOT["fingerprint"]).next() # we do this to make sure they exist. p2 = self.server.getPerson(f2) for value, resource in store.predicate_objects(trustee): if value in self.trustValues: p.addTrustLink(f2, resource.split("#")[1], resource, TrustValue.TrustValue(value.split("#")[1]))
def load(self, source): print "Update Listener: parsing input: %s" % source # this is the main object we're concerned with store = TripleStore() store.load(source) # For each foaf:Person in the store print out its mbox property. truster = store.subjects(self.TRUST["trusts"]).next() f = store.objects(truster, self.WOT["fingerprint"]).next() p = self.server.getPerson(f) for trustee in store.objects(truster, self.TRUST["trusts"]): f2 = store.objects(trustee, self.WOT["fingerprint"]).next() # we do this to make sure they exist. p2 = self.server.getPerson(f2) for value, resource in store.predicate_objects(trustee): if value in self.trustValues: self.server.lock.acquire_write() #time.sleep(15) p.addTrustLink(f2, resource.split("#")[1], resource, BasicTrustValue(value.split("#")[1])) self.server.lock.release_write()
def setup(self): # Create a namespace object for the Friend of a friend namespace. # figure out trailing pound thing... #self.FOAF = Namespace(self.server.config.foaf_url + "#") #self.TRUST = Namespace(self.server.config.trust_url + "#") #self.WOT = Namespace(self.server.config.wot_url + "#") #self.RDF = Namespace(self.server.config.rdf_url + "#") self.FOAF = Namespace("http://xmlns.com/foaf/0.1/#") self.TRUST = Namespace("http://brondsema.gotdns.com/svn/dmail/schema/tags/release-1.0/trust.owl#") self.WOT = Namespace("http://xmlns.com/wot/0.1/#") self.RDF = Namespace("http://www.w3.org/2000/01/rdf-schema#") # load trust values into list for later trust = TripleStore() #trust.load(self.server.config.trust_url) trust.load("http://brondsema.gotdns.com/svn/dmail/schema/tags/release-1.0/trust.owl#") self.trustValues = [] for s in trust.subjects(self.RDF["subPropertyOf"], self.TRUST["trustValue"]): self.trustValues.append(s)
from rdflib.constants import DATATYPE # Add triples using store's add method. store.add((donna, TYPE, FOAF["Person"])) store.add((donna, FOAF["nick"], Literal("donna"))) store.add((donna, FOAF["name"], Literal("Donna Fales"))) # Iterate over triples in store and print them out. print "--- printing raw triples ---" for s, p, o in store: print s, p, o # For each foaf:Person in the store print out its mbox property. print "--- printing mboxes ---" for person in store.subjects(TYPE, FOAF["Person"]): for mbox in store.objects(person, FOAF["mbox"]): print mbox # Serialize the store as RDF/XML to the file foaf.rdf. store.save("foaf.rdf") # Let's show off the serializers print "RDF Serializations:" # Serialize as XML print "--- start: rdf-xml ---" print store.serialize() print "--- end: rdf-xml ---\n"
WOT = Namespace("http://xmlns.com/wot/0.1/") RDF = Namespace("http://www.w3.org/2000/01/rdf-schema#") # this is the main object we're concerned with store = TripleStore() store.load("example2.rdf") # master dictionary containing all the people # will a plain old dictionary suffice, or do I need a hashtable? people = {} # load trust values into list for later trust = TripleStore() trust.load("http://www.abundantplunder.com/trust/owl/trust.owl#") trustValues = [] for s in trust.subjects(RDF["subPropertyOf"], TRUST["trustValue"]): trustValues.append(s) # For each foaf:Person in the store print out its mbox property. print "--- printing trust: ---" truster = store.subjects(TRUST["trusts"]).next() f = store.objects(truster, WOT["fingerprint"]).next() p = Person.Person(f) people[f] = p for trustee in store.objects(truster, TRUST["trusts"]): f2 = store.objects(trustee, WOT["fingerprint"]).next() p2 = Person.Person(f2) people[f2] = p2 for value, subject in store.predicate_objects(trustee): if value in trustValues: