Mercurial > repos > shellac > guppy_basecaller
diff env/lib/python3.7/site-packages/rdflib/graph.py @ 0:26e78fe6e8c4 draft
"planemo upload commit c699937486c35866861690329de38ec1a5d9f783"
| author | shellac |
|---|---|
| date | Sat, 02 May 2020 07:14:21 -0400 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/env/lib/python3.7/site-packages/rdflib/graph.py Sat May 02 07:14:21 2020 -0400 @@ -0,0 +1,1954 @@ +from rdflib.term import Literal # required for doctests +assert Literal # avoid warning +from rdflib.namespace import Namespace # required for doctests +assert Namespace # avoid warning +from rdflib.py3compat import format_doctest_out + +__doc__ = format_doctest_out("""\ + +RDFLib defines the following kinds of Graphs: + +* :class:`~rdflib.graph.Graph` +* :class:`~rdflib.graph.QuotedGraph` +* :class:`~rdflib.graph.ConjunctiveGraph` +* :class:`~rdflib.graph.Dataset` + +Graph +----- + +An RDF graph is a set of RDF triples. Graphs support the python ``in`` +operator, as well as iteration and some operations like union, +difference and intersection. + +see :class:`~rdflib.graph.Graph` + +Conjunctive Graph +----------------- + +A Conjunctive Graph is the most relevant collection of graphs that are +considered to be the boundary for closed world assumptions. This +boundary is equivalent to that of the store instance (which is itself +uniquely identified and distinct from other instances of +:class:`Store` that signify other Conjunctive Graphs). It is +equivalent to all the named graphs within it and associated with a +``_default_`` graph which is automatically assigned a :class:`BNode` +for an identifier - if one isn't given. + +see :class:`~rdflib.graph.ConjunctiveGraph` + +Quoted graph +------------ + +The notion of an RDF graph [14] is extended to include the concept of +a formula node. A formula node may occur wherever any other kind of +node can appear. Associated with a formula node is an RDF graph that +is completely disjoint from all other graphs; i.e. has no nodes in +common with any other graph. (It may contain the same labels as other +RDF graphs; because this is, by definition, a separate graph, +considerations of tidiness do not apply between the graph at a formula +node and any other graph.) + +This is intended to map the idea of "{ N3-expression }" that is used +by N3 into an RDF graph upon which RDF semantics is defined. + +see :class:`~rdflib.graph.QuotedGraph` + +Dataset +------- + +The RDF 1.1 Dataset, a small extension to the Conjunctive Graph. The +primary term is "graphs in the datasets" and not "contexts with quads" +so there is a separate method to set/retrieve a graph in a dataset and +to operate with dataset graphs. As a consequence of this approach, +dataset graphs cannot be identified with blank nodes, a name is always +required (RDFLib will automatically add a name if one is not provided +at creation time). This implementation includes a convenience method +to directly add a single quad to a dataset graph. + +see :class:`~rdflib.graph.Dataset` + +Working with graphs +=================== + +Instantiating Graphs with default store (IOMemory) and default identifier +(a BNode): + + >>> g = Graph() + >>> g.store.__class__ + <class 'rdflib.plugins.memory.IOMemory'> + >>> g.identifier.__class__ + <class 'rdflib.term.BNode'> + +Instantiating Graphs with a IOMemory store and an identifier - +<http://rdflib.net>: + + >>> g = Graph('IOMemory', URIRef("http://rdflib.net")) + >>> g.identifier + rdflib.term.URIRef(%(u)s'http://rdflib.net') + >>> str(g) # doctest: +NORMALIZE_WHITESPACE + "<http://rdflib.net> a rdfg:Graph;rdflib:storage + [a rdflib:Store;rdfs:label 'IOMemory']." + +Creating a ConjunctiveGraph - The top level container for all named Graphs +in a 'database': + + >>> g = ConjunctiveGraph() + >>> str(g.default_context) + "[a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'IOMemory']]." + +Adding / removing reified triples to Graph and iterating over it directly or +via triple pattern: + + >>> g = Graph() + >>> statementId = BNode() + >>> print(len(g)) + 0 + >>> g.add((statementId, RDF.type, RDF.Statement)) + >>> g.add((statementId, RDF.subject, + ... URIRef(%(u)s'http://rdflib.net/store/ConjunctiveGraph'))) + >>> g.add((statementId, RDF.predicate, RDFS.label)) + >>> g.add((statementId, RDF.object, Literal("Conjunctive Graph"))) + >>> print(len(g)) + 4 + >>> for s, p, o in g: + ... print(type(s)) + ... + <class 'rdflib.term.BNode'> + <class 'rdflib.term.BNode'> + <class 'rdflib.term.BNode'> + <class 'rdflib.term.BNode'> + + >>> for s, p, o in g.triples((None, RDF.object, None)): + ... print(o) + ... + Conjunctive Graph + >>> g.remove((statementId, RDF.type, RDF.Statement)) + >>> print(len(g)) + 3 + +``None`` terms in calls to :meth:`~rdflib.graph.Graph.triples` can be +thought of as "open variables". + +Graph support set-theoretic operators, you can add/subtract graphs, as +well as intersection (with multiplication operator g1*g2) and xor (g1 +^ g2). + +Note that BNode IDs are kept when doing set-theoretic operations, this +may or may not be what you want. Two named graphs within the same +application probably want share BNode IDs, two graphs with data from +different sources probably not. If your BNode IDs are all generated +by RDFLib they are UUIDs and unique. + + >>> g1 = Graph() + >>> g2 = Graph() + >>> u = URIRef(%(u)s'http://example.com/foo') + >>> g1.add([u, RDFS.label, Literal('foo')]) + >>> g1.add([u, RDFS.label, Literal('bar')]) + >>> g2.add([u, RDFS.label, Literal('foo')]) + >>> g2.add([u, RDFS.label, Literal('bing')]) + >>> len(g1 + g2) # adds bing as label + 3 + >>> len(g1 - g2) # removes foo + 1 + >>> len(g1 * g2) # only foo + 1 + >>> g1 += g2 # now g1 contains everything + + +Graph Aggregation - ConjunctiveGraphs and ReadOnlyGraphAggregate within +the same store: + + >>> store = plugin.get('IOMemory', Store)() + >>> g1 = Graph(store) + >>> g2 = Graph(store) + >>> g3 = Graph(store) + >>> stmt1 = BNode() + >>> stmt2 = BNode() + >>> stmt3 = BNode() + >>> g1.add((stmt1, RDF.type, RDF.Statement)) + >>> g1.add((stmt1, RDF.subject, + ... URIRef(%(u)s'http://rdflib.net/store/ConjunctiveGraph'))) + >>> g1.add((stmt1, RDF.predicate, RDFS.label)) + >>> g1.add((stmt1, RDF.object, Literal("Conjunctive Graph"))) + >>> g2.add((stmt2, RDF.type, RDF.Statement)) + >>> g2.add((stmt2, RDF.subject, + ... URIRef(%(u)s'http://rdflib.net/store/ConjunctiveGraph'))) + >>> g2.add((stmt2, RDF.predicate, RDF.type)) + >>> g2.add((stmt2, RDF.object, RDFS.Class)) + >>> g3.add((stmt3, RDF.type, RDF.Statement)) + >>> g3.add((stmt3, RDF.subject, + ... URIRef(%(u)s'http://rdflib.net/store/ConjunctiveGraph'))) + >>> g3.add((stmt3, RDF.predicate, RDFS.comment)) + >>> g3.add((stmt3, RDF.object, Literal( + ... "The top-level aggregate graph - The sum " + + ... "of all named graphs within a Store"))) + >>> len(list(ConjunctiveGraph(store).subjects(RDF.type, RDF.Statement))) + 3 + >>> len(list(ReadOnlyGraphAggregate([g1,g2]).subjects( + ... RDF.type, RDF.Statement))) + 2 + +ConjunctiveGraphs have a :meth:`~rdflib.graph.ConjunctiveGraph.quads` method +which returns quads instead of triples, where the fourth item is the Graph +(or subclass thereof) instance in which the triple was asserted: + + >>> uniqueGraphNames = set( + ... [graph.identifier for s, p, o, graph in ConjunctiveGraph(store + ... ).quads((None, RDF.predicate, None))]) + >>> len(uniqueGraphNames) + 3 + >>> unionGraph = ReadOnlyGraphAggregate([g1, g2]) + >>> uniqueGraphNames = set( + ... [graph.identifier for s, p, o, graph in unionGraph.quads( + ... (None, RDF.predicate, None))]) + >>> len(uniqueGraphNames) + 2 + +Parsing N3 from a string + + >>> g2 = Graph() + >>> src = ''' + ... @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . + ... @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . + ... [ a rdf:Statement ; + ... rdf:subject <http://rdflib.net/store#ConjunctiveGraph>; + ... rdf:predicate rdfs:label; + ... rdf:object "Conjunctive Graph" ] . + ... ''' + >>> g2 = g2.parse(data=src, format='n3') + >>> print(len(g2)) + 4 + +Using Namespace class: + + >>> RDFLib = Namespace('http://rdflib.net/') + >>> RDFLib.ConjunctiveGraph + rdflib.term.URIRef(%(u)s'http://rdflib.net/ConjunctiveGraph') + >>> RDFLib['Graph'] + rdflib.term.URIRef(%(u)s'http://rdflib.net/Graph') + +""") + +import logging +logger = logging.getLogger(__name__) + +# import md5 +import random +import warnings + +from hashlib import md5 + +try: + from io import BytesIO + assert BytesIO +except ImportError: + try: + from io import StringIO as BytesIO + assert BytesIO + except ImportError: + from io import StringIO as BytesIO + assert BytesIO + +from rdflib.namespace import RDF, RDFS, SKOS + +from rdflib import plugin, exceptions, query + +from rdflib.term import Node, URIRef, Genid +from rdflib.term import BNode + +import rdflib.term + +from rdflib.paths import Path + +from rdflib.store import Store +from rdflib.serializer import Serializer +from rdflib.parser import Parser +from rdflib.parser import create_input_source +from rdflib.namespace import NamespaceManager +from rdflib.resource import Resource +from rdflib.collection import Collection +from rdflib import py3compat +b = py3compat.b + +import os +import shutil +import tempfile +from urllib.parse import urlparse + +__all__ = [ + 'Graph', 'ConjunctiveGraph', 'QuotedGraph', 'Seq', + 'ModificationException', 'Dataset', + 'UnSupportedAggregateOperation', 'ReadOnlyGraphAggregate'] + + +class Graph(Node): + """An RDF Graph + + The constructor accepts one argument, the 'store' + that will be used to store the graph data (see the 'store' + package for stores currently shipped with rdflib). + + Stores can be context-aware or unaware. Unaware stores take up + (some) less space but cannot support features that require + context, such as true merging/demerging of sub-graphs and + provenance. + + The Graph constructor can take an identifier which identifies the Graph + by name. If none is given, the graph is assigned a BNode for its + identifier. + For more on named graphs, see: http://www.w3.org/2004/03/trix/ + + """ + + def __init__(self, store='default', identifier=None, + namespace_manager=None): + super(Graph, self).__init__() + self.__identifier = identifier or BNode() + + if not isinstance(self.__identifier, Node): + self.__identifier = URIRef(self.__identifier) + + if not isinstance(store, Store): + # TODO: error handling + self.__store = store = plugin.get(store, Store)() + else: + self.__store = store + self.__namespace_manager = namespace_manager + self.context_aware = False + self.formula_aware = False + self.default_union = False + + def __get_store(self): + return self.__store + store = property(__get_store) # read-only attr + + def __get_identifier(self): + return self.__identifier + identifier = property(__get_identifier) # read-only attr + + def _get_namespace_manager(self): + if self.__namespace_manager is None: + self.__namespace_manager = NamespaceManager(self) + return self.__namespace_manager + + def _set_namespace_manager(self, nm): + self.__namespace_manager = nm + + namespace_manager = property(_get_namespace_manager, + _set_namespace_manager, + doc="this graph's namespace-manager") + + def __repr__(self): + return "<Graph identifier=%s (%s)>" % (self.identifier, type(self)) + + def __str__(self): + if isinstance(self.identifier, URIRef): + return ("%s a rdfg:Graph;rdflib:storage " + + "[a rdflib:Store;rdfs:label '%s'].") % ( + self.identifier.n3(), + self.store.__class__.__name__) + else: + return ("[a rdfg:Graph;rdflib:storage " + + "[a rdflib:Store;rdfs:label '%s']].") % ( + self.store.__class__.__name__) + + def toPython(self): + return self + + def destroy(self, configuration): + """Destroy the store identified by `configuration` if supported""" + self.__store.destroy(configuration) + + # Transactional interfaces (optional) + def commit(self): + """Commits active transactions""" + self.__store.commit() + + def rollback(self): + """Rollback active transactions""" + self.__store.rollback() + + def open(self, configuration, create=False): + """Open the graph store + + Might be necessary for stores that require opening a connection to a + database or acquiring some resource. + """ + return self.__store.open(configuration, create) + + def close(self, commit_pending_transaction=False): + """Close the graph store + + Might be necessary for stores that require closing a connection to a + database or releasing some resource. + """ + self.__store.close( + commit_pending_transaction=commit_pending_transaction) + + def add(self, xxx_todo_changeme): + """Add a triple with self as context""" + (s, p, o) = xxx_todo_changeme + assert isinstance(s, Node), \ + "Subject %s must be an rdflib term" % (s,) + assert isinstance(p, Node), \ + "Predicate %s must be an rdflib term" % (p,) + assert isinstance(o, Node), \ + "Object %s must be an rdflib term" % (o,) + self.__store.add((s, p, o), self, quoted=False) + + def addN(self, quads): + """Add a sequence of triple with context""" + + self.__store.addN((s, p, o, c) for s, p, o, c in quads + if isinstance(c, Graph) + and c.identifier is self.identifier + and _assertnode(s,p,o) + ) + + def remove(self, xxx_todo_changeme1): + """Remove a triple from the graph + + If the triple does not provide a context attribute, removes the triple + from all contexts. + """ + (s, p, o) = xxx_todo_changeme1 + self.__store.remove((s, p, o), context=self) + + def triples(self, xxx_todo_changeme2): + """Generator over the triple store + + Returns triples that match the given triple pattern. If triple pattern + does not provide a context, all contexts will be searched. + """ + (s, p, o) = xxx_todo_changeme2 + if isinstance(p, Path): + for _s, _o in p.eval(self, s, o): + yield (_s, p, _o) + else: + for (s, p, o), cg in self.__store.triples((s, p, o), context=self): + yield (s, p, o) + + @py3compat.format_doctest_out + def __getitem__(self, item): + """ + A graph can be "sliced" as a shortcut for the triples method + The python slice syntax is (ab)used for specifying triples. + A generator over matches is returned, + the returned tuples include only the parts not given + + >>> import rdflib + >>> g = rdflib.Graph() + >>> g.add((rdflib.URIRef('urn:bob'), rdflib.RDFS.label, rdflib.Literal('Bob'))) + + >>> list(g[rdflib.URIRef('urn:bob')]) # all triples about bob + [(rdflib.term.URIRef(%(u)s'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.Literal(%(u)s'Bob'))] + + >>> list(g[:rdflib.RDFS.label]) # all label triples + [(rdflib.term.URIRef(%(u)s'urn:bob'), rdflib.term.Literal(%(u)s'Bob'))] + + >>> list(g[::rdflib.Literal('Bob')]) # all triples with bob as object + [(rdflib.term.URIRef(%(u)s'urn:bob'), rdflib.term.URIRef(%(u)s'http://www.w3.org/2000/01/rdf-schema#label'))] + + Combined with SPARQL paths, more complex queries can be + written concisely: + + Name of all Bobs friends: + + g[bob : FOAF.knows/FOAF.name ] + + Some label for Bob: + + g[bob : DC.title|FOAF.name|RDFS.label] + + All friends and friends of friends of Bob + + g[bob : FOAF.knows * '+'] + + etc. + + .. versionadded:: 4.0 + + """ + + if isinstance(item, slice): + + s,p,o=item.start,item.stop,item.step + if s is None and p is None and o is None: + return self.triples((s,p,o)) + elif s is None and p is None: + return self.subject_predicates(o) + elif s is None and o is None: + return self.subject_objects(p) + elif p is None and o is None: + return self.predicate_objects(s) + elif s is None: + return self.subjects(p,o) + elif p is None: + return self.predicates(s,o) + elif o is None: + return self.objects(s,p) + else: + # all given + return (s,p,o) in self + + elif isinstance(item, (Path,Node)): + + return self.predicate_objects(item) + + else: + raise TypeError("You can only index a graph by a single rdflib term or path, or a slice of rdflib terms.") + + def __len__(self): + """Returns the number of triples in the graph + + If context is specified then the number of triples in the context is + returned instead. + """ + return self.__store.__len__(context=self) + + def __iter__(self): + """Iterates over all triples in the store""" + return self.triples((None, None, None)) + + def __contains__(self, triple): + """Support for 'triple in graph' syntax""" + for triple in self.triples(triple): + return True + return False + + def __hash__(self): + return hash(self.identifier) + + def md5_term_hash(self): + d = md5(str(self.identifier)) + d.update("G") + return d.hexdigest() + + def __cmp__(self, other): + if other is None: + return -1 + elif isinstance(other, Graph): + return cmp(self.identifier, other.identifier) + else: + # Note if None is considered equivalent to owl:Nothing + # Then perhaps a graph with length 0 should be considered + # equivalent to None (if compared to it)? + return 1 + + def __eq__(self, other): + return isinstance(other, Graph) \ + and self.identifier == other.identifier + + def __lt__(self, other): + return (other is None) \ + or (isinstance(other, Graph) + and self.identifier < other.identifier) + + def __le__(self, other): + return self < other or self == other + + def __gt__(self, other): + return (isinstance(other, Graph) + and self.identifier > other.identifier) \ + or (other is not None) + + def __ge__(self, other): + return self > other or self == other + + def __iadd__(self, other): + """Add all triples in Graph other to Graph. + BNode IDs are not changed.""" + self.addN((s, p, o, self) for s, p, o in other) + return self + + def __isub__(self, other): + """Subtract all triples in Graph other from Graph. + BNode IDs are not changed.""" + for triple in other: + self.remove(triple) + return self + + def __add__(self, other): + """Set-theoretic union + BNode IDs are not changed.""" + retval = Graph() + for (prefix, uri) in set( + list(self.namespaces()) + list(other.namespaces())): + retval.bind(prefix, uri) + for x in self: + retval.add(x) + for y in other: + retval.add(y) + return retval + + def __mul__(self, other): + """Set-theoretic intersection. + BNode IDs are not changed.""" + retval = Graph() + for x in other: + if x in self: + retval.add(x) + return retval + + def __sub__(self, other): + """Set-theoretic difference. + BNode IDs are not changed.""" + retval = Graph() + for x in self: + if not x in other: + retval.add(x) + return retval + + def __xor__(self, other): + """Set-theoretic XOR. + BNode IDs are not changed.""" + return (self - other) + (other - self) + + __or__ = __add__ + __and__ = __mul__ + + # Conv. methods + + def set(self, triple): + """Convenience method to update the value of object + + Remove any existing triples for subject and predicate before adding + (subject, predicate, object). + """ + (subject, predicate, object_) = triple + assert subject is not None, \ + "s can't be None in .set([s,p,o]), as it would remove (*, p, *)" + assert predicate is not None, \ + "p can't be None in .set([s,p,o]), as it would remove (s, *, *)" + self.remove((subject, predicate, None)) + self.add((subject, predicate, object_)) + + def subjects(self, predicate=None, object=None): + """A generator of subjects with the given predicate and object""" + for s, p, o in self.triples((None, predicate, object)): + yield s + + def predicates(self, subject=None, object=None): + """A generator of predicates with the given subject and object""" + for s, p, o in self.triples((subject, None, object)): + yield p + + def objects(self, subject=None, predicate=None): + """A generator of objects with the given subject and predicate""" + for s, p, o in self.triples((subject, predicate, None)): + yield o + + def subject_predicates(self, object=None): + """A generator of (subject, predicate) tuples for the given object""" + for s, p, o in self.triples((None, None, object)): + yield s, p + + def subject_objects(self, predicate=None): + """A generator of (subject, object) tuples for the given predicate""" + for s, p, o in self.triples((None, predicate, None)): + yield s, o + + def predicate_objects(self, subject=None): + """A generator of (predicate, object) tuples for the given subject""" + for s, p, o in self.triples((subject, None, None)): + yield p, o + + def triples_choices(self, xxx_todo_changeme3, context=None): + (subject, predicate, object_) = xxx_todo_changeme3 + for (s, p, o), cg in self.store.triples_choices( + (subject, predicate, object_), context=self): + yield (s, p, o) + + def value(self, subject=None, predicate=RDF.value, object=None, + default=None, any=True): + """Get a value for a pair of two criteria + + Exactly one of subject, predicate, object must be None. Useful if one + knows that there may only be one value. + + It is one of those situations that occur a lot, hence this + 'macro' like utility + + Parameters: + subject, predicate, object -- exactly one must be None + default -- value to be returned if no values found + any -- if True, return any value in the case there is more than one, + else, raise UniquenessError + """ + retval = default + + if (subject is None and predicate is None) or \ + (subject is None and object is None) or \ + (predicate is None and object is None): + return None + + if object is None: + values = self.objects(subject, predicate) + if subject is None: + values = self.subjects(predicate, object) + if predicate is None: + values = self.predicates(subject, object) + + try: + retval = next(values) + except StopIteration: + retval = default + else: + if any is False: + try: + next(values) + msg = ("While trying to find a value for (%s, %s, %s) the" + " following multiple values where found:\n" % + (subject, predicate, object)) + triples = self.store.triples( + (subject, predicate, object), None) + for (s, p, o), contexts in triples: + msg += "(%s, %s, %s)\n (contexts: %s)\n" % ( + s, p, o, list(contexts)) + raise exceptions.UniquenessError(msg) + except StopIteration: + pass + return retval + + def label(self, subject, default=''): + """Query for the RDFS.label of the subject + + Return default if no label exists or any label if multiple exist. + """ + if subject is None: + return default + return self.value(subject, RDFS.label, default=default, any=True) + + @py3compat.format_doctest_out + def preferredLabel(self, subject, lang=None, default=None, + labelProperties=(SKOS.prefLabel, RDFS.label)): + """ + Find the preferred label for subject. + + By default prefers skos:prefLabels over rdfs:labels. In case at least + one prefLabel is found returns those, else returns labels. In case a + language string (e.g., 'en', 'de' or even '' for no lang-tagged + literals) is given, only such labels will be considered. + + Return a list of (labelProp, label) pairs, where labelProp is either + skos:prefLabel or rdfs:label. + + >>> from rdflib import ConjunctiveGraph, URIRef, RDFS, Literal + >>> from rdflib.namespace import SKOS + >>> from pprint import pprint + >>> g = ConjunctiveGraph() + >>> u = URIRef(%(u)s'http://example.com/foo') + >>> g.add([u, RDFS.label, Literal('foo')]) + >>> g.add([u, RDFS.label, Literal('bar')]) + >>> pprint(sorted(g.preferredLabel(u))) + [(rdflib.term.URIRef(%(u)s'http://www.w3.org/2000/01/rdf-schema#label'), + rdflib.term.Literal(%(u)s'bar')), + (rdflib.term.URIRef(%(u)s'http://www.w3.org/2000/01/rdf-schema#label'), + rdflib.term.Literal(%(u)s'foo'))] + >>> g.add([u, SKOS.prefLabel, Literal('bla')]) + >>> pprint(g.preferredLabel(u)) + [(rdflib.term.URIRef(%(u)s'http://www.w3.org/2004/02/skos/core#prefLabel'), + rdflib.term.Literal(%(u)s'bla'))] + >>> g.add([u, SKOS.prefLabel, Literal('blubb', lang='en')]) + >>> sorted(g.preferredLabel(u)) #doctest: +NORMALIZE_WHITESPACE + [(rdflib.term.URIRef(%(u)s'http://www.w3.org/2004/02/skos/core#prefLabel'), + rdflib.term.Literal(%(u)s'bla')), + (rdflib.term.URIRef(%(u)s'http://www.w3.org/2004/02/skos/core#prefLabel'), + rdflib.term.Literal(%(u)s'blubb', lang='en'))] + >>> g.preferredLabel(u, lang='') #doctest: +NORMALIZE_WHITESPACE + [(rdflib.term.URIRef(%(u)s'http://www.w3.org/2004/02/skos/core#prefLabel'), + rdflib.term.Literal(%(u)s'bla'))] + >>> pprint(g.preferredLabel(u, lang='en')) + [(rdflib.term.URIRef(%(u)s'http://www.w3.org/2004/02/skos/core#prefLabel'), + rdflib.term.Literal(%(u)s'blubb', lang='en'))] + """ + + if default is None: + default = [] + + # setup the language filtering + if lang is not None: + if lang == '': # we only want not language-tagged literals + langfilter = lambda l: l.language is None + else: + langfilter = lambda l: l.language == lang + else: # we don't care about language tags + langfilter = lambda l: True + + for labelProp in labelProperties: + labels = list(filter(langfilter, self.objects(subject, labelProp))) + if len(labels) == 0: + continue + else: + return [(labelProp, l) for l in labels] + return default + + def comment(self, subject, default=''): + """Query for the RDFS.comment of the subject + + Return default if no comment exists + """ + if subject is None: + return default + return self.value(subject, RDFS.comment, default=default, any=True) + + def items(self, list): + """Generator over all items in the resource specified by list + + list is an RDF collection. + """ + chain = set([list]) + while list: + item = self.value(list, RDF.first) + if item is not None: + yield item + list = self.value(list, RDF.rest) + if list in chain: + raise ValueError("List contains a recursive rdf:rest reference") + chain.add(list) + + def transitiveClosure(self, func, arg, seen=None): + """ + Generates transitive closure of a user-defined + function against the graph + + >>> from rdflib.collection import Collection + >>> g=Graph() + >>> a=BNode('foo') + >>> b=BNode('bar') + >>> c=BNode('baz') + >>> g.add((a,RDF.first,RDF.type)) + >>> g.add((a,RDF.rest,b)) + >>> g.add((b,RDF.first,RDFS.label)) + >>> g.add((b,RDF.rest,c)) + >>> g.add((c,RDF.first,RDFS.comment)) + >>> g.add((c,RDF.rest,RDF.nil)) + >>> def topList(node,g): + ... for s in g.subjects(RDF.rest,node): + ... yield s + >>> def reverseList(node,g): + ... for f in g.objects(node,RDF.first): + ... print(f) + ... for s in g.subjects(RDF.rest,node): + ... yield s + + >>> [rt for rt in g.transitiveClosure( + ... topList,RDF.nil)] # doctest: +NORMALIZE_WHITESPACE + [rdflib.term.BNode('baz'), + rdflib.term.BNode('bar'), + rdflib.term.BNode('foo')] + + >>> [rt for rt in g.transitiveClosure( + ... reverseList,RDF.nil)] # doctest: +NORMALIZE_WHITESPACE + http://www.w3.org/2000/01/rdf-schema#comment + http://www.w3.org/2000/01/rdf-schema#label + http://www.w3.org/1999/02/22-rdf-syntax-ns#type + [rdflib.term.BNode('baz'), + rdflib.term.BNode('bar'), + rdflib.term.BNode('foo')] + + """ + if seen is None: + seen = {} + elif arg in seen: + return + seen[arg] = 1 + for rt in func(arg, self): + yield rt + for rt_2 in self.transitiveClosure(func, rt, seen): + yield rt_2 + + def transitive_objects(self, subject, property, remember=None): + """Transitively generate objects for the ``property`` relationship + + Generated objects belong to the depth first transitive closure of the + ``property`` relationship starting at ``subject``. + """ + if remember is None: + remember = {} + if subject in remember: + return + remember[subject] = 1 + yield subject + for object in self.objects(subject, property): + for o in self.transitive_objects(object, property, remember): + yield o + + def transitive_subjects(self, predicate, object, remember=None): + """Transitively generate objects for the ``property`` relationship + + Generated objects belong to the depth first transitive closure of the + ``property`` relationship starting at ``subject``. + """ + if remember is None: + remember = {} + if object in remember: + return + remember[object] = 1 + yield object + for subject in self.subjects(predicate, object): + for s in self.transitive_subjects(predicate, subject, remember): + yield s + + def seq(self, subject): + """Check if subject is an rdf:Seq + + If yes, it returns a Seq class instance, None otherwise. + """ + if (subject, RDF.type, RDF.Seq) in self: + return Seq(self, subject) + else: + return None + + def qname(self, uri): + return self.namespace_manager.qname(uri) + + def compute_qname(self, uri, generate=True): + return self.namespace_manager.compute_qname(uri, generate) + + def bind(self, prefix, namespace, override=True): + """Bind prefix to namespace + + If override is True will bind namespace to given prefix even + if namespace was already bound to a different prefix. + + for example: graph.bind('foaf', 'http://xmlns.com/foaf/0.1/') + + """ + return self.namespace_manager.bind( + prefix, namespace, override=override) + + def namespaces(self): + """Generator over all the prefix, namespace tuples""" + for prefix, namespace in self.namespace_manager.namespaces(): + yield prefix, namespace + + def absolutize(self, uri, defrag=1): + """Turn uri into an absolute URI if it's not one already""" + return self.namespace_manager.absolutize(uri, defrag) + + def serialize(self, destination=None, format="xml", + base=None, encoding=None, **args): + """Serialize the Graph to destination + + If destination is None serialize method returns the serialization as a + string. Format defaults to xml (AKA rdf/xml). + + Format support can be extended with plugins, + but 'xml', 'n3', 'turtle', 'nt', 'pretty-xml', 'trix', 'trig' and 'nquads' are built in. + """ + serializer = plugin.get(format, Serializer)(self) + if destination is None: + stream = BytesIO() + serializer.serialize(stream, base=base, encoding=encoding, **args) + return stream.getvalue() + if hasattr(destination, "write"): + stream = destination + serializer.serialize(stream, base=base, encoding=encoding, **args) + else: + location = destination + scheme, netloc, path, params, _query, fragment = urlparse(location) + if netloc != "": + print(("WARNING: not saving as location" + + "is not a local file reference")) + return + fd, name = tempfile.mkstemp() + stream = os.fdopen(fd, "wb") + serializer.serialize(stream, base=base, encoding=encoding, **args) + stream.close() + if hasattr(shutil, "move"): + shutil.move(name, path) + else: + shutil.copy(name, path) + os.remove(name) + + def parse(self, source=None, publicID=None, format=None, + location=None, file=None, data=None, **args): + """ + Parse source adding the resulting triples to the Graph. + + The source is specified using one of source, location, file or + data. + + :Parameters: + + - `source`: An InputSource, file-like object, or string. In the case + of a string the string is the location of the source. + - `location`: A string indicating the relative or absolute URL of the + source. Graph's absolutize method is used if a relative location + is specified. + - `file`: A file-like object. + - `data`: A string containing the data to be parsed. + - `format`: Used if format can not be determined from source. + Defaults to rdf/xml. Format support can be extended with plugins, + but 'xml', 'n3', 'nt', 'trix', 'rdfa' are built in. + - `publicID`: the logical URI to use as the document base. If None + specified the document location is used (at least in the case where + there is a document location). + + :Returns: + + - self, the graph instance. + + Examples: + + >>> my_data = ''' + ... <rdf:RDF + ... xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' + ... xmlns:rdfs='http://www.w3.org/2000/01/rdf-schema#' + ... > + ... <rdf:Description> + ... <rdfs:label>Example</rdfs:label> + ... <rdfs:comment>This is really just an example.</rdfs:comment> + ... </rdf:Description> + ... </rdf:RDF> + ... ''' + >>> import tempfile + >>> fd, file_name = tempfile.mkstemp() + >>> f = os.fdopen(fd, 'w') + >>> dummy = f.write(my_data) # Returns num bytes written on py3 + >>> f.close() + + >>> g = Graph() + >>> result = g.parse(data=my_data, format="application/rdf+xml") + >>> len(g) + 2 + + >>> g = Graph() + >>> result = g.parse(location=file_name, format="application/rdf+xml") + >>> len(g) + 2 + + >>> g = Graph() + >>> with open(file_name, "r") as f: + ... result = g.parse(f, format="application/rdf+xml") + >>> len(g) + 2 + + >>> os.remove(file_name) + + """ + + source = create_input_source(source=source, publicID=publicID, + location=location, file=file, + data=data, format=format) + if format is None: + format = source.content_type + if format is None: + # raise Exception("Could not determine format for %r. You can" + \ + # "expicitly specify one with the format argument." % source) + format = "application/rdf+xml" + parser = plugin.get(format, Parser)() + try: + parser.parse(source, self, **args) + finally: + if source.auto_close: + source.close() + return self + + def load(self, source, publicID=None, format="xml"): + self.parse(source, publicID, format) + + def query(self, query_object, processor='sparql', + result='sparql', initNs=None, initBindings=None, + use_store_provided=True, **kwargs): + """ + Query this graph. + + A type of 'prepared queries' can be realised by providing + initial variable bindings with initBindings + + Initial namespaces are used to resolve prefixes used in the query, + if none are given, the namespaces from the graph's namespace manager + are used. + + :returntype: rdflib.query.QueryResult + + """ + + initBindings = initBindings or {} + initNs = initNs or dict(self.namespaces()) + + if hasattr(self.store, "query") and use_store_provided: + try: + return self.store.query( + query_object, initNs, initBindings, + self.default_union + and '__UNION__' + or self.identifier, + **kwargs) + except NotImplementedError: + pass # store has no own implementation + + if not isinstance(result, query.Result): + result = plugin.get(result, query.Result) + if not isinstance(processor, query.Processor): + processor = plugin.get(processor, query.Processor)(self) + + return result(processor.query( + query_object, initBindings, initNs, **kwargs)) + + def update(self, update_object, processor='sparql', + initNs=None, initBindings=None, + use_store_provided=True, **kwargs): + """Update this graph with the given update query.""" + initBindings = initBindings or {} + initNs = initNs or dict(self.namespaces()) + + if hasattr(self.store, "update") and use_store_provided: + try: + return self.store.update( + update_object, initNs, initBindings, + self.default_union + and '__UNION__' + or self.identifier, + **kwargs) + except NotImplementedError: + pass # store has no own implementation + + if not isinstance(processor, query.UpdateProcessor): + processor = plugin.get(processor, query.UpdateProcessor)(self) + + return processor.update(update_object, initBindings, initNs, **kwargs) + + + def n3(self): + """return an n3 identifier for the Graph""" + return "[%s]" % self.identifier.n3() + + def __reduce__(self): + return (Graph, (self.store, self.identifier,)) + + def isomorphic(self, other): + """ + does a very basic check if these graphs are the same + If no BNodes are involved, this is accurate. + + See rdflib.compare for a correct implementation of isomorphism checks + """ + # TODO: this is only an approximation. + if len(self) != len(other): + return False + for s, p, o in self: + if not isinstance(s, BNode) and not isinstance(o, BNode): + if not (s, p, o) in other: + return False + for s, p, o in other: + if not isinstance(s, BNode) and not isinstance(o, BNode): + if not (s, p, o) in self: + return False + # TODO: very well could be a false positive at this point yet. + return True + + def connected(self): + """Check if the Graph is connected + + The Graph is considered undirectional. + + Performs a search on the Graph, starting from a random node. Then + iteratively goes depth-first through the triplets where the node is + subject and object. Return True if all nodes have been visited and + False if it cannot continue and there are still unvisited nodes left. + """ + all_nodes = list(self.all_nodes()) + discovered = [] + + # take a random one, could also always take the first one, doesn't + # really matter. + if not all_nodes: + return False + + visiting = [all_nodes[random.randrange(len(all_nodes))]] + while visiting: + x = visiting.pop() + if x not in discovered: + discovered.append(x) + for new_x in self.objects(subject=x): + if new_x not in discovered and new_x not in visiting: + visiting.append(new_x) + for new_x in self.subjects(object=x): + if new_x not in discovered and new_x not in visiting: + visiting.append(new_x) + + # optimisation by only considering length, since no new objects can + # be introduced anywhere. + if len(all_nodes) == len(discovered): + return True + else: + return False + + def all_nodes(self): + res = set(self.objects()) + res.update(self.subjects()) + return res + + def collection(self, identifier): + """Create a new ``Collection`` instance. + + Parameters: + + - ``identifier``: a URIRef or BNode instance. + + Example:: + + >>> graph = Graph() + >>> uri = URIRef("http://example.org/resource") + >>> collection = graph.collection(uri) + >>> assert isinstance(collection, Collection) + >>> assert collection.uri is uri + >>> assert collection.graph is graph + >>> collection += [ Literal(1), Literal(2) ] + """ + + return Collection(self, identifier) + + + + def resource(self, identifier): + """Create a new ``Resource`` instance. + + Parameters: + + - ``identifier``: a URIRef or BNode instance. + + Example:: + + >>> graph = Graph() + >>> uri = URIRef("http://example.org/resource") + >>> resource = graph.resource(uri) + >>> assert isinstance(resource, Resource) + >>> assert resource.identifier is uri + >>> assert resource.graph is graph + + """ + if not isinstance(identifier, Node): + identifier = URIRef(identifier) + return Resource(self, identifier) + + def _process_skolem_tuples(self, target, func): + for t in self.triples((None, None, None)): + target.add(func(t)) + + def skolemize(self, new_graph=None, bnode=None): + def do_skolemize(bnode, t): + (s, p, o) = t + if s == bnode: + s = s.skolemize() + if o == bnode: + o = o.skolemize() + return (s, p, o) + + def do_skolemize2(t): + (s, p, o) = t + if isinstance(s, BNode): + s = s.skolemize() + if isinstance(o, BNode): + o = o.skolemize() + return (s, p, o) + + retval = Graph() if new_graph is None else new_graph + + if bnode is None: + self._process_skolem_tuples(retval, do_skolemize2) + elif isinstance(bnode, BNode): + self._process_skolem_tuples( + retval, lambda t: do_skolemize(bnode, t)) + + return retval + + def de_skolemize(self, new_graph=None, uriref=None): + def do_de_skolemize(uriref, t): + (s, p, o) = t + if s == uriref: + s = s.de_skolemize() + if o == uriref: + o = o.de_skolemize() + return (s, p, o) + + def do_de_skolemize2(t): + (s, p, o) = t + if isinstance(s, Genid): + s = s.de_skolemize() + if isinstance(o, Genid): + o = o.de_skolemize() + return (s, p, o) + + retval = Graph() if new_graph is None else new_graph + + if uriref is None: + self._process_skolem_tuples(retval, do_de_skolemize2) + elif isinstance(uriref, Genid): + self._process_skolem_tuples( + retval, lambda t: do_de_skolemize(uriref, t)) + + return retval + +class ConjunctiveGraph(Graph): + + """ + A ConjunctiveGraph is an (unnamed) aggregation of all the named + graphs in a store. + + It has a ``default`` graph, whose name is associated with the + graph throughout its life. :meth:`__init__` can take an identifier + to use as the name of this default graph or it will assign a + BNode. + + All methods that add triples work against this default graph. + + All queries are carried out against the union of all graphs. + + """ + + def __init__(self, store='default', identifier=None): + super(ConjunctiveGraph, self).__init__(store, identifier=identifier) + assert self.store.context_aware, ("ConjunctiveGraph must be backed by" + " a context aware store.") + self.context_aware = True + self.default_union = True # Conjunctive! + self.default_context = Graph(store=self.store, + identifier=identifier or BNode()) + + def __str__(self): + pattern = ("[a rdflib:ConjunctiveGraph;rdflib:storage " + "[a rdflib:Store;rdfs:label '%s']]") + return pattern % self.store.__class__.__name__ + + def _spoc(self, triple_or_quad, default=False): + """ + helper method for having methods that support + either triples or quads + """ + if triple_or_quad is None: + return (None, None, None, self.default_context if default else None) + if len(triple_or_quad) == 3: + c = self.default_context if default else None + (s, p, o) = triple_or_quad + elif len(triple_or_quad) == 4: + (s, p, o, c) = triple_or_quad + c = self._graph(c) + return s,p,o,c + + + def __contains__(self, triple_or_quad): + """Support for 'triple/quad in graph' syntax""" + s,p,o,c = self._spoc(triple_or_quad) + for t in self.triples((s,p,o), context=c): + return True + return False + + + def add(self, triple_or_quad): + + """ + Add a triple or quad to the store. + + if a triple is given it is added to the default context + """ + + s,p,o,c = self._spoc(triple_or_quad, default=True) + + _assertnode(s,p,o) + + self.store.add((s, p, o), context=c, quoted=False) + + def _graph(self, c): + if c is None: return None + if not isinstance(c, Graph): + return self.get_context(c) + else: + return c + + + def addN(self, quads): + """Add a sequence of triples with context""" + + self.store.addN( + (s, p, o, self._graph(c)) for s, p, o, c in quads if + _assertnode(s, p, o) + ) + + def remove(self, triple_or_quad): + """ + Removes a triple or quads + + if a triple is given it is removed from all contexts + + a quad is removed from the given context only + + """ + s,p,o,c = self._spoc(triple_or_quad) + + self.store.remove((s, p, o), context=c) + + def triples(self, triple_or_quad, context=None): + """ + Iterate over all the triples in the entire conjunctive graph + + For legacy reasons, this can take the context to query either + as a fourth element of the quad, or as the explicit context + keyword parameter. The kw param takes precedence. + """ + + s,p,o,c = self._spoc(triple_or_quad) + context = self._graph(context or c) + + if self.default_union: + if context==self.default_context: + context = None + else: + if context is None: + context = self.default_context + + if isinstance(p, Path): + if context is None: + context = self + + for s, o in p.eval(context, s, o): + yield (s, p, o) + else: + for (s, p, o), cg in self.store.triples((s, p, o), context=context): + yield s, p, o + + def quads(self, triple_or_quad=None): + """Iterate over all the quads in the entire conjunctive graph""" + + s,p,o,c = self._spoc(triple_or_quad) + + for (s, p, o), cg in self.store.triples((s, p, o), context=c): + for ctx in cg: + yield s, p, o, ctx + + def triples_choices(self, xxx_todo_changeme4, context=None): + """Iterate over all the triples in the entire conjunctive graph""" + (s, p, o) = xxx_todo_changeme4 + if context is None: + if not self.default_union: + context=self.default_context + else: + context = self._graph(context) + + for (s1, p1, o1), cg in self.store.triples_choices((s, p, o), + context=context): + yield (s1, p1, o1) + + def __len__(self): + """Number of triples in the entire conjunctive graph""" + return self.store.__len__() + + def contexts(self, triple=None): + """Iterate over all contexts in the graph + + If triple is specified, iterate over all contexts the triple is in. + """ + for context in self.store.contexts(triple): + if isinstance(context, Graph): + # TODO: One of these should never happen and probably + # should raise an exception rather than smoothing over + # the weirdness - see #225 + yield context + else: + yield self.get_context(context) + + def get_context(self, identifier, quoted=False): + """Return a context graph for the given identifier + + identifier must be a URIRef or BNode. + """ + return Graph(store=self.store, identifier=identifier, + namespace_manager=self) + + def remove_context(self, context): + """Removes the given context from the graph""" + self.store.remove((None, None, None), context) + + def context_id(self, uri, context_id=None): + """URI#context""" + uri = uri.split("#", 1)[0] + if context_id is None: + context_id = "#context" + return URIRef(context_id, base=uri) + + def parse(self, source=None, publicID=None, format="xml", + location=None, file=None, data=None, **args): + """ + Parse source adding the resulting triples to its own context + (sub graph of this graph). + + See :meth:`rdflib.graph.Graph.parse` for documentation on arguments. + + :Returns: + + The graph into which the source was parsed. In the case of n3 + it returns the root context. + """ + + source = create_input_source( + source=source, publicID=publicID, location=location, + file=file, data=data, format=format) + + g_id = publicID and publicID or source.getPublicId() + if not isinstance(g_id, Node): + g_id = URIRef(g_id) + + context = Graph(store=self.store, identifier=g_id) + context.remove((None, None, None)) # hmm ? + context.parse(source, publicID=publicID, format=format, **args) + return context + + def __reduce__(self): + return (ConjunctiveGraph, (self.store, self.identifier)) + + + +DATASET_DEFAULT_GRAPH_ID = URIRef('urn:x-rdflib:default') + +class Dataset(ConjunctiveGraph): + __doc__ = format_doctest_out(""" + RDF 1.1 Dataset. Small extension to the Conjunctive Graph: + - the primary term is graphs in the datasets and not contexts with quads, + so there is a separate method to set/retrieve a graph in a dataset and + operate with graphs + - graphs cannot be identified with blank nodes + - added a method to directly add a single quad + + Examples of usage: + + >>> # Create a new Dataset + >>> ds = Dataset() + >>> # simple triples goes to default graph + >>> ds.add((URIRef('http://example.org/a'), + ... URIRef('http://www.example.org/b'), + ... Literal('foo'))) + >>> + >>> # Create a graph in the dataset, if the graph name has already been + >>> # used, the corresponding graph will be returned + >>> # (ie, the Dataset keeps track of the constituent graphs) + >>> g = ds.graph(URIRef('http://www.example.com/gr')) + >>> + >>> # add triples to the new graph as usual + >>> g.add( + ... (URIRef('http://example.org/x'), + ... URIRef('http://example.org/y'), + ... Literal('bar')) ) + >>> # alternatively: add a quad to the dataset -> goes to the graph + >>> ds.add( + ... (URIRef('http://example.org/x'), + ... URIRef('http://example.org/z'), + ... Literal('foo-bar'),g) ) + >>> + >>> # querying triples return them all regardless of the graph + >>> for t in ds.triples((None,None,None)): # doctest: +SKIP + ... print(t) # doctest: +NORMALIZE_WHITESPACE + (rdflib.term.URIRef(%(u)s'http://example.org/a'), + rdflib.term.URIRef(%(u)s'http://www.example.org/b'), + rdflib.term.Literal(%(u)s'foo')) + (rdflib.term.URIRef(%(u)s'http://example.org/x'), + rdflib.term.URIRef(%(u)s'http://example.org/z'), + rdflib.term.Literal(%(u)s'foo-bar')) + (rdflib.term.URIRef(%(u)s'http://example.org/x'), + rdflib.term.URIRef(%(u)s'http://example.org/y'), + rdflib.term.Literal(%(u)s'bar')) + >>> + >>> # querying quads return quads; the fourth argument can be unrestricted + >>> # or restricted to a graph + >>> for q in ds.quads((None, None, None, None)): # doctest: +SKIP + ... print(q) # doctest: +NORMALIZE_WHITESPACE + (rdflib.term.URIRef(%(u)s'http://example.org/a'), + rdflib.term.URIRef(%(u)s'http://www.example.org/b'), + rdflib.term.Literal(%(u)s'foo'), + None) + (rdflib.term.URIRef(%(u)s'http://example.org/x'), + rdflib.term.URIRef(%(u)s'http://example.org/y'), + rdflib.term.Literal(%(u)s'bar'), + rdflib.term.URIRef(%(u)s'http://www.example.com/gr')) + (rdflib.term.URIRef(%(u)s'http://example.org/x'), + rdflib.term.URIRef(%(u)s'http://example.org/z'), + rdflib.term.Literal(%(u)s'foo-bar'), + rdflib.term.URIRef(%(u)s'http://www.example.com/gr')) + >>> + >>> for q in ds.quads((None,None,None,g)): # doctest: +SKIP + ... print(q) # doctest: +NORMALIZE_WHITESPACE + (rdflib.term.URIRef(%(u)s'http://example.org/x'), + rdflib.term.URIRef(%(u)s'http://example.org/y'), + rdflib.term.Literal(%(u)s'bar'), + rdflib.term.URIRef(%(u)s'http://www.example.com/gr')) + (rdflib.term.URIRef(%(u)s'http://example.org/x'), + rdflib.term.URIRef(%(u)s'http://example.org/z'), + rdflib.term.Literal(%(u)s'foo-bar'), + rdflib.term.URIRef(%(u)s'http://www.example.com/gr')) + >>> # Note that in the call above - + >>> # ds.quads((None,None,None,'http://www.example.com/gr')) + >>> # would have been accepted, too + >>> + >>> # graph names in the dataset can be queried: + >>> for c in ds.graphs(): # doctest: +SKIP + ... print(c) # doctest: + DEFAULT + http://www.example.com/gr + >>> # A graph can be created without specifying a name; a skolemized genid + >>> # is created on the fly + >>> h = ds.graph() + >>> for c in ds.graphs(): # doctest: +SKIP + ... print(c) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + DEFAULT + http://rdlib.net/.well-known/genid/rdflib/N... + http://www.example.com/gr + >>> # Note that the Dataset.graphs() call returns names of empty graphs, + >>> # too. This can be restricted: + >>> for c in ds.graphs(empty=False): # doctest: +SKIP + ... print(c) # doctest: +NORMALIZE_WHITESPACE + DEFAULT + http://www.example.com/gr + >>> + >>> # a graph can also be removed from a dataset via ds.remove_graph(g) + + .. versionadded:: 4.0 + """) + + def __init__(self, store='default', default_union=False): + super(Dataset, self).__init__(store=store, identifier=None) + + if not self.store.graph_aware: + raise Exception("DataSet must be backed by a graph-aware store!") + self.default_context = Graph(store=self.store, identifier=DATASET_DEFAULT_GRAPH_ID) + + self.default_union = default_union + + + def __str__(self): + pattern = ("[a rdflib:Dataset;rdflib:storage " + "[a rdflib:Store;rdfs:label '%s']]") + return pattern % self.store.__class__.__name__ + + def graph(self, identifier=None): + if identifier is None: + from rdflib.term import rdflib_skolem_genid + self.bind( + "genid", "http://rdflib.net" + rdflib_skolem_genid, + override=False) + identifier = BNode().skolemize() + + g = self._graph(identifier) + + self.store.add_graph(g) + return g + + def parse(self, source=None, publicID=None, format="xml", + location=None, file=None, data=None, **args): + c = ConjunctiveGraph.parse(self, source, publicID, format, location, file, data, **args) + self.graph(c) + return c + + def add_graph(self, g): + """alias of graph for consistency""" + return self.graph(g) + + def remove_graph(self, g): + if not isinstance(g, Graph): + g = self.get_context(g) + + self.store.remove_graph(g) + if g is None or g == self.default_context: + # default graph cannot be removed + # only triples deleted, so add it back in + self.store.add_graph(self.default_context) + + def contexts(self, triple=None): + default = False + for c in super(Dataset, self).contexts(triple): + default |= c.identifier == DATASET_DEFAULT_GRAPH_ID + yield c + if not default: + yield self.graph(DATASET_DEFAULT_GRAPH_ID) + + graphs = contexts + + def quads(self, quad): + for s, p, o, c in super(Dataset, self).quads(quad): + if c.identifier==self.default_context: + yield (s, p, o, None) + else: + yield (s, p, o, c.identifier) + +class QuotedGraph(Graph): + """ + Quoted Graphs are intended to implement Notation 3 formulae. They are + associated with a required identifier that the N3 parser *must* provide + in order to maintain consistent formulae identification for scenarios + such as implication and other such processing. + """ + def __init__(self, store, identifier): + super(QuotedGraph, self).__init__(store, identifier) + + def add(self, xxx_todo_changeme5): + """Add a triple with self as context""" + (s, p, o) = xxx_todo_changeme5 + assert isinstance(s, Node), \ + "Subject %s must be an rdflib term" % (s,) + assert isinstance(p, Node), \ + "Predicate %s must be an rdflib term" % (p,) + assert isinstance(o, Node), \ + "Object %s must be an rdflib term" % (o,) + + self.store.add((s, p, o), self, quoted=True) + + def addN(self, quads): + """Add a sequence of triple with context""" + + self.store.addN( + (s, p, o, c) for s, p, o, c in quads + if isinstance(c, QuotedGraph) + and c.identifier is self.identifier + and _assertnode(s, p, o) + ) + + def n3(self): + """Return an n3 identifier for the Graph""" + return "{%s}" % self.identifier.n3() + + def __str__(self): + identifier = self.identifier.n3() + label = self.store.__class__.__name__ + pattern = ("{this rdflib.identifier %s;rdflib:storage " + "[a rdflib:Store;rdfs:label '%s']}") + return pattern % (identifier, label) + + def __reduce__(self): + return (QuotedGraph, (self.store, self.identifier)) + + +# Make sure QuotedGraph is ordered correctly +# wrt to other Terms. +# this must be done here, as the QuotedGraph cannot be +# circularily imported in term.py +rdflib.term._ORDERING[QuotedGraph]=11 + + +class Seq(object): + """Wrapper around an RDF Seq resource + + It implements a container type in Python with the order of the items + returned corresponding to the Seq content. It is based on the natural + ordering of the predicate names _1, _2, _3, etc, which is the + 'implementation' of a sequence in RDF terms. + """ + + def __init__(self, graph, subject): + """Parameters: + + - graph: + the graph containing the Seq + + - subject: + the subject of a Seq. Note that the init does not + check whether this is a Seq, this is done in whoever + creates this instance! + """ + + _list = self._list = list() + LI_INDEX = URIRef(str(RDF) + "_") + for (p, o) in graph.predicate_objects(subject): + if p.startswith(LI_INDEX): # != RDF.Seq: # + i = int(p.replace(LI_INDEX, '')) + _list.append((i, o)) + + # here is the trick: the predicates are _1, _2, _3, etc. Ie, + # by sorting the keys (by integer) we have what we want! + _list.sort() + + def toPython(self): + return self + + def __iter__(self): + """Generator over the items in the Seq""" + for _, item in self._list: + yield item + + def __len__(self): + """Length of the Seq""" + return len(self._list) + + def __getitem__(self, index): + """Item given by index from the Seq""" + index, item = self._list.__getitem__(index) + return item + + +class ModificationException(Exception): + + def __init__(self): + pass + + def __str__(self): + return ("Modifications and transactional operations not allowed on " + "ReadOnlyGraphAggregate instances") + + +class UnSupportedAggregateOperation(Exception): + + def __init__(self): + pass + + def __str__(self): + return ("This operation is not supported by ReadOnlyGraphAggregate " + "instances") + + +class ReadOnlyGraphAggregate(ConjunctiveGraph): + """Utility class for treating a set of graphs as a single graph + + Only read operations are supported (hence the name). Essentially a + ConjunctiveGraph over an explicit subset of the entire store. + """ + + def __init__(self, graphs, store='default'): + if store is not None: + super(ReadOnlyGraphAggregate, self).__init__(store) + Graph.__init__(self, store) + self.__namespace_manager = None + + assert isinstance(graphs, list) \ + and graphs \ + and [g for g in graphs if isinstance(g, Graph)], \ + "graphs argument must be a list of Graphs!!" + self.graphs = graphs + + def __repr__(self): + return "<ReadOnlyGraphAggregate: %s graphs>" % len(self.graphs) + + def destroy(self, configuration): + raise ModificationException() + + # Transactional interfaces (optional) + def commit(self): + raise ModificationException() + + def rollback(self): + raise ModificationException() + + def open(self, configuration, create=False): + # TODO: is there a use case for this method? + for graph in self.graphs: + graph.open(self, configuration, create) + + def close(self): + for graph in self.graphs: + graph.close() + + def add(self, xxx_todo_changeme6): + (s, p, o) = xxx_todo_changeme6 + raise ModificationException() + + def addN(self, quads): + raise ModificationException() + + def remove(self, xxx_todo_changeme7): + (s, p, o) = xxx_todo_changeme7 + raise ModificationException() + + def triples(self, xxx_todo_changeme8): + (s, p, o) = xxx_todo_changeme8 + for graph in self.graphs: + if isinstance(p, Path): + for s, o in p.eval(self, s, o): + yield s, p, o + else: + for s1, p1, o1 in graph.triples((s, p, o)): + yield (s1, p1, o1) + + def __contains__(self, triple_or_quad): + context = None + if len(triple_or_quad) == 4: + context = triple_or_quad[3] + for graph in self.graphs: + if context is None or graph.identifier == context.identifier: + if triple_or_quad[:3] in graph: + return True + return False + + def quads(self, xxx_todo_changeme9): + """Iterate over all the quads in the entire aggregate graph""" + (s, p, o) = xxx_todo_changeme9 + for graph in self.graphs: + for s1, p1, o1 in graph.triples((s, p, o)): + yield (s1, p1, o1, graph) + + def __len__(self): + return sum(len(g) for g in self.graphs) + + def __hash__(self): + raise UnSupportedAggregateOperation() + + def __cmp__(self, other): + if other is None: + return -1 + elif isinstance(other, Graph): + return -1 + elif isinstance(other, ReadOnlyGraphAggregate): + return cmp(self.graphs, other.graphs) + else: + return -1 + + def __iadd__(self, other): + raise ModificationException() + + def __isub__(self, other): + raise ModificationException() + + # Conv. methods + + def triples_choices(self, xxx_todo_changeme10, context=None): + (subject, predicate, object_) = xxx_todo_changeme10 + for graph in self.graphs: + choices = graph.triples_choices((subject, predicate, object_)) + for (s, p, o) in choices: + yield (s, p, o) + + def qname(self, uri): + if hasattr(self, 'namespace_manager') and self.namespace_manager: + return self.namespace_manager.qname(uri) + raise UnSupportedAggregateOperation() + + def compute_qname(self, uri, generate=True): + if hasattr(self, 'namespace_manager') and self.namespace_manager: + return self.namespace_manager.compute_qname(uri, generate) + raise UnSupportedAggregateOperation() + + def bind(self, prefix, namespace, override=True): + raise UnSupportedAggregateOperation() + + def namespaces(self): + if hasattr(self, 'namespace_manager'): + for prefix, namespace in self.namespace_manager.namespaces(): + yield prefix, namespace + else: + for graph in self.graphs: + for prefix, namespace in graph.namespaces(): + yield prefix, namespace + + def absolutize(self, uri, defrag=1): + raise UnSupportedAggregateOperation() + + def parse(self, source, publicID=None, format="xml", **args): + raise ModificationException() + + def n3(self): + raise UnSupportedAggregateOperation() + + def __reduce__(self): + raise UnSupportedAggregateOperation() + +def _assertnode(*terms): + for t in terms: + assert isinstance(t, Node), \ + 'Term %s must be an rdflib term' % (t,) + return True + + +def test(): + import doctest + doctest.testmod() + +if __name__ == '__main__': + test()