def get_relations(persons):
main_person=None
relations={}
mapper()
#~ check if there is only one person if the file
if len(persons)==1:
return (persons[0],relations)
for person in persons:
#~ check for main person
if person.knows or person.hasMet or person.knowsByReputation or person.friendOf:
main_person=person
#~ check for relations
if person.knows:
relations['knows']=person.knows
add_uris(relations['knows'])
if person.hasMet:
relations['hasMet']=person.hasMet
add_uris(relations['hasMet'])
if person.knowsByReputation:
relations['knowsByReputation']=person.knowsByReputation
add_uris(relations['knowsByReputation'])
if person.friendOf:
relations['friendOf']=person.friendOf
add_uris(relations['friendOf'])
if person.worksWith:
relations['worksWith']=person.worksWith
add_uris(relations['worksWith'])
if person.wouldLikeToKnow:
relations['wouldLikeToKnow']=person.wouldLikeToKnow
add_uris(relations['wouldLikeToKnow'])
return (main_person,relations)
def test_addBNodeKnowsM():
Person.knows = rdfalchemy.rdfMultiple(FOAF.knowsM, range_type=FOAF.Person)
mapper()
p1 = Person(first="PhilipM")
p2 = Person(last="Cooper", first="Ben")
p3 = Person(last="Cooper", first="Matt")
p1.knows = [p2, p3]
p1 = Person.get_by(first="PhilipM")
log.info("db len is %s" % len(Person.db))
assert len(p1.knows) == 2
del p1
def test_addBNodeKnowsM():
Person.knows = rdfMultiple(FOAF.knowsM, range_type=FOAF.Person)
mapper()
p1=Person(first="PhilipM")
p2=Person(last="Cooper" , first="Ben")
p3=Person(last="Cooper" , first="Matt")
p1.knows = [p2, p3]
p1=Person.get_by(first="PhilipM")
log.info("db len is %s"%len(Person.db))
assert len(p1.knows) == 2
del p1
def test_addBNodeKnowsC():
Person.knows = rdfalchemy.rdfContainer(
FOAF.knowsC, range_type=FOAF.Person)
mapper()
p1 = Person(first="PhilipC")
p2 = Person(last="Cooper", first="Ben")
p3 = Person(last="Cooper", first="Matt")
p1.knows = [p2, p3]
p1 = Person.get_by(first="PhilipC")
log.info("db len is %s" % len(Person.db))
assert len(p1.knows) == 2
del p1
def test_addBNodeKnowsL():
Person.knows = rdfalchemy.rdfList(FOAF.knows, range_type=FOAF.Person)
mapper()
p1 = Person.get_by(first="Philip")
p2 = Person(last="Cooper", first="Ben")
p3 = Person(last="Cooper", first="Matt")
assert len(Person.db) == 9
p1.knows = [p2, p3]
print(len(Person.db))
assert len(Person.db) == 14
del p1.knows
print(len(Person.db))
assert len(Person.db) == 3
def test_addBNodeKnowsL():
Person.knows = rdfalchemy.rdfList(FOAF.knows, range_type=FOAF.Person)
mapper()
p1 = Person.get_by(first="Philip")
p2 = Person(last="Cooper", first="Ben")
p3 = Person(last="Cooper", first="Matt")
assert len(Person.db) == 9
p1.knows = [p2, p3]
print len(Person.db)
assert len(Person.db) == 14
del p1.knows
print len(Person.db)
assert len(Person.db) == 3
def configure_database(self):
"""
Database configuration should be set here
"""
self.NS = NamespaceContainer()
self.NS.RDFS = rdflib.RDFS
self.NS.RDF = rdflib.RDF
self.NS.rdfs = rdflib.Namespace(rdflib.RDFS)
self.NS.rdf = rdflib.Namespace(rdflib.RDF)
self.NS.owl = rdflib.OWL
self.NS.xsd = rdflib.Namespace("http://www.w3.org/2001/XMLSchema#")
self.NS.dc = rdflib.Namespace("http://purl.org/dc/terms/")
self.NS.dcelements = rdflib.Namespace(
"http://purl.org/dc/elements/1.1/")
self.NS.auth = rdflib.Namespace("http://vocab.rpi.edu/auth/")
self.NS.foaf = rdflib.Namespace("http://xmlns.com/foaf/0.1/")
self.NS.prov = rdflib.Namespace("http://www.w3.org/ns/prov#")
self.NS.skos = rdflib.Namespace("http://www.w3.org/2004/02/skos/core#")
self.NS.cmo = rdflib.Namespace(
"http://purl.org/twc/ontologies/cmo.owl#")
self.NS.sio = rdflib.Namespace("http://semanticscience.org/resource/")
self.NS.sioc_types = rdflib.Namespace("http://rdfs.org/sioc/types#")
self.NS.sioc = rdflib.Namespace("http://rdfs.org/sioc/ns#")
self.NS.np = rdflib.Namespace("http://www.nanopub.org/nschema#")
self.NS.graphene = rdflib.Namespace("http://vocab.rpi.edu/graphene/")
self.NS.local = rdflib.Namespace(self.config['lod_prefix'] + '/')
self.NS.ov = rdflib.Namespace("http://open.vocab.org/terms/")
self.db = database.engine_from_config(self.config, "db_")
load_namespaces(self.db, locals())
Resource.db = self.db
self.vocab = Graph()
#print URIRef(self.config['vocab_file'])
self.vocab.load(open(self.config['vocab_file']), format="turtle")
self.role_api = ld.LocalResource(self.NS.prov.Role, "role",
self.db.store, self.vocab,
self.config['lod_prefix'], RoleMixin)
self.Role = self.role_api.alchemy
self.user_api = ld.LocalResource(self.NS.prov.Agent, "user",
self.db.store, self.vocab,
self.config['lod_prefix'], UserMixin)
self.User = self.user_api.alchemy
self.nanopub_api = ld.LocalResource(self.NS.np.Nanopublication,
"pub",
self.db.store,
self.vocab,
self.config['lod_prefix'],
name="Graph")
self.Nanopub = self.nanopub_api.alchemy
self.classes = mapper(self.Role, self.User)
self.datastore = RDFAlchemyUserDatastore(self.db, self.classes,
self.User, self.Role)
self.security = Security(self,
self.datastore,
register_form=ExtendedRegisterForm)
def initRDFDatabase(graph=None):
"""
Initialize the database of every mapped RDF class. Returns the prior
value of rdfSubject.db
"""
mapper()
old = getattr(rdfSubject, 'db', None)
# recursively purge class-bound 'db' attributes, which might be
# polluted by other rdfalchemy code. Instance-bound attributes should not
# be a problem since we'll be fetching new instances.
for sub in allsub(rdfSubject):
if 'db' in sub.__dict__: # hasattr returns true for superclasses, must
# check the subclass's own __dict__
del sub.db
rdfSubject.db = graph
return old
def addr_to_point(addr):
if not addr:
return None
Loc = mapper()[str(settings.NS.dct.Location)]
loc = map(Loc, list(addr.db.subjects(settings.NS.locn.address, addr)))
if len(loc) > 0:
loc = loc[0]
else:
return None
if loc.geometry and loc.geometry.datatype == settings.NS.opens.wkt:
geo = fromstr(str(loc.geometry))
if isinstance(geo, Point) and validGeoPoint(geo):
return geo
def tagged(self, rdfType):
""" returns the URI list from RDF resources using this tag
filtered by rdfType
"""
tagged = list(self.db.subjects(settings.NS.dct.subject, self))
model = mapper()[str(rdfType)]
if tagged == []:
return []
else:
res = []
for e in tagged:
one = list(self.db.triples((e, settings.NS.rdf.type, rdfType)))
if one != []:
res.append(model(e))
return res
def configure_database(self):
"""
Database configuration should be set here
"""
self.NS = NS
self.NS.local = rdflib.Namespace(self.config['lod_prefix'] + '/')
self.admin_db = database.engine_from_config(self.config, "admin_")
self.db = database.engine_from_config(self.config, "knowledge_")
self.db.app = self
load_namespaces(self.db, locals())
Resource.db = self.admin_db
self.vocab = Graph()
#print URIRef(self.config['vocab_file'])
self.vocab.load(open("default_vocab.ttl"), format="turtle")
self.vocab.load(open(self.config['vocab_file']), format="turtle")
self.role_api = ld.LocalResource(self.NS.prov.Role, "role",
self.admin_db.store, self.vocab,
self.config['lod_prefix'], RoleMixin)
self.Role = self.role_api.alchemy
self.user_api = ld.LocalResource(self.NS.prov.Agent, "user",
self.admin_db.store, self.vocab,
self.config['lod_prefix'], UserMixin)
self.User = self.user_api.alchemy
self.nanopub_api = ld.LocalResource(self.NS.np.Nanopublication,
"pub",
self.db.store,
self.vocab,
self.config['lod_prefix'],
name="Graph")
self.Nanopub = self.nanopub_api.alchemy
self.classes = mapper(self.Role, self.User)
self.datastore = RDFAlchemyUserDatastore(self.admin_db, self.classes,
self.User, self.Role)
self.security = Security(self,
self.datastore,
register_form=ExtendedRegisterForm)
#self.mail = Mail(self)
DepotManager.configure('nanopublications',
self.config['nanopub_archive'])
DepotManager.configure('files', self.config['file_archive'])
self.file_depot = DepotManager.get('files')
def _deserialize(self, data):
""" data has the pattern "<uri>" """
uri = data[1:-1]
# We have to retrieve the type to rebuild the object
attr = self.__dict__['field']
# Be careful when orig = None !!!!!
orig = getattr(attr.model, attr.name)
if None == orig:
return rdfSubject(rdflib.term.URIRef(uri))
elif isinstance(orig, list):
# rdfalchemy mapper gives me the solution
rt = attr.model.__class__.__dict__[attr.name].range_type
from rdfalchemy.orm import mapper
alch_map = mapper()
try:
cls = alch_map[str(rt)]
return cls(rdflib.term.URIRef(uri))
except:
rdfSubject(rdflib.term.URIRef(uri))
else:
return type(orig)(rdflib.term.URIRef(uri))
def _deserialize(self, data):
""" data has the pattern "<uri>" """
uri = data[1:-1]
# We have to retrieve the type to rebuild the object
attr = self.__dict__['field']
# Be careful when orig = None !!!!!
orig = getattr(attr.model, attr.name)
if None == orig:
return rdfSubject(rdflib.term.URIRef(uri))
elif isinstance(orig, list):
# rdfalchemy mapper gives me the solution
rt = attr.model.__class__.__dict__[attr.name].range_type
from rdfalchemy.orm import mapper
alch_map = mapper()
try:
cls = alch_map[str(rt)]
return cls(rdflib.term.URIRef(uri))
except:
rdfSubject(rdflib.term.URIRef(uri))
else:
return type(orig)(rdflib.term.URIRef(uri))
rdf_type = OWL.DatatypeProperty
range = rdfSingle(RDFS.range, range_type=RDFS.Class)
default_descriptor = rdfMultiple
########################################
# Object properties
class owlObjectProperty(rdfsProperty):
rdf_type = OWL.ObjectProperty
range = rdfSingle(RDFS.range, range_type=RDFS.Class)
inverseOf = rdfSingle(OWL.inverseOf, range_type=OWL.ObjectProperty)
default_descriptor = rdfMultiple
class owlInverseFunctionalProperty(owlObjectProperty):
rdf_type = OWL.InverseFunctionalProperty
default_descriptor = rdfSingle
class owlSymetricProperty(owlObjectProperty):
rdf_type = OWL.SymetricProperty
default_descriptor = rdfMultiple
class owlTransitiveProperty(owlObjectProperty):
rdf_type = OWL.TransitiveProperty
default_descriptor = owlTransitive
# this maps the return type of subClassOf back to rdfsClass
mapper()
title = rdfLocale(RDFS.label, 'en')
frtitle = rdfLocale(RDFS.label, 'fr')
subject = rdfMultiple(DCTERMS.subject)
actor = rdfMultiple(DBPO.starring, range_type=UMBEL.Actor)
class Actor(rdfSubject):
"""DBPedia actors"""
rdf_type = UMBEL.Actor
#name = rdfMultiple(FOAF.name)
name = rdfLocale(FOAF.name, 'en')
frname = rdfLocale(FOAF.name, 'fr')
# bind film's actors
mapper(Film, Actor)
# Utility function which lists predicates of a descriptor class
def predicates_of_descriptor(cls):
predicates = []
types = []
for f in cls.__dict__:
p = cls.__dict__[f]
t = None
mapped = None
if issubclass(type(p), rdfAbstract):
t = p.pred
mapped = getattr(p, '_mappedClass', None)
elif f == 'rdf_type':
t = RDF.type
DOAP['programming-language']) # because of the hyphen we can't use
# DOAP.programming-language
maintainer = rdfSingle(DOAP.maintainer, range_type=FOAF.Person)
class Release(rdfSubject):
rdf_type = DOAP.Version
name = rdfSingle(DOAP.revision)
created = rdfSingle(DOAP.created)
shortdesc = rdfMultiple(DOAP.shortdesc)
file_releases = rdfMultiple(DOAP['file-release'])
# mapper()
# The above line works because * is implied
# The below line is just more explicit
mapper(Project, Release, Person)
def show_project(p):
print("\n============================")
print("Name is %s" % p.name)
print(" created on %s" % p.created)
# because of `mapper()`, release below will be an instance of Release
# so we can use dot notation on it
for release in p.releases:
print(" %s released on %s" % (release.name, release.created))
for f in release.file_releases:
print(" with file %s" % f.resUri) # or f.n3()
if __name__ == '__main__':
rdf_type = OWL.DatatypeProperty
range = rdfSingle(RDFS.range, range_type=RDFS.Class)
default_descriptor = rdfMultiple
########################################
# Object properties
class owlObjectProperty(rdfsProperty):
rdf_type = OWL.ObjectProperty
range = rdfSingle(RDFS.range, range_type=RDFS.Class)
inverseOf = rdfSingle(OWL.inverseOf, range_type=OWL.ObjectProperty)
default_descriptor = rdfMultiple
class owlInverseFunctionalProperty(owlObjectProperty):
rdf_type = OWL.InverseFunctionalProperty
default_descriptor = rdfSingle
class owlSymetricProperty(owlObjectProperty):
rdf_type = OWL.SymetricProperty
default_descriptor = rdfMultiple
class owlTransitiveProperty(owlObjectProperty):
rdf_type = OWL.TransitiveProperty
default_descriptor = owlTransitive
# this maps the return type of subClassOf back to rdfsClass
mapper()
def toSesameRep(self, repository, graph, ctx='default', rdfType=None, force=False):
# lets use the context posibility, should be useless
if ctx == None and not getattr(settings, 'PES_USE_CONTEXT', False):
sesame = Repository(repository)
else:
if ctx == 'default' or getattr(settings, 'PES_USE_CONTEXT', False):
ctx = self.defaultCtxName
ctx = "<%s>" % ctx
sesame = Repository(repository, context=ctx)
unknownTypes = []
mapDjrdfTypes = djrdf.tools.rdfDjrdfMapTypes()
subjects = graph.subjects(settings.NS.rdf.type, rdfType)
for subject in subjects:
# small delay to let jetty warmup
time.sleep(0.01)
stored_date = list(sesame.objects(subject, settings.NS.dct.modified))
update_date = list(graph.objects(subject, settings.NS.dct.modified))
replacedBy = list(graph.objects(subject, settings.NS.dct.isReplacedBy))
deletedOn = list(graph.objects(subject, settings.NS.ov.deletedOn))
if (not force) and len(update_date) == 1 and len(stored_date) == 1 and update_date[0].toPython() <= stored_date[0].toPython():
log.debug(u"Nothing to update for %s" % subject)
else:
log.debug("Handle %s in %s" % (subject, repository))
types = list(graph.objects(subject, settings.NS.rdf.type))
# look for a type corresponding to a mapped RDFAlchemy model
RdfModel, djRdfModel = None, None
i = 0
n = len(types)
while i < n and not RdfModel:
str_type = str(types[i])
if str_type in mapper():
RdfModel = mapper()[str_type]
i += 1
if not RdfModel:
unknownTypes.extend(types)
# look for and djRdf.models corresponding to that type
if RdfModel:
try:
djRdfModel = mapDjrdfTypes[RdfModel.rdf_type]
except KeyError:
djRdfModel = None
# If a triple <old_uri> dct.isReplacedBy <new_uri> exists, this supposed
# the new_uri is up_to_date and the 'domain' which was hosting old_uri
# aggrees this renaming of uri. The aggregator has just to registered it
# and to populate this modification
if len(replacedBy) == 1:
newSubject = replacedBy[0]
sesame.add((subject, settings.NS.dct.isReplacedBy, newSubject))
triples = graph.triples((None, None, subject))
try:
while True:
(s, p, o) = triples.next()
sesame.add((s, p, newSubject))
except StopIteration:
pass
# and we suppress triples that are now obsolete
sesame.remove((subject, None, None))
sesame.remove((None, None, subject))
# if subject is django object
if djRdfModel:
oldSubject = djRdfModel.objects.get(uri=unicode(subject))
oldSubject.delete()
djSubject, created = djRdfModel.objects.get_or_create(uri=unicode(newSubject))
djSubject.save() # To publish updates
elif len(deletedOn) == 1:
if djRdfModel:
djSubject, created = djRdfModel.objects.get_or_create(uri=unicode(subject))
djSubject.remove()
elif RdfModel:
subject.remove()
else:
sesame.remove((subject, None, None))
sesame.remove((None, None, subject))
else:
addtriples = []
undirect_triples = list(graph.triples((None, None, subject)))
for (s, p, o) in list(graph.triples((subject, None, None))):
# Skip triples belong to foreign "context", which correspond to
# "imported" triples in this application
# local property case
if self.is_local(p):
addtriples.append((s, p, o))
else:
if self.is_local(s):
addtriples.append((s, p, o))
elif self.is_common(s):
addtriples.append((s, p, o))
elif isinstance(o, URIRef):
if self.is_local(o):
addtriples.append((s, p, o))
else:
self.addLog("The triple (%s,%s,%s) CANNOT be added" % (s, p, o))
else:
self.addLog("The triple (%s,%s,%s) CANNOT be added" % (s, p, o))
undirect_triples = []
for (s, p, o) in list(graph.triples((None, None, subject))):
if self.is_local(p):
undirect_triples.append((s, p, o))
if self.is_local(o):
undirect_triples.append((s, p, o))
elif self.is_common(o):
undirect_triples.append((s, p, o))
elif isinstance(s, URIRef):
if self.is_local(s):
undirect_triples.append((s, p, o))
else:
self.addLog("The triple (%s,%s,%s) CANNOT be added" % (s, p, o))
else:
self.addLog("The triple (%s,%s,%s) CANNOT be added" % (s, p, o))
if djRdfModel:
djSubject, created = djRdfModel.objects.get_or_create(uri=unicode(subject))
djrdf.tools.addTriples(subject, addtriples, undirect_triples, sesame)
djSubject.save()
else:
# print "When no djRdfModel exists for %s" % subject
djrdf.tools.addTriples(subject, addtriples, undirect_triples, sesame)
for t in unknownTypes:
self.addLog("The rdf:type %s is not handled yet by the aggregator" % t)
# for the logs
self.save()
def seeked_by(self):
org = mapper()[str(settings.NS.org.Organization)]
return map(org, list(self.db.subjects(settings.NS.gr.seeks, self)))
rdf_type = DBPO.Film
#title = rdfMultiple(RDFS.label)
title = rdfLocale(RDFS.label, 'en')
frtitle = rdfLocale(RDFS.label, 'fr')
subject = rdfMultiple(DCTERMS.subject)
actor = rdfMultiple(DBPO.starring, range_type=UMBEL.Actor)
class Actor(rdfSubject):
"""DBPedia actors"""
rdf_type = UMBEL.Actor
#name = rdfMultiple(FOAF.name)
name = rdfLocale(FOAF.name, 'en')
frname = rdfLocale(FOAF.name, 'fr')
# bind film's actors
mapper(Film, Actor)
# Utility function which lists predicates of a descriptor class
def predicates_of_descriptor(cls):
predicates = []
types = []
for f in cls.__dict__:
p = cls.__dict__[f]
t = None
mapped = None
if issubclass(type(p), rdfAbstract):
t = p.pred
mapped = getattr(p, '_mappedClass', None)
elif f == 'rdf_type':
t = RDF.type
if t and t not in types:
