Move Store API to work with identifiers, not graphs

All add/remove methods now raise an Exception if passed a graph.
The Graph API works on Graph objects and will pack/unpack as required.

Author: gromgull

rdflib/graph.py

@@ -389,12 +389,12 @@ def add(self, triple):
             "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)
+        self.__store.add((s, p, o), self.identifier, 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
+        self.__store.addN((s, p, o, c.identifier) for s, p, o, c in quads
                           if isinstance(c, Graph)
                           and c.identifier is self.identifier
                           and _assertnode(s,p,o)
@@ -406,7 +406,7 @@ def remove(self, triple):
         If the triple does not provide a context attribute, removes the triple
         from all contexts.
         """
-        self.__store.remove(triple, context=self)
+        self.__store.remove(triple, context=self.identifier)
 
     def triples(self, triple):
         """Generator over the triple store
@@ -419,7 +419,7 @@ def triples(self, triple):
             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):
+            for (s, p, o), cg in self.__store.triples((s, p, o), context=self.identifier):
                 yield (s, p, o)
 
     @format_doctest_out
@@ -498,7 +498,7 @@ def __len__(self):
         If context is specified then the number of triples in the context is
         returned instead.
         """
-        return self.__store.__len__(context=self)
+        return self.__store.__len__(context=self.identifier)
 
     def __iter__(self):
         """Iterates over all triples in the store"""
@@ -645,7 +645,7 @@ def predicate_objects(self, subject=None):
     def triples_choices(self, triple, context=None):
         subject, predicate, object_ = triple
         for (s, p, o), cg in self.store.triples_choices(
-                (subject, predicate, object_), context=self):
+                (subject, predicate, object_), context=self.identifier):
             yield (s, p, o)
 
     def value(self, subject=None, predicate=RDF.value, object=None,
@@ -1296,7 +1296,8 @@ def __init__(self, store='default', identifier=None):
         self.context_aware = True
         self.default_union = True # Conjunctive!
         self.default_context = Graph(store=self.store,
-                                     identifier=identifier or BNode())
+                                     identifier=self.identifier)
+
 
     def __str__(self):
         pattern = ("[a rdflib:ConjunctiveGraph;rdflib:storage "
@@ -1309,13 +1310,12 @@ def _spoc(self, triple_or_quad, default=False):
         either triples or quads
         """
         if triple_or_quad is None:
-            return (None, None, None, self.default_context if default else None)
+            return (None, None, None, self.identifier if default else None)
         if len(triple_or_quad) == 3:
-            c = self.default_context if default else None
+            c = self.identifier 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
 
 
@@ -1339,7 +1339,9 @@ def add(self, triple_or_quad):
 
         _assertnode(s,p,o)
 
-        self.store.add((s, p, o), context=c, quoted=False)
+        self.store.add((s, p, o),
+                       context=c.identifier if isinstance(c, Graph) else c,
+                       quoted=False)
 
     def _graph(self, c):
         if c is None: return None
@@ -1353,8 +1355,9 @@ 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)
+            (s, p, o,
+             c.identifier if isinstance(c, Graph) else c)
+            for s, p, o, c in quads if _assertnode(s, p, o)
             )
 
     def remove(self, triple_or_quad):
@@ -1368,7 +1371,8 @@ def remove(self, triple_or_quad):
         """
         s,p,o,c = self._spoc(triple_or_quad)
 
-        self.store.remove((s, p, o), context=c)
+        self.store.remove((s, p, o),
+                          context=c.identifier if isinstance(c, Graph) else c)
 
     def triples(self, triple_or_quad, context=None):
         """
@@ -1380,14 +1384,14 @@ def triples(self, triple_or_quad, context=None):
         """
 
         s,p,o,c = self._spoc(triple_or_quad)
-        context = self._graph(context or c)
+        context = context or c
 
         if self.default_union:
-            if context==self.default_context:
+            if context == self.identifier:
                 context = None
         else:
             if context is None:
-                context = self.default_context
+                context = self.identifier
 
         if isinstance(p, Path):
             if context is None:
@@ -1404,18 +1408,19 @@ def quads(self, triple_or_quad=None):
 
         s,p,o,c = self._spoc(triple_or_quad)
 
-        for (s, p, o), cg in self.store.triples((s, p, o), context=c):
+        for (s, p, o), cg in self.store.triples((s, p, o),
+                                                context=c if isinstance(c, Graph) else c ):
             for ctx in cg:
-                yield s, p, o, ctx
+                yield s, p, o, self._graph(ctx)
 
     def triples_choices(self, triple, context=None):
         """Iterate over all the triples in the entire conjunctive graph"""
         s, p, o = triple
         if context is None:
             if not self.default_union:
-                context=self.default_context
+                context=self.identifier
         else:
-            context = self._graph(context)
+            if isinstance(context, Graph): context = context.identifier
 
         for (s1, p1, o1), cg in self.store.triples_choices((s, p, o),
                                                            context=context):
@@ -1432,10 +1437,7 @@ def contexts(self, triple=None):
         """
         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
+                raise Exception("Got graph object as context, not Identifier!")
             else:
                 yield self.get_context(context)
 
@@ -1449,7 +1451,8 @@ def get_context(self, identifier, quoted=False):
 
     def remove_context(self, context):
         """Removes the given context from the graph"""
-        self.store.remove((None, None, None), context)
+        self.store.remove((None, None, None),
+                          context.identifier if isinstance(context, Graph) else context)
 
     def context_id(self, uri, context_id=None):
         """URI#context"""
@@ -1600,17 +1603,20 @@ def __init__(self, store='default', default_union=False):
 
         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 add(self, triple_or_quad):
+        if len(triple_or_quad)==4: super(Dataset, self).add(triple_or_quad)
+        else: super(Dataset, self).add(triple_or_quad+(DATASET_DEFAULT_GRAPH_ID,))
 
     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 isinstance(identifier, Graph): identifier = identifier.identifier
         if identifier is None:
             from rdflib.term import rdflib_skolem_genid
             self.bind(
@@ -1620,7 +1626,7 @@ def graph(self, identifier=None):
 
         g = self._graph(identifier)
 
-        self.store.add_graph(g)
+        self.store.add_graph(identifier)
         return g
 
     def parse(self, source=None, publicID=None, format="xml",
@@ -1634,14 +1640,14 @@ def add_graph(self, g):
         return self.graph(g)
 
     def remove_graph(self, g):
-        if not isinstance(g, Graph):
-            g = self.get_context(g)
+        if isinstance(g, Graph):
+            g = g.identifier
 
         self.store.remove_graph(g)
-        if g is None or g == self.default_context:
+        if g is None or g == DATASET_DEFAULT_GRAPH_ID:
             # default graph cannot be removed
             # only triples deleted, so add it back in
-            self.store.add_graph(self.default_context)
+            self.store.add_graph(DATASET_DEFAULT_GRAPH_ID)
 
     def contexts(self, triple=None):
         default = False
@@ -1655,7 +1661,7 @@ def contexts(self, triple=None):
 
     def quads(self, quad):
         for s, p, o, c in super(Dataset, self).quads(quad):
-            if c.identifier==self.default_context:
+            if c.identifier == DATASET_DEFAULT_GRAPH_ID:
                 yield (s, p, o, None)
             else:
                 yield (s, p, o, c.identifier)
@@ -1680,13 +1686,13 @@ def add(self, triple):
         assert isinstance(o, Node), \
             "Object %s must be an rdflib term" % (o,)
 
-        self.store.add((s, p, o), self, quoted=True)
+        self.store.add((s, p, o), self.identifier, 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
+            (s, p, o, c.identifier) for s, p, o, c in quads
             if isinstance(c, QuotedGraph)
             and c.identifier is self.identifier
             and _assertnode(s, p, o)

rdflib/plugins/parsers/notation3.py

@@ -1900,7 +1900,7 @@ def parse(self, source, graph, encoding="utf-8"):
         assert graph.store.context_aware  # is this implied by formula_aware
         assert graph.store.formula_aware
 
-        conj_graph = ConjunctiveGraph(store=graph.store)
+        conj_graph = ConjunctiveGraph(identifier=graph.identifier, store=graph.store)
         conj_graph.default_context = graph  # TODO: CG __init__ should have a
                                             # default_context arg
          # TODO: update N3Processor so that it can use conj_graph as the sink

rdflib/plugins/sparql/update.py

@@ -70,7 +70,7 @@ def evalDrop(ctx, u):
     """
     if ctx.dataset.store.graph_aware:
         for g in _graphAll(ctx, u.graphiri):
-            ctx.dataset.store.remove_graph(g)
+            ctx.dataset.remove_graph(g)
     else:
         evalClear(ctx, u)
 
@@ -227,7 +227,7 @@ def evalMove(ctx, u):
     dstg += srcg
 
     if ctx.dataset.store.graph_aware:
-        ctx.dataset.store.remove_graph(srcg)
+        ctx.dataset.remove_graph(srcg)
     else:
         srcg.remove((None, None, None))
 

rdflib/plugins/stores/auditable.py

@@ -53,8 +53,7 @@ def add(self, triple, context, quoted=False):
         lock = destructiveOpLocks['add']
         lock = lock if lock else threading.RLock()
         with lock:
-            context = context.__class__(self.store, context.identifier) if context is not None else None
-            ctxId = context.identifier if context is not None else None
+            ctxId = context if context is not None else None
             if list(self.store.triples(triple, context)):
                 return # triple already in store, do nothing
             self.reverseOps.append((s, p, o, ctxId, 'remove'))
@@ -71,21 +70,20 @@ def remove(self, spo, context=None):
         with lock:
             # Need to determine which quads will be removed if any term is a
             # wildcard
-            context = context.__class__(self.store, context.identifier) if context is not None else None
-            ctxId = context.identifier if context is not None else None
+            ctxId = context if context is not None else None
             if None in [subject, predicate, object_, context]:
                 if ctxId:
-                    for s, p, o in context.triples((subject, predicate, object_)):
+                    for (s, p, o), cg in self.store.triples((subject, predicate, object_), context):
                         try:
                             self.reverseOps.remove((s, p, o, ctxId, 'remove'))
                         except ValueError:
                             self.reverseOps.append((s, p, o, ctxId, 'add'))
                 else:
                     for s, p, o, ctx in ConjunctiveGraph(self.store).quads((subject, predicate, object_)):
                         try:
-                            self.reverseOps.remove((s, p, o, ctx.identifier, 'remove'))
+                            self.reverseOps.remove((s, p, o, ctx, 'remove'))
                         except ValueError:
-                            self.reverseOps.append((s, p, o, ctx.identifier, 'add'))
+                            self.reverseOps.append((s, p, o, ctx, 'add'))
             else:
                 if not list(self.triples((subject, predicate, object_), context)):
                     return # triple not present in store, do nothing
@@ -97,12 +95,10 @@ def remove(self, spo, context=None):
 
     def triples(self, triple, context=None):
         (su, pr, ob) = triple
-        context = context.__class__(self.store, context.identifier) if context is not None else None
         for (s, p, o), cg in self.store.triples((su, pr, ob), context):
             yield (s, p, o), cg
 
     def __len__(self, context=None):
-        context = context.__class__(self.store, context.identifier) if context is not None else None
         return self.store.__len__(context)
 
     def contexts(self, triple=None):
@@ -131,9 +127,9 @@ def rollback(self):
             for subject, predicate, obj, context, op in self.reverseOps:
                 if op == 'add':
                     self.store.add(
-                        (subject, predicate, obj), Graph(self.store, context))
+                        (subject, predicate, obj), context)
                 else:
                     self.store.remove(
-                        (subject, predicate, obj), Graph(self.store, context))
+                        (subject, predicate, obj), context)
 
             self.reverseOps = []

rdflib/store.py

@@ -36,6 +36,9 @@
 UNKNOWN = None
 
 from rdflib.events import Dispatcher, Event
+from rdflib.term import URIRef, BNode, Literal, Variable, Statement, Identifier
+
+
 
 from .py3compat import cPickle
 from .py3compat import BytesIO
@@ -147,18 +150,13 @@ def __init__(self, configuration=None, identifier=None):
 
     def __get_node_pickler(self):
         if self.__node_pickler is None:
-            from rdflib.term import URIRef
-            from rdflib.term import BNode
-            from rdflib.term import Literal
-            from rdflib.graph import Graph, QuotedGraph
-            from rdflib.term import Variable
-            from rdflib.term import Statement
             self.__node_pickler = np = NodePickler()
+            from rdflib.graph import QuotedGraph # here to avoid circular import
+
             np.register(self, "S")
             np.register(URIRef, "U")
             np.register(BNode, "B")
             np.register(Literal, "L")
-            np.register(Graph, "G")
             np.register(QuotedGraph, "Q")
             np.register(Variable, "V")
             np.register(Statement, "s")
@@ -211,6 +209,8 @@ def add(self, triple, context, quoted=False):
         be an error for the quoted argument to be True when the store is not
         formula-aware.
         """
+        if not isinstance(context, Identifier): raise Exception("Trying to add to a context that isn't an identifier: %s"%context)
+
         self.dispatcher.dispatch(
             TripleAddedEvent(
                 triple=triple, context=context))
@@ -229,6 +229,8 @@ def addN(self, quads):
 
     def remove(self, triple, context=None):
         """ Remove the set of triples matching the pattern from the store """
+        if context is not None and not isinstance(context, Identifier): raise Exception("Trying to remove from a context that isn't an identifier: %s"%context)
+
         self.dispatcher.dispatch(
             TripleRemovedEvent(
                 triple=triple, context=context))