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))
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__':
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: