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)
return people if __name__ == "__main__": mem_model = TripleStore() wordlist = get_words() FOAF = Namespace("http://xmlns.com/foaf/0.1/") GEO = Namespace("http://www.w3.org/2003/01/geo/wgs84_pos#") RDF = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#") DC = Namespace("http://purl.org/dc/elements/1.1/") CYC = Namespace("http://opencyc.sourceforge.net/daml/cyc.daml#") print "Image Annotation Tool" print "Enter the URI of a photo to annotate:" uri = raw_input("> ") mem_model.add((URIRef(uri), URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef("http://xmlns.com/foaf/0.1/Image"))) print "Should I add a thumbnail for this image, by adding '.sized' before the extension?" thumbnail = raw_input("> ") if thumbnail: thumb = "%ssized.%s" % (uri[:-3], uri[-3:]) mem_model.add((URIRef(uri), FOAF['thumbnail'], URIRef(thumb))) print "Enter a title for the photo:" title = raw_input("> ") mem_model.add( (URIRef(uri), URIRef("http://purl.org/dc/elements/1.1/title"), Literal(title))) print "Enter a description for the photo:" description = raw_input("> ") mem_model.add( (URIRef(uri), URIRef("http://purl.org/dc/elements/1.1/description"),
for i in available: people[source][prop].append(i) return people if __name__ == "__main__": mem_model = TripleStore() wordlist = get_words() FOAF = Namespace("http://xmlns.com/foaf/0.1/") GEO = Namespace("http://www.w3.org/2003/01/geo/wgs84_pos#") RDF = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#") DC = Namespace("http://purl.org/dc/elements/1.1/") CYC = Namespace("http://opencyc.sourceforge.net/daml/cyc.daml#") print "Image Annotation Tool" print "Enter the URI of a photo to annotate:" uri = raw_input("> ") mem_model.add((URIRef(uri), URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef("http://xmlns.com/foaf/0.1/Image"))) print "Should I add a thumbnail for this image, by adding '.sized' before the extension?" thumbnail = raw_input("> ") if thumbnail: thumb = "%ssized.%s"%(uri[:-3],uri[-3:]) mem_model.add((URIRef(uri), FOAF['thumbnail'], URIRef(thumb))) print "Enter a title for the photo:" title = raw_input("> ") mem_model.add((URIRef(uri), URIRef("http://purl.org/dc/elements/1.1/title"), Literal(title))) print "Enter a description for the photo:" description = raw_input("> ") mem_model.add((URIRef(uri), URIRef("http://purl.org/dc/elements/1.1/description"), Literal(description))) while 1: print "Photo Creator?" person = raw_input("> ") people = get_people(person)
try: bnode = graph.objects(graphNode, FOAF["primaryTopic"]).next() except StopIteration: print 'Content-Type: text/plain\r' print '\r' print 'no primary topic given' graph2 = TripleStore() for (s, p, o) in graph.triples((None, None, None)): if (s, p, o) == (graphNode, FOAF["primaryTopic"], bnode): continue if s == bnode: s = thisURI if o == bnode: o = thisURI graph2.add((s, p, o)) http_accept = os.environ['HTTP_ACCEPT'] accepts = [] # pairs (quality, type) for acc in http_accept.split(','): parts = acc.split(';') type = parts[0].strip().lower() for part in parts[1:]: eq = part.find('=') if eq >= 0 and part[:eq].strip() == 'q': quality = float(part[eq + 1:]) break else: quality = 1
# Create a namespace object for the Friend of a friend namespace. FOAF = Namespace("http://xmlns.com/foaf/0.1/") store = TripleStore() store.prefix_mapping("dc", "http://http://purl.org/dc/elements/1.1/") store.prefix_mapping("foaf", "http://xmlns.com/foaf/0.1/") # Create an identifier to use as the subject for Donna. donna = BNode() 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.
class rdfDict: """ Provides a dictionary-like wrapper around a set of RDF triples with a common subject. In addition to the standard dictionary interface provides convenience methods for manipulating the triples. """ def __init__(self, subject, rdfStore=None): """ Creates a new rdfDict given the particular subject and an optional TripleStore (rdfStore). If no TripleStore is provided, creates a new one. """ # store the subject self.subject = subject # store or create the triple store if rdfStore is None: self.store = TripleStore() else: self.store = rdfStore def __str__(self): """ Return the string representation of this instance using an algorithm inspired by the Dublic Core dumb-down method. """ output_str = '' pairs = [] type_item = None for key in self: if (key.find("#type") != -1): type_item = key else: pairs.append((key, self.getAll(key))) output_str = str(self.getFirst(type_item)) + ": " for pair in pairs: output_str = '%s %s: %s;' % (output_str, str(pair[0]), ", ".join([str(n) for n in pair[1]]) ) return output_str def about(self): """ Return the subject used to create the instance (usually equivalent to rdf:about. """ return self.subject def __getvalues(self, key): """ Returns a list of values for a particular key; coerces BNodes to rdfDicts and mangles Literals with language attributes (if available). """ values = [ n for n in self.store.objects(subject=self.subject, predicate=key) ] result = [] for value in values: if (isinstance(value, BNode)): # coerce to rdfDict result.append(rdfDict(value, self.store)) else: result.append(value) return result def __getitem__(self, key): """ Return the object described in RDF with a subject of self.subject and a predicate of key. If more than one match is found, raises an AmbiguousKeyError. """ result = self.__getvalues(key) if (len(result) == 0): # no item was found, throw an exception raise KeyError() elif (len(result) > 1): # check if there is more than one option raise AmbiguousKeyError() else: # otherwise return object value return result[0] def getFirst(self, key): """ Returns the first object having the predicate key. If no match is found returns None. """ if ( (self.subject, URIRef(key), None) in self.store): return self.__getvalues(key)[0] else: return None def getAll(self, key): """ Returns a list of objects which have a predicate of key. The list may be empty or contain only a single element. """ return self.__getvalues(key) def __setitem__(self, key, value): """ Adds an RDF triple of the values (self.subject, key, value); any objects with the same subject/predicate are replaced. """ if (self.subject, key, none) in self.store: del self[key] self.store.add( (self.subject, key, value) ) def add (self, key, value): """ Adds an RDF triple consisting of the subject, key and value. """ self.store.add( (self.subject, key, value) ) def addAll (self, key, values): """ Adds the list of objects in values with the same subject and predicate. """ for value in values: self.add (key, value) def __len__(self): """ Returns the number of predicate-object pairs associated with the subject self.subject. """ return len(self.store) def __delitem__(self, key): """ Removes all items with the given key. """ if (self.subject, key, None) in self.store: self.store.remove( (self.subject, key, None) ) else: raise KeyError() def remove (self, key, value): """ Removes a specific key-value pair. """ self.store.remove( (self.subject, key, value) ) def __iter__(self): """ Returns an iterator over the unique keys (predicates) for the given subject. """ return iter(sets.Set(self.store.predicates(subject=self.subject))) iterkeys = __iter__ def __contains__(self, key): """ Returns true if the given key appears as a predicate of the subject. """ return ( (self.subject, key, None) in self.store )