Use in-memory resource for retrieval.

lakesuperior/model/ldp_rs.py

@@ -1,5 +1,6 @@
 from lakesuperior.core.namespaces import ns_collection as nsc
-from lakesuperior.model.ldpr import Ldpr, transactional, must_exist
+from lakesuperior.model.ldpr import Ldpr, transactional, must_exist, \
+        ResourceNotExistsError
 from lakesuperior.util.translator import Translator
 
 class LdpRs(Ldpr):

lakesuperior/model/ldpr.py

@@ -5,12 +5,9 @@ from importlib import import_module
 from itertools import accumulate
 from uuid import uuid4
 
-import arrow
-
 from rdflib import Graph
 from rdflib.resource import Resource
 from rdflib.namespace import RDF, XSD
-from rdflib.term import Literal
 
 from lakesuperior.config_parser import config
 from lakesuperior.connectors.filesystem_connector import FilesystemConnector
@@ -151,16 +148,13 @@ class Ldpr(metaclass=ABCMeta):
         store_mod = import_module(
                 'lakesuperior.store_layouts.rdf.{}'.format(
                         self.rdf_store_layout))
-        # Ideally, _rdf_store_cls should not be a class member, but
-        # `_find_parent_or_create_pairtree` is using it at the moment. That
-        # should be fixed some time.
-        self._rdf_store_cls = getattr(store_mod, Translator.camelcase(
+        rdf_store_cls = getattr(store_mod, Translator.camelcase(
                 self.rdf_store_layout))
 
         self._urn = nsc['fcres'][uuid] if self.uuid is not None \
-                else self._rdf_store_cls.ROOT_NODE_URN
+                else rdf_store_cls.ROOT_NODE_URN
 
-        self.rdfly = self._rdf_store_cls(self._urn)
+        self.rdfly = rdf_store_cls(self._urn)
 
         # Same thing coud be done for the filesystem store layout, but we
         # will keep it simple for now.
@@ -332,16 +326,20 @@ class Ldpr(metaclass=ABCMeta):
             return cls(str(uuid4()))
 
         rdfly = cls.load_rdf_layout()
-        parent_rsrc = Resource(rdfly.ds, nsc['fcres'][parent_uuid])
+        parent_imr = rdfly.extract_imr(nsc['fcres'][parent_uuid])
 
         # Set prefix.
         if parent_uuid:
-            parent_exists = rdfly.ask_rsrc_exists(parent_rsrc)
+            parent_exists = rdfly.ask_rsrc_exists(parent_imr.identifier)
             if not parent_exists:
                 raise ResourceNotExistsError('Parent not found: {}.'
                         .format(parent_uuid))
 
-            if nsc['ldp'].Container not in rdfly.rsrc.values(RDF.type):
+            parent_types = { t.identifier for t in \
+                    parent_imr.objects(RDF.type) }
+            cls._logger.debug('Parent types: {}'.format(
+                    parent_types))
+            if nsc['ldp'].Container not in parent_types:
                 raise InvalidResourceError('Parent {} is not a container.'
                        .format(parent_uuid))
 
@@ -353,7 +351,7 @@ class Ldpr(metaclass=ABCMeta):
         if slug:
             cnd_uuid = pfx + slug
             cnd_rsrc = Resource(rdfly.ds, nsc['fcres'][cnd_uuid])
-            if rdfly.ask_rsrc_exists(cnd_rsrc):
+            if rdfly.ask_rsrc_exists(cnd_rsrc.identifier):
                 return cls(pfx + str(uuid4()))
             else:
                 return cls(cnd_uuid)
@@ -419,13 +417,12 @@ class Ldpr(metaclass=ABCMeta):
         '''
         if '/' in self.uuid:
             # Traverse up the hierarchy to find the parent.
-            #candidate_parent_urn = self._find_first_ancestor()
-            #cparent = self.rdfly.ds.resource(candidate_parent_urn)
             cparent_uri = self._find_parent_or_create_pairtree(self.uuid)
 
             # Reroute possible containment relationships between parent and new
             # resource.
             #self._splice_in(cparent)
+
             if cparent_uri:
                 self.rdfly.ds.add((cparent_uri, nsc['ldp'].contains,
                         self.rsrc.identifier))
@@ -463,38 +460,36 @@ class Ldpr(metaclass=ABCMeta):
         for cparent_uuid in rev_search_order:
             cparent_uri = nsc['fcres'][cparent_uuid]
 
-            # @FIXME A bit ugly. Maybe we should use a Pairtree class.
-            if self._rdf_store_cls(cparent_uri).ask_rsrc_exists():
+            if self.rdfly.ask_rsrc_exists(cparent_uri):
                 return cparent_uri
             else:
-                self._create_pairtree(cparent_uri, cur_child_uri)
+                self._create_path_segment(cparent_uri, cur_child_uri)
                 cur_child_uri = cparent_uri
 
         return None
 
 
-    def _create_pairtree(self, uri, child_uri):
+    def _create_path_segment(self, uri, child_uri):
         '''
-        Create a pairtree node with a containment statement.
+        Create a path segment with a non-LDP containment statement.
 
-        This is the default fcrepo4 behavior and probably not the best one, but
-        we are following it here.
+        This diverges from the default fcrepo4 behavior which creates pairtree
+        resources.
 
         If a resource such as `fcres:a/b/c` is created, and neither fcres:a or
-        fcres:a/b exists, we have to create pairtree nodes in order to maintain
-        the containment chain.
-
-        This way, both fcres:a and fcres:a/b become thus containers of
-        fcres:a/b/c, which may be confusing.
+        fcres:a/b exists, we have to create two "hidden" containment statements
+        between a and a/b and between a/b and a/b/c in order to maintain the
+        `containment chain.
         '''
         g = Graph()
-        g.add((uri, RDF.type, nsc['fcrepo'].Pairtree))
         g.add((uri, RDF.type, nsc['ldp'].Container))
         g.add((uri, RDF.type, nsc['ldp'].BasicContainer))
         g.add((uri, RDF.type, nsc['ldp'].RDFSource))
-        g.add((uri, nsc['ldp'].contains, child_uri))
+        g.add((uri, nsc['fcrepo'].contains, child_uri))
+
+        # If the path segment is just below root
         if '/' not in str(uri):
-            g.add((nsc['fcsystem'].root, nsc['ldp'].contains, uri))
+            g.add((nsc['fcsystem'].root, nsc['fcrepo'].contains, uri))
 
         self.rdfly.create_rsrc(g)
 

lakesuperior/store_layouts/rdf/base_rdf_layout.py

@@ -176,7 +176,13 @@ class BaseRdfLayout(metaclass=ABCMeta):
         return self.ds.query(q, initBindings=initBindings, initNs=nsc)
 
 
-    def extract_rsrc(self, uri=None, graph=None, inbound=False):
+    ## INTERFACE METHODS ##
+
+    # Implementers of custom layouts should look into these methods to
+    # implement.
+
+    @abstractmethod
+    def extract_imr(self, uri=None, graph=None, inbound=False):
         '''
         Extract an in-memory resource based on the copy of a graph on a subject.
 
@@ -187,35 +193,8 @@ class BaseRdfLayout(metaclass=ABCMeta):
         @param inbound (boolean) Whether to pull triples that have the resource
         URI as their object.
         '''
-        uri = uri or self.base_urn
-
-        inbound_qry = '\n?s1 ?p1 {}'.format(self.base_urn.n3()) \
-                if inbound else ''
-
-        q = '''
-        CONSTRUCT {{
-            {0} ?p ?o .{1}
-        }} WHERE {{
-            {0} ?p ?o .{1}
-            FILTER (?p != premis:hasMessageDigest) .
-        }}
-        '''.format(uri.n3(), inbound_qry)
-
-        try:
-            qres = self.query(q)
-        except ResultException:
-            # RDFlib bug? https://github.com/RDFLib/rdflib/issues/775
-            g = Graph()
-        else:
-            g = qres.graph
-
-        return Resource(g, uri)
-
-
-    ## INTERFACE METHODS ##
+        pass
 
-    # Implementers of custom layouts should look into these methods to
-    # implement.
 
     @abstractmethod
     @needs_rsrc
@@ -233,11 +212,11 @@ class BaseRdfLayout(metaclass=ABCMeta):
 
 
     @abstractmethod
-    def ask_rsrc_exists(self):
+    def ask_rsrc_exists(self, uri=None):
         '''
         Ask if a resource exists (is stored) in the graph store.
 
-        @param rsrc (rdflib.resource.Resource) If this is provided, this method
+        @param uri (rdflib.term.URIRef) If this is provided, this method
         will look for the specified resource. Otherwise, it will look for the
         default resource. If this latter is not specified, the result is False.
 

lakesuperior/store_layouts/rdf/simple_layout.py

@@ -4,6 +4,7 @@ import arrow
 
 from rdflib import Graph
 from rdflib.namespace import XSD
+from rdflib.query import ResultException
 from rdflib.resource import Resource
 from rdflib.term import Literal, URIRef, Variable
 
@@ -49,30 +50,58 @@ class SimpleLayout(BaseRdfLayout):
         return headers
 
 
+    def extract_imr(self, uri=None, graph=None, inbound=False):
+        '''
+        See base_rdf_layout.extract_imr.
+        '''
+        uri = uri or self.base_urn
+
+        inbound_qry = '\n?s1 ?p1 {}'.format(self.base_urn.n3()) \
+                if inbound else ''
+
+        q = '''
+        CONSTRUCT {{
+            {0} ?p ?o .{1}
+        }} WHERE {{
+            {0} ?p ?o .{1}
+            #FILTER (?p != premis:hasMessageDigest) .
+        }}
+        '''.format(uri.n3(), inbound_qry)
+
+        try:
+            qres = self.query(q)
+        except ResultException:
+            # RDFlib bug? https://github.com/RDFLib/rdflib/issues/775
+            g = Graph()
+        else:
+            g = qres.graph
+
+        return Resource(g, uri)
+
+
     def out_rsrc(self, srv_mgd=True, inbound=False, embed_children=False):
         '''
         See base_rdf_layout.out_rsrc.
         '''
-        im_rsrc = self.extract_rsrc(inbound=inbound)
+        im_rsrc = self.extract_imr(inbound=inbound)
 
         im_rsrc.remove(nsc['premis'].hasMessageDigest)
 
         return im_rsrc
 
 
-    def ask_rsrc_exists(self, rsrc=None):
+    def ask_rsrc_exists(self, uri=None):
         '''
         See base_rdf_layout.ask_rsrc_exists.
         '''
-        if not rsrc:
+        if not uri:
             if self.rsrc is not None:
-                rsrc = self.rsrc
+                uri = self.rsrc.identifier
             else:
                 return False
 
-        self._logger.info('Searching for resource: {}'
-                .format(rsrc.identifier))
-        return (rsrc.identifier, Variable('p'), Variable('o')) in self.ds
+        self._logger.info('Searching for resource: {}'.format(uri))
+        return (uri, Variable('p'), Variable('o')) in self.ds
 
 
     def create_or_replace_rsrc(self, g):