def validate(self, uri_fingerprint, require_hex_fpr=1):
"""validate the format of the document"""
FOAF = Namespace("http://xmlns.com/foaf/0.1/")
TRUST = Namespace("http://www.konfidi.org/ns/trust/1.2#")
WOT = Namespace("http://xmlns.com/wot/0.1/")
RDF = Namespace("http://www.w3.org/2000/01/rdf-schema#")
store = TripleStore()
# TODO: verify all <truster>s have fingerprints
# and that they're all the same
try:
store.parse(StringInputSource(self.content))
except SAXParseException:
raise FOAFServerError, "invalid XML: " + str(sys.exc_info()[1])
fingerprint = last_fingerprint = None
for (relationship, truster) in store.subject_objects(TRUST["truster"]):
for (key) in store.objects(truster, WOT["hasKey"]):
fingerprint = store.objects(key, WOT["fingerprint"]).next()
if last_fingerprint:
if fingerprint != last_fingerprint:
raise FOAFServerError, "All wot:fingerprint's from trust:truster's PubKeys must be the same. Found '%s' and '%s'" % (fingerprint, last_fingerprint)
last_fingerprint = fingerprint
# per http://xmlns.com/wot/0.1/, we really shouldn't replace these
fingerprint = fingerprint.replace(" ", "")
fingerprint = fingerprint.replace(":", "")
if require_hex_fpr and not(ishex(fingerprint)):
raise FOAFServerError, "Invalid fingerprint format; must be hex"
if uri_fingerprint and uri_fingerprint != fingerprint:
raise FOAFServerError, "URI fingerprint doesn't match FOAF fingerprint"
return fingerprint
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 load(self, source):
print "Update Listener: parsing input: %s" % source
# this is the main object we're concerned with
trust = TripleStore()
trust.load(source)
# new version
count = 0
for (relationship, truster) in trust.subject_objects(self.TRUST["truster"]):
# clean up the fingerprints
source_fingerprint = trust.objects(truster, self.WOT["fingerprint"]).next()
sink_fingerprint = trust.objects(trust.objects(relationship, self.TRUST["trusted"]).next(), self.WOT["fingerprint"]).next()
# turn these off for now, for our test cases. figure a better solution later
source_fingerprint = re.sub(r'[^0-9A-Z]', r'', source_fingerprint.upper())
sink_fingerprint = re.sub(r'[^0-9A-Z]', r'', sink_fingerprint.upper())
source = self.server.getPerson(source_fingerprint)
sink = self.server.getPerson(sink_fingerprint)
for item in trust.objects(relationship, self.TRUST["about"]):
topic = trust.objects(item, self.TRUST["topic"]).next().split("#")[1]
rating = float(trust.objects(item, self.TRUST["rating"]).next())
if rating >= 0.0 and rating <= 1.0:
source.addTrustLink(sink.getFingerprint(), topic, rating)
count += 1
return "Added %d trust links." % count
"""
read XMP xml files
"""
# see http://www.xml.com/lpt/a/1107
# see also raptor-utls
# rapper -o ntriples http://planetrdf.com/guide/rss.rdf
# rapper -o ntriples ../tests/fixture/xmp/sample_xmp.rdf
from rdflib.TripleStore import TripleStore
from rdflib.Namespace import Namespace
ns_dc = Namespace("http://purl.org/dc/elements/1.1/")
ns_pr = Namespace("http://prismstandard.org/1.0#")
store = TripleStore()
store.load("../tests/fixture/xmp/sample_xmp.rdf")
# print dir(store)
quit()
# For all triples that have prism:publicationTime as their predicate,
for s, o in store.subject_objects(ns_pr["publicationTime"]):
# if the triples' object is greater than the cutoff date,
if o > cutOffDate:
# print the date, author name, and title.
print o,
for object in store.objects(s, ns_dc["creator"]):
print object + ": ",
for object in store.objects(s, ns_dc["title"]):
print object
'turtle',
'ntriples',
infile=tmpfile)
graph = TripleStore()
graph.parse(StringIO(data), format='nt')
thisURI = URIRef('http://%s%s' %
(os.environ['HTTP_HOST'], os.environ['REQUEST_URI']))
graphNode = URIRef('file://%s' % tmpfile)
FOAF = Namespace("http://xmlns.com/foaf/0.1/")
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))
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"
# Serialize as NTriples
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 )
# 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:
name = subject.split("#")[1]
resource = subject
value = value.split("#")[1]
tc = TrustConnection.TrustConnection()
tc.setFingerprint(f2)
tv = TrustValue.TrustValue(value)
