def __init__(self, ident=None, key=None, **kwargs): try: super(DataObject, self).__init__(**kwargs) except BadConf: raise Exception( "You may need to connect to a database before continuing.") self.properties = [] self.owner_properties = [] self.po_cache = None """ A cache of property URIs and values. Used by RealSimpleProperty """ if ident is not None: self._id = R.URIRef(ident) else: # Randomly generate an identifier if the derived class can't # come up with one from the start. Ensures we always have something # that functions as an identifier self._id = None if key is not None: self.setKey(key) self._variable = R.Variable("V" + str(RND.random())) DataObject.attach_property(self, RDFTypeProperty) self.rdf_type_property.set(self.rdf_type)
def on_page_context( self, context: TemplateContext, page: Page, config: Config, nav: Page, ) -> TemplateContext: """Attach the views to certain pages.""" page_iri = rdflib.URIRef( f'{LOCAL}{page.file.src_path}', ) this_choices = list(map( operator.itemgetter(rdflib.Variable('this')), self.octiron.graph.query( 'SELECT * WHERE { ?this octa:subjectOf ?page_iri }', initBindings={ 'page_iri': page_iri, }, ).bindings, )) if this_choices: context['this'] = this_choices[0] else: context['this'] = page_iri context['graph'] = self.octiron.graph context['iri'] = page_iri # noinspection PyTypedDict context['query'] = partial( query, instance=self.octiron.graph, ) context['queries'] = self.stored_query context['local'] = LOCAL context['LOCAL'] = LOCAL context.update(self.octiron.namespaces) context['render'] = partial( render, octiron=self.octiron, ) # Provide all the support namespaces into template context context['octiron'] = self.octiron context['link'] = partial( link, octiron=self.octiron, ) # Page attributes page.iri = page_iri return context
def _graph_variable_to_var(cls, uri): from urlparse import urlparse u = urlparse(uri) x = u.path.split('/') #print uri if x[2] == 'variable': #print 'fragment = ', u.fragment return R.Variable(u.fragment) else: return uri
def label( resource: rdflib.URIRef, graph: rdflib.ConjunctiveGraph ) -> Optional[str]: """Convert a URIRef to a clickable URL.""" bindings = graph.query( 'SELECT ?label WHERE { ?resource rdfs:label ?label . } ', initBindings={ 'resource': resource, } ).bindings if not bindings: return None return bindings[0][rdflib.Variable('label')].value
def url( resource: rdflib.URIRef, graph: rdflib.ConjunctiveGraph ) -> Optional[str]: """Convert a URIRef to a clickable URL.""" bindings = graph.query( 'SELECT ?url WHERE { ?resource octa:subjectOf/octa:url ?url . } ', initBindings={ 'resource': resource, } ).bindings if not bindings: return None return '/' + bindings[0][rdflib.Variable('url')].value
def __init__(self, owner, resolver, **kwargs): super(SimpleProperty, self).__init__(**kwargs) self.owner = owner self._id = None self._variable = R.Variable("V" + str(RND.random())) if self.property_type == "ObjectProperty": self._pp = _ObjectValueProperty(conf=self.conf, owner_property=self, resolver=resolver) else: self._pp = _DatatypeValueProperty(conf=self.conf, owner_property=self, resolver=resolver) self.properties.append(self._pp) self._defined_values_cache = None self._defined_values_string_cache = None
def get(self): """ If the ``Property`` has had ``load`` or ``set`` called previously, returns the resulting values. Otherwise, queries the configured rdf graph for values which are set for the ``Property``'s owner. """ import random as RND if self.id_is_variable(): try: self._var = R.Variable("V" + str(int(RND.random() * 1E10))) gp = self.owner.graph_pattern(query=True) if self.property_type == 'DatatypeProperty': q = u"SELECT DISTINCT {0} where {{ {1} . }}".format( self._var.n3(), gp) elif self.property_type == 'ObjectProperty': q = "SELECT DISTINCT {0} {0}_type where {{ {{ {1} }} . {0} rdf:type {0}_type }} ORDER BY {0}".format( self._var.n3(), gp) else: raise Exception("Inappropriate property type " + self.property_type + " in SimpleProperty::get") finally: self._var = None qres = self.rdf.query(q) if self.property_type == 'DatatypeProperty': for x in qres: if x[0] is not None and not DataObject._is_variable(x[0]): yield _rdf_literal_to_python(x[0]) elif self.property_type == 'ObjectProperty': for x in _QueryResultsTypeResolver(self, qres)(): yield x else: for value in self.rdf.objects(self.identifier(query=False), self.value_property): if self.property_type == 'DatatypeProperty': if value is not None and not DataObject._is_variable( value): yield _rdf_literal_to_python(value) elif self.property_type == 'ObjectProperty': constructed_qres = set() for rdf_type in self.rdf.objects(value, R.RDF['type']): constructed_qres.add((value, rdf_type)) for ob in _QueryResultsTypeResolver( self, constructed_qres)(): yield ob
def next_variable(cls): cls._next_variable_int += 1 return R.Variable('a' + cls.__name__ + '_' + str(cls._next_variable_int))
def fixup2(o): if type(o) == rdflib.BNode: return rdflib.Variable(str(o.lower())) return o
def load(kb, goal, identification, base): kb_stream, goal_stream = kb, goal implies = rdflib.URIRef("http://www.w3.org/2000/10/swap/log#implies") store = OrderedStore() kb_graph = rdflib.Graph(store=store, identifier=base) kb_conjunctive = rdflib.ConjunctiveGraph(store=store, identifier=base) kb_graph.parse(kb_stream, format='n3', publicID=base) if not nolog: log('---kb:') try: for l in kb_graph.serialize(format='n3').splitlines(): log(l.decode('utf8')) except Exception as e: log(str(e)) log('---kb quads:') for l in kb_conjunctive.serialize(format='nquads').splitlines(): log(l.decode('utf8')) log('---') def fixup3(o): if isinstance(o, rdflib.Graph): # r = URIRef('file:///#' + o.identifier.n3().strip('_:')) #from IPython import embed; embed(); return r return o def fixup2(o): if type(o) == rdflib.BNode: return rdflib.Variable(str(o.lower())) return o def fixup(spo): s, p, o = spo return (fixup2(s), fixup2(p), fixup2(o)) rules = [] head_triples_triples_id = 0 kb_graph_triples = [fixup(x) for x in kb_graph.triples((None, None, None))] facts = GraphTuple( Triple(un_move_me_ize_pred(fixup3(x[1])), [fixup3(x[0]), fixup3(x[2])]) for x in kb_graph_triples) facts.id = head_triples_triples_id head_triples_triples_id += 1 for kb_graph_triple_idx, (s, p, o) in enumerate(kb_graph_triples): if p == implies: body = Graph() head_triples = [ fixup(x) for x in kb_conjunctive.triples((None, None, None, o)) ] head_triples_triples = Graph() for triple in [ Triple(fixup3(x[1]), [fixup3(x[0]), fixup3(x[2])]) for x in head_triples ]: move = False if triple.pred == URIRef( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#move_me_to_body_first' ): triple.pred = URIRef( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first') move = True if triple.pred == URIRef( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#move_me_to_body_rest' ): triple.pred = URIRef( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest') move = True if move: body.append(triple) else: head_triples_triples.append(triple) for body_triple in [ fixup(x) for x in kb_conjunctive.triples((None, None, None, s)) ]: body.append( Triple((un_move_me_ize_pred(fixup3(body_triple[1]))), [fixup3(body_triple[0]), fixup3(body_triple[2])])) #body.reverse() to_expand = [] for triple in head_triples_triples + body: for thing in triple.args: if type(thing) == rdflib.Variable: if str(thing).endswith('_'): to_expand.append(thing) for thing in to_expand: body.insert( 0, Triple( rdflib.RDF.first, [thing, rdflib.Variable(str(thing)[:-1] + 'f')])) body.insert( 0, Triple( rdflib.RDF.rest, [thing, rdflib.Variable(str(thing)[:-1] + 'r')])) body = GraphTuple(body) head_triples_triples = GraphTuple(head_triples_triples) head_triples_triples.id = head_triples_triples_id head_triples_triples_id += 1 # if len(head_triples_triples) > 1: # with open(_rules_file_name, 'a') as ru: # ru.write("expanded rules for " + head_triples_triples.str(shorten) + ":\n") for head_triple_idx in range(len(head_triples_triples)): rules.append(Rule(head_triples_triples, head_triple_idx, body)) if len(head_triples_triples) > 1: with open(_rules_file_name, 'a') as ru: ru.write("\n\n") else: rules.append(Rule(facts, kb_graph_triple_idx, GraphTuple())) goal_rdflib_graph = rdflib.ConjunctiveGraph(store=OrderedStore(), identifier=base) goal_rdflib_graph.parse(goal_stream, format='n3', publicID=base) if not nolog: log('---goal:') try: for l in goal_rdflib_graph.serialize(format='n3').splitlines(): log(l.decode('utf8')) except Exception as e: log(str(e)) log('---goal nq:') for l in goal_rdflib_graph.serialize(format='nquads').splitlines(): log(l.decode('utf8')) log('---') goal = Graph() for s, p, o in [ fixup(x) for x in goal_rdflib_graph.triples((None, None, None, None)) ]: goal.append( Triple(un_move_me_ize_pred(fixup3(p)), [fixup3(s), fixup3(o)])) #goal.reverse() goal = GraphTuple(goal) query_rule = Rule(GraphTuple(), None, goal) return rules, query_rule, goal
def __init__(self, name, **kwargs): super(Variable, self).__init__() self.var = rdflib.Variable(name)