Preload all information in LDP class

constructors.

lakesuperior/endpoints/ldp.py

@@ -5,8 +5,10 @@ from uuid import uuid4
 
 from flask import Blueprint, current_app, g, request, send_file, url_for
 from rdflib import Graph
+from rdflib.namespace import RDF, XSD
 from werkzeug.datastructures import FileStorage
 
+from lakesuperior.dictionaries.namespaces import ns_collection as nsc
 from lakesuperior.exceptions import (
     InvalidResourceError, ResourceExistsError, ResourceNotExistsError,
     ServerManagedTermError, TombstoneError
@@ -90,7 +92,7 @@ def get_resource(uuid, force_rdf=False):
         prefer = Toolbox().parse_rfc7240(request.headers['prefer'])
         logger.debug('Parsed Prefer header: {}'.format(prefer))
         if 'return' in prefer:
-            repr_options = prefer['return']
+            repr_options = parse_repr_options(prefer['return'])
 
     try:
         rsrc = Ldpr.inst(uuid, repr_options)
@@ -103,7 +105,7 @@ def get_resource(uuid, force_rdf=False):
         if isinstance(rsrc, LdpRs) \
                 or request.headers['accept'] in accept_rdf \
                 or force_rdf:
-            return (rsrc.out_graph.serialize(format='turtle'), out_headers)
+            return (rsrc.get(), out_headers)
         else:
             return send_file(rsrc.local_path, as_attachment=True,
                     attachment_filename=rsrc.filename)
@@ -130,10 +132,12 @@ def post_resource(parent):
     except KeyError:
         slug = None
 
-    cls, data = class_from_req_body()
+    handling, disposition = set_post_put_params()
 
     try:
-        rsrc = cls.inst_for_post(parent, slug)
+        uuid = uuid_for_post(parent, slug)
+        rsrc = Ldpr.inst_from_client_input(uuid, handling=handling,
+                disposition=disposition)
     except ResourceNotExistsError as e:
         return str(e), 404
     except InvalidResourceError as e:
@@ -141,19 +145,10 @@ def post_resource(parent):
     except TombstoneError as e:
         return _tombstone_response(e, uuid)
 
-    if cls == LdpNr:
-        try:
-            cont_disp = Toolbox().parse_rfc7240(
-                    request.headers['content-disposition'])
-        except KeyError:
-            cont_disp = None
-
-        rsrc.post(data, mimetype=request.content_type, disposition=cont_disp)
-    else:
-        try:
-            rsrc.post(data)
-        except ServerManagedTermError as e:
-            return str(e), 412
+    try:
+        rsrc.post()
+    except ServerManagedTermError as e:
+        return str(e), 412
 
     out_headers.update({
         'Location' : rsrc.uri,
@@ -167,49 +162,26 @@ def put_resource(uuid):
     '''
     Add a new resource at a specified URI.
     '''
+    # Parse headers.
     logger.info('Request headers: {}'.format(request.headers))
     rsp_headers = std_headers
 
-    cls, data = class_from_req_body()
+    handling, disposition = set_post_put_params()
 
-    rsrc = cls(uuid)
+    try:
+        rsrc = Ldpr.inst_from_client_input(uuid, handling=handling,
+                disposition=disposition)
+    except ServerManagedTermError as e:
+        return str(e), 412
 
-    # Parse headers.
-    pref_handling = None
-    if cls == LdpNr:
-        try:
-            logger.debug('Headers: {}'.format(request.headers))
-            cont_disp = Toolbox().parse_rfc7240(
-                    request.headers['content-disposition'])
-        except KeyError:
-            cont_disp = None
-
-        try:
-            ret = rsrc.put(data, disposition=cont_disp,
-                    mimetype=request.content_type)
-        except InvalidResourceError as e:
-            return str(e), 409
-        except ResourceExistsError as e:
-            return str(e), 409
-        except TombstoneError as e:
-            return _tombstone_response(e, uuid)
-    else:
-        if 'prefer' in request.headers:
-            prefer = Toolbox().parse_rfc7240(request.headers['prefer'])
-            logger.debug('Parsed Prefer header: {}'.format(prefer))
-            if 'handling' in prefer:
-                pref_handling = prefer['handling']['value']
-
-        try:
-            ret = rsrc.put(data, handling=pref_handling)
-        except InvalidResourceError as e:
-            return str(e), 409
-        except ResourceExistsError as e:
-            return str(e), 409
-        except TombstoneError as e:
-            return _tombstone_response(e, uuid)
-        except ServerManagedTermError as e:
-            return str(e), 412
+    try:
+        ret = rsrc.put()
+    except InvalidResourceError as e:
+        return str(e), 409
+    except ResourceExistsError as e:
+        return str(e), 409
+    except TombstoneError as e:
+        return _tombstone_response(e, uuid)
 
     res_code = 201 if ret == Ldpr.RES_CREATED else 204
     return '', res_code, rsp_headers
@@ -244,9 +216,9 @@ def delete_resource(uuid):
 
     # If referential integrity is enforced, grab all inbound relationships
     # to break them.
-    repr_opts = {'parameters' : {'include' : Ldpr.RETURN_INBOUND_REF_URI}} \
+    repr_opts = {'incl_inbound' : True} \
             if current_app.config['store']['ldp_rs']['referential_integrity'] \
-            else None
+            else {}
     if 'prefer' in request.headers:
         prefer = Toolbox().parse_rfc7240(request.headers['prefer'])
         leave_tstone = 'no-tombstone' not in prefer
@@ -272,7 +244,7 @@ def tombstone(uuid):
     The only allowed method is DELETE; any other verb will return a 405.
     '''
     logger.debug('Deleting tombstone for {}.'.format(uuid))
-    rsrc = Ldpr(uuid, repr_opts={'value' : 'minimal'})
+    rsrc = Ldpr(uuid)
     try:
         imr = rsrc.imr
     except TombstoneError as e:
@@ -290,48 +262,45 @@ def tombstone(uuid):
         return '', 404
 
 
-def class_from_req_body():
+def uuid_for_post(parent_uuid=None, slug=None):
     '''
-    Determine LDP type (and instance class) from the provided RDF body.
+    Validate conditions to perform a POST and return an LDP resource
+    UUID for using with the `post` method.
+
+    This may raise an exception resulting in a 404 if the parent is not
+    found or a 409 if the parent is not a valid container.
     '''
-    logger.debug('Content type: {}'.format(request.mimetype))
-    logger.debug('files: {}'.format(request.files))
-    logger.debug('stream: {}'.format(request.stream))
-
-    # LDP-NR types
-    if not request.content_length:
-        logger.debug('No data received in body.')
-        cls = Ldpc
-        data = None
-    elif request.mimetype in accept_rdf:
-        # Parse out the RDF string.
-        data = request.data.decode('utf-8')
-        g = Graph().parse(data=data, format=request.mimetype)
-
-        if Ldpr.MBR_RSRC_URI in g.predicates() and \
-                Ldpr.MBR_REL_URI in g.predicates():
-            if Ldpr.INS_CNT_REL_URI in g.predicates():
-                cls = LdpIc
-            else:
-                cls = LdpDc
-        else:
-            cls = Ldpc
+    # Shortcut!
+    if not slug and not parent_uuid:
+        return str(uuid4())
+
+    parent = Ldpr.inst(parent_uuid, repr_opts={'incl_children' : False})
+
+    # Set prefix.
+    if parent_uuid:
+        parent_types = { t.identifier for t in \
+                parent.imr.objects(RDF.type) }
+        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))
+
+        pfx = parent_uuid + '/'
     else:
-        cls = LdpNr
-        if request.mimetype == 'multipart/form-data':
-            # This seems the "right" way to upload a binary file, with a
-            # multipart/form-data MIME type and the file in the `file`
-            # field. This however is not supported by FCREPO4.
-            data = request.files.get('file').stream
-        else:
-            # This is a less clean way, with the file in the form body and
-            # the request as application/x-www-form-urlencoded.
-            # This is how FCREPO4 accepts binary uploads.
-            data = request.stream
+        pfx = ''
 
-    logger.info('Creating resource of type: {}'.format(cls.__name__))
+    # Create candidate UUID and validate.
+    if slug:
+        cnd_uuid = pfx + slug
+        if current_app.rdfly.ask_rsrc_exists(nsc['fcres'][cnd_uuid]):
+            uuid = pfx + str(uuid4())
+        else:
+            uuid = cnd_uuid
+    else:
+        uuid = pfx + str(uuid4())
 
-    return cls, data
+    return uuid
 
 
 def _get_bitstream(rsrc):
@@ -348,3 +317,78 @@ def _tombstone_response(e, uuid):
         'Link' : '<{}/fcr:tombstone>; rel="hasTombstone"'.format(request.url),
     } if e.uuid == uuid else {}
     return str(e), 410, headers
+
+
+
+def set_post_put_params():
+    '''
+    Sets handling and content disposition for POST and PUT by parsing headers.
+    '''
+    handling = None
+    if 'prefer' in request.headers:
+        prefer = Toolbox().parse_rfc7240(request.headers['prefer'])
+        logger.debug('Parsed Prefer header: {}'.format(prefer))
+        if 'handling' in prefer:
+            handling = prefer['handling']['value']
+
+    try:
+        disposition = Toolbox().parse_rfc7240(
+                request.headers['content-disposition'])
+    except KeyError:
+        disposition = None
+
+    return handling, disposition
+
+
+def parse_repr_options(retr_opts):
+    '''
+    Set options to retrieve IMR.
+
+    Ideally, IMR retrieval is done once per request, so all the options
+    are set once in the `imr()` property.
+
+    @param retr_opts (dict): Options parsed from `Prefer` header.
+    '''
+    logger.debug('Parsing retrieval options: {}'.format(retr_opts))
+    imr_options = {}
+
+    if retr_opts.setdefault('value') == 'minimal':
+        imr_options = {
+            'embed_children' : False,
+            'incl_children' : False,
+            'incl_inbound' : False,
+            'incl_srv_mgd' : False,
+        }
+    else:
+        # Default.
+        imr_options = {
+            'embed_children' : False,
+            'incl_children' : True,
+            'incl_inbound' : False,
+            'incl_srv_mgd' : True,
+        }
+
+        # Override defaults.
+        if 'parameters' in retr_opts:
+            include = retr_opts['parameters']['include'].split(' ') \
+                    if 'include' in retr_opts['parameters'] else []
+            omit = retr_opts['parameters']['omit'].split(' ') \
+                    if 'omit' in retr_opts['parameters'] else []
+
+            logger.debug('Include: {}'.format(include))
+            logger.debug('Omit: {}'.format(omit))
+
+            if str(Ldpr.EMBED_CHILD_RES_URI) in include:
+                    imr_options['embed_children'] = True
+            if str(Ldpr.RETURN_CHILD_RES_URI) in omit:
+                    imr_options['incl_children'] = False
+            if str(Ldpr.RETURN_INBOUND_REF_URI) in include:
+                    imr_options['incl_inbound'] = True
+            if str(Ldpr.RETURN_SRV_MGD_RES_URI) in omit:
+                    imr_options['incl_srv_mgd'] = False
+
+    logger.debug('Retrieval options: {}'.format(imr_options))
+
+    return imr_options
+
+

lakesuperior/model/ldp_nr.py

@@ -20,6 +20,23 @@ class LdpNr(Ldpr):
         nsc['ldp'].NonRDFSource,
     }
 
+    def __init__(self, uuid, stream=None, mimetype='application/octet-stream',
+            disposition=None, **kwargs):
+        '''
+        Extends Ldpr.__init__ by adding LDP-NR specific parameters.
+        '''
+        super().__init__(uuid, **kwargs)
+
+        if stream:
+            self.workflow = self.WRKF_INBOUND
+            self.stream = stream
+        else:
+            self.workflow = self.WRKF_OUTBOUND
+
+        self.mimetype = mimetype
+        self.disposition = disposition
+
+
     @property
     def filename(self):
         return self.imr.value(nsc['ebucore'].filename)
@@ -39,21 +56,20 @@ class LdpNr(Ldpr):
 
 
     @atomic
-    def post(self, stream, mimetype=None, disposition=None):
+    def post(self):
         '''
         Create a new binary resource with a corresponding RDF representation.
 
         @param file (Stream) A Stream resource representing the uploaded file.
         '''
         # Persist the stream.
-        file_uuid = self.nonrdfly.persist(stream)
+        file_uuid = self.nonrdfly.persist(self.stream)
 
         # Gather RDF metadata.
-        self.provided_imr = Resource(Graph(), self.urn)
         for t in self.base_types:
             self.provided_imr.add(RDF.type, t)
-        self._add_metadata(stream, digest=file_uuid, mimetype=mimetype,
-                disposition=disposition)
+        # @TODO check that the existing resource is of the same LDP type.
+        self._add_metadata(digest=file_uuid)
 
         # Try to persist metadata. If it fails, delete the file.
         self._logger.debug('Persisting LDP-NR triples in {}'.format(self.urn))
@@ -61,18 +77,18 @@ class LdpNr(Ldpr):
             rsrc = self._create_rsrc()
         except:
             self.nonrdfly.delete(file_uuid)
+            raise
         else:
             return rsrc
 
 
-    def put(self, stream, **kwargs):
-        return self.post(stream, **kwargs)
+    def put(self):
+        return self.post()
 
 
     ## PROTECTED METHODS ##
 
-    def _add_metadata(self, stream, digest,
-            mimetype='application/octet-stream', disposition=None):
+    def _add_metadata(self, digest):
         '''
         Add all metadata for the RDF representation of the LDP-NR.
 
@@ -82,20 +98,21 @@ class LdpNr(Ldpr):
         content, parsed through `parse_rfc7240`.
         '''
         # File size.
-        self._logger.debug('Data stream size: {}'.format(stream.limit))
-        self.provided_imr.set(nsc['premis'].hasSize, Literal(stream.limit))
+        self._logger.debug('Data stream size: {}'.format(self.stream.limit))
+        self.provided_imr.set(nsc['premis'].hasSize, Literal(self.stream.limit))
 
         # Checksum.
         cksum_term = URIRef('urn:sha1:{}'.format(digest))
         self.provided_imr.set(nsc['premis'].hasMessageDigest, cksum_term)
 
         # MIME type.
-        self.provided_imr.set(nsc['ebucore']['hasMimeType'], Literal(mimetype))
+        self.provided_imr.set(nsc['ebucore']['hasMimeType'], 
+                Literal(self.mimetype))
 
         # File name.
-        self._logger.debug('Disposition: {}'.format(disposition))
+        self._logger.debug('Disposition: {}'.format(self.disposition))
         try:
             self.provided_imr.set(nsc['ebucore']['filename'], Literal(
-                    disposition['attachment']['parameters']['filename']))
-        except KeyError:
+                    self.disposition['attachment']['parameters']['filename']))
+        except (KeyError, TypeError) as e:
             pass

lakesuperior/model/ldp_rs.py

@@ -32,32 +32,51 @@ class LdpRs(Ldpr):
     }
 
 
+    def __init__(self, uuid, repr_opts={}, handling='strict', **kwargs):
+        '''
+        Extends Ldpr.__init__ by adding LDP-RS specific parameters.
+
+        @param handling (string) One of `strict` (the default) or `lenient`.
+        `strict` raises an error if a server-managed term is in the graph.
+        `lenient` removes all sever-managed triples encountered.
+        '''
+        super().__init__(uuid, **kwargs)
+
+        # provided_imr can be empty. If None, it is an outbound resource.
+        if self.provided_imr is not None:
+            self.workflow = self.WRKF_INBOUND
+        else:
+            self.workflow = self.WRKF_OUTBOUND
+            self._imr_options = repr_opts
+
+        self.handling = handling
+
+
     ## LDP METHODS ##
 
-    def get(self, repr_opts):
+    def get(self):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_GET
         '''
-        return Toolbox().globalize_rsrc(self.imr)
+        return self.out_graph.serialize(format='turtle')
 
 
     @atomic
-    def post(self, data, format='text/turtle', handling=None):
+    def post(self):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_POST
 
         Perform a POST action after a valid resource URI has been found.
         '''
-        return self._create_or_replace_rsrc(data, format, handling,
-                create_only=True)
+        return self._create_or_replace_rsrc(create_only=True)
 
 
     @atomic
-    def put(self, data, format='text/turtle', handling=None):
+    def put(self):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_PUT
         '''
-        return self._create_or_replace_rsrc(data, format, handling)
+        return self._create_or_replace_rsrc()
 
 
     @atomic
@@ -71,34 +90,22 @@ class LdpRs(Ldpr):
         '''
         delta = self._sparql_delta(update_str.replace('<>', self.urn.n3()))
 
-        return self.rdfly.modify_dataset(*delta)
+        return self._modify_rsrc(self.RES_UPDATED, *delta)
 
 
     ## PROTECTED METHODS ##
 
-    def _create_or_replace_rsrc(self, data, format, handling,
-            create_only=False):
+    def _create_or_replace_rsrc(self, create_only=False):
         '''
         Create or update a resource. PUT and POST methods, which are almost
         identical, are wrappers for this method.
 
         @param data (string) RDF data to parse for insertion.
         @param format(string) MIME type of RDF data.
-        @param handling (sting) One of `strict` or `lenient`. This determines
-        how to handle provided server-managed triples. If `strict` is selected,
-        any server-managed triple  included in the input RDF will trigger an
-        exception. If `lenient`, server-managed triples are ignored.
-        @param create_only (boolean) Whether the operation is a create-only
-        one (i.e. POST) or a create-or-update one (i.e. PUT).
+        @param create_only (boolean) Whether this is a create-only operation.
         '''
-        g = Graph()
-        if data:
-            g.parse(data=data, format=format, publicID=self.urn)
-
-        self.provided_imr = Resource(self._check_mgd_terms(g, handling),
-                self.urn)
-
         create = create_only or not self.is_stored
+
         self._add_srv_mgd_triples(create)
         self._ensure_single_subject_rdf(self.provided_imr.graph)
         ref_int = self.rdfly.config['referential_integrity']
@@ -118,17 +125,13 @@ class LdpRs(Ldpr):
     ## PROTECTED METHODS ##
 
 
-    def _check_mgd_terms(self, g, handling='strict'):
+    def _check_mgd_terms(self, g):
         '''
         Check whether server-managed terms are in a RDF payload.
-
-        @param handling (string) One of `strict` (the default) or `lenient`.
-        `strict` raises an error if a server-managed term is in the graph.
-        `lenient` removes all sever-managed triples encountered.
         '''
         offending_subjects = set(g.subjects()) & srv_mgd_subjects
         if offending_subjects:
-            if handling=='strict':
+            if self.handling=='strict':
                 raise ServerManagedTermError(offending_subjects, 's')
             else:
                 for s in offending_subjects:
@@ -137,7 +140,7 @@ class LdpRs(Ldpr):
 
         offending_predicates = set(g.predicates()) & srv_mgd_predicates
         if offending_predicates:
-            if handling=='strict':
+            if self.handling=='strict':
                 raise ServerManagedTermError(offending_predicates, 'p')
             else:
                 for p in offending_predicates:
@@ -146,7 +149,7 @@ class LdpRs(Ldpr):
 
         offending_types = set(g.objects(predicate=RDF.type)) & srv_mgd_types
         if offending_types:
-            if handling=='strict':
+            if self.handling=='strict':
                 raise ServerManagedTermError(offending_types, 't')
             else:
                 for t in offending_types:
@@ -183,7 +186,7 @@ class LdpRs(Ldpr):
             self.provided_imr.add(RDF.type, t)
 
 
-    def _sparql_delta(self, q, handling=None):
+    def _sparql_delta(self, q):
         '''
         Calculate the delta obtained by a SPARQL Update operation.
 
@@ -220,8 +223,8 @@ class LdpRs(Ldpr):
         #self._logger.info('Adding: {}'.format(
         #    add_g.serialize(format='turtle').decode('utf8')))
 
-        remove_g = self._check_mgd_terms(remove_g, handling)
-        add_g = self._check_mgd_terms(add_g, handling)
+        remove_g = self._check_mgd_terms(remove_g)
+        add_g = self._check_mgd_terms(add_g)
 
         return remove_g, add_g
 

lakesuperior/model/ldpr.py

@@ -6,6 +6,7 @@ from itertools import accumulate, groupby
 from uuid import uuid4
 
 import arrow
+import rdflib
 
 from flask import current_app, request
 from rdflib import Graph
@@ -88,6 +89,11 @@ class Ldpr(metaclass=ABCMeta):
     RETURN_SRV_MGD_RES_URI = nsc['fcrepo'].ServerManaged
     ROOT_NODE_URN = nsc['fcsystem'].root
 
+    # Workflow type. Inbound means that the resource is being written to the
+    # store, outbounnd is being retrieved for output.
+    WRKF_INBOUND = '_workflow:inbound_'
+    WRKF_OUTBOUND = '_workflow:outbound_'
+
     RES_CREATED = '_create_'
     RES_DELETED = '_delete_'
     RES_UPDATED = '_update_'
@@ -104,9 +110,11 @@ class Ldpr(metaclass=ABCMeta):
     ## STATIC & CLASS METHODS ##
 
     @classmethod
-    def inst(cls, uuid, repr_opts=None):
+    def inst(cls, uuid, repr_opts=None, **kwargs):
         '''
-        Factory method that creates and returns an instance of an LDPR subclass
+        Create an instance for retrieval purposes.
+
+        This factory method creates and returns an instance of an LDPR subclass
         based on information that needs to be queried from the underlying
         graph store.
 
@@ -115,124 +123,136 @@ class Ldpr(metaclass=ABCMeta):
         @param uuid UUID of the instance.
         '''
         imr_urn = nsc['fcres'][uuid] if uuid else cls.ROOT_NODE_URN
+
         cls._logger.debug('Representation options: {}'.format(repr_opts))
-        imr_opts = cls.set_imr_options(repr_opts)
-        imr = current_app.rdfly.extract_imr(imr_urn, **imr_opts)
-        rdf_types = set(imr.objects(RDF.type))
+        imr = current_app.rdfly.extract_imr(imr_urn, **repr_opts)
+        rdf_types = set(imr.graph.objects(imr.identifier, RDF.type))
+
+        if cls.LDP_NR_TYPE in rdf_types:
+            from lakesuperior.model.ldp_nr import LdpNr
+            cls._logger.info('Resource is a LDP-NR.')
+            rsrc = LdpNr(uuid, repr_opts, **kwargs)
+        elif cls.LDP_RS_TYPE in rdf_types:
+            from lakesuperior.model.ldp_rs import LdpRs
+            cls._logger.info('Resource is a LDP-RS.')
+            rsrc = LdpRs(uuid, repr_opts, **kwargs)
+        else:
+            raise ResourceNotExistsError(uuid)
 
-        for t in rdf_types:
-            cls._logger.debug('Checking RDF type: {}'.format(t.identifier))
-            if t.identifier == cls.LDP_NR_TYPE:
-                from lakesuperior.model.ldp_nr import LdpNr
-                cls._logger.info('Resource is a LDP-NR.')
-                return LdpNr(uuid, repr_opts)
-            if t.identifier == cls.LDP_RS_TYPE:
-                from lakesuperior.model.ldp_rs import LdpRs
-                cls._logger.info('Resource is a LDP-RS.')
-                return LdpRs(uuid, repr_opts)
+        # Sneak in the already extracted IMR to save a query.
+        rsrc._imr = imr
 
-        raise ResourceNotExistsError(uuid)
+        return rsrc
 
 
-    @classmethod
-    def inst_for_post(cls, parent_uuid=None, slug=None):
+    @staticmethod
+    def inst_from_client_input(uuid, **kwargs):
         '''
-        Validate conditions to perform a POST and return an LDP resource
-        instancefor using with the `post` method.
+        Determine LDP type (and instance class) from request headers and body.
 
-        This may raise an exception resulting in a 404 if the parent is not
-        found or a 409 if the parent is not a valid container.
+        This is used with POST and PUT methods.
+
+        @param uuid (string) UUID of the resource to be created or updated.
         '''
-        # Shortcut!
-        if not slug and not parent_uuid:
-            return cls(str(uuid4()))
+        # @FIXME Circular reference.
+        from lakesuperior.model.ldp_nr import LdpNr
+        from lakesuperior.model.ldp_rs import Ldpc, LdpDc, LdpIc, LdpRs
 
-        parent = cls(parent_uuid, repr_opts={
-            'parameters' : {'omit' : cls.RETURN_CHILD_RES_URI}
-        })
+        urn = nsc['fcres'][uuid]
 
-        # Set prefix.
-        if parent_uuid:
-            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))
-
-            pfx = parent_uuid + '/'
-        else:
-            pfx = ''
-
-        # Create candidate UUID and validate.
-        if slug:
-            cnd_uuid = pfx + slug
-            cnd_rsrc = Resource(current_app.rdfly.ds, nsc['fcres'][cnd_uuid])
-            if current_app.rdfly.ask_rsrc_exists(cnd_rsrc.identifier):
-                return cls(pfx + str(uuid4()))
+        logger = __class__._logger
+        logger.debug('Content type: {}'.format(request.mimetype))
+        logger.debug('files: {}'.format(request.files))
+        logger.debug('stream: {}'.format(request.stream))
+
+        if not request.content_length:
+            # Create empty LDPC.
+            logger.debug('No data received in request. '
+                    'Creating empty container.')
+
+            return Ldpc(uuid, provided_imr=Resource(Graph(), urn), **kwargs)
+
+        if __class__.is_rdf_parsable(request.mimetype):
+            # Create container and populate it with provided RDF data.
+            provided_g = Graph().parse(data=request.data.decode('utf-8'),
+                    format=request.mimetype, publicID=urn)
+            provided_imr = Resource(provided_g, urn)
+
+            if Ldpr.MBR_RSRC_URI in provided_g.predicates() and \
+                    Ldpr.MBR_REL_URI in provided_g.predicates():
+                if Ldpr.INS_CNT_REL_URI in provided_g.predicates():
+                    cls = LdpIc
+                else:
+                    cls = LdpDc
             else:
-                return cls(cnd_uuid)
+                cls = Ldpc
+
+            inst = cls(uuid, provided_imr=provided_imr, **kwargs)
+            inst._check_mgd_terms(inst.provided_imr.graph)
+
         else:
-            return cls(pfx + str(uuid4()))
+            # Create a LDP-NR and equip it with the binary file provided.
+            if request.mimetype == 'multipart/form-data':
+                # This seems the "right" way to upload a binary file, with a
+                # multipart/form-data MIME type and the file in the `file`
+                # field. This however is not supported by FCREPO4.
+                stream = request.files.get('file').stream
+                mimetype = request.file.get('file').content_type
+                provided_imr = Resource(Graph(), urn)
+                # @TODO This will turn out useful to provide metadata
+                # with the binary.
+                #metadata = request.files.get('metadata').stream
+                #provided_imr = [parse RDF here...]
+            else:
+                # This is a less clean way, with the file in the form body and
+                # the request as application/x-www-form-urlencoded.
+                # This is how FCREPO4 accepts binary uploads.
+                stream = request.stream
+                mimetype = request.mimetype
+                provided_imr = Resource(Graph(), urn)
 
+            inst = LdpNr(uuid, stream=stream, mimetype=mimetype,
+                    provided_imr=provided_imr, **kwargs)
 
-    @classmethod
-    def set_imr_options(cls, repr_opts):
+        logger.info('Creating resource of type: {}'.format(
+                inst.__class__.__name__))
+
+        return inst
+
+
+    @staticmethod
+    def is_rdf_parsable(mimetype):
+        '''
+        Checks whether a MIME type support RDF parsing by a RDFLib plugin.
+
+        @param mimetype (string) MIME type to check.
         '''
-        Set options to retrieve IMR.
+        try:
+            rdflib.plugin.get(mimetype, rdflib.parser.Parser)
+        except rdflib.plugin.PluginException:
+            return False
+        else:
+            return True
 
-        Ideally, IMR retrieval is done once per request, so all the options
-        are set once in the `imr()` property.
 
-        @param repr_opts (dict): Options parsed from `Prefer` header.
+    @staticmethod
+    def is_rdf_serializable(mimetype):
         '''
-        cls._logger.debug('Setting retrieval options from: {}'.format(repr_opts))
-        imr_options = {}
+        Checks whether a MIME type support RDF serialization by a RDFLib plugin
 
-        if repr_opts.setdefault('value') == 'minimal':
-            imr_options = {
-                'embed_children' : False,
-                'incl_children' : False,
-                'incl_inbound' : False,
-                'incl_srv_mgd' : False,
-            }
+        @param mimetype (string) MIME type to check.
+        '''
+        try:
+            rdflib.plugin.get(mimetype, rdflib.serializer.Serializer)
+        except rdflib.plugin.PluginException:
+            return False
         else:
-            # Default.
-            imr_options = {
-                'embed_children' : False,
-                'incl_children' : True,
-                'incl_inbound' : False,
-                'incl_srv_mgd' : True,
-            }
-
-            # Override defaults.
-            if 'parameters' in repr_opts:
-                include = repr_opts['parameters']['include'].split(' ') \
-                        if 'include' in repr_opts['parameters'] else []
-                omit = repr_opts['parameters']['omit'].split(' ') \
-                        if 'omit' in repr_opts['parameters'] else []
-
-                cls._logger.debug('Include: {}'.format(include))
-                cls._logger.debug('Omit: {}'.format(omit))
-
-                if str(cls.EMBED_CHILD_RES_URI) in include:
-                        imr_options['embed_children'] = True
-                if str(cls.RETURN_CHILD_RES_URI) in omit:
-                        imr_options['incl_children'] = False
-                if str(cls.RETURN_INBOUND_REF_URI) in include:
-                        imr_options['incl_inbound'] = True
-                if str(cls.RETURN_SRV_MGD_RES_URI) in omit:
-                        imr_options['incl_srv_mgd'] = False
-
-        cls._logger.debug('Retrieval options: {}'.format(imr_options))
-
-        return imr_options
+            return True
 
 
     ## MAGIC METHODS ##
 
-    def __init__(self, uuid, repr_opts={}):
+    def __init__(self, uuid, repr_opts={}, provided_imr=None, **kwargs):
         '''Instantiate an in-memory LDP resource that can be loaded from and
         persisted to storage.
 
@@ -243,6 +263,11 @@ class Ldpr(metaclass=ABCMeta):
         @param uuid (string) UUID of the resource. If None (must be explicitly
         set) it refers to the root node. It can also be the full URI or URN,
         in which case it will be converted.
+        @param repr_opts (dict) Options used to retrieve the IMR. See
+        `parse_rfc7240` for format details.
+        @Param provd_rdf (string) RDF data provided by the client in
+        operations isuch as `PUT` or `POST`, serialized as a string. This sets
+        the `provided_imr` property.
         '''
         self.uuid = Toolbox().uri_to_uuid(uuid) \
                 if isinstance(uuid, URIRef) else uuid
@@ -250,12 +275,11 @@ class Ldpr(metaclass=ABCMeta):
                 if self.uuid else self.ROOT_NODE_URN
         self.uri = Toolbox().uuid_to_uri(self.uuid)
 
-        self.repr_opts = repr_opts
-        self._imr_options = __class__.set_imr_options(self.repr_opts)
-
         self.rdfly = current_app.rdfly
         self.nonrdfly = current_app.nonrdfly
 
+        self.provided_imr = provided_imr
+
 
     @property
     def rsrc(self):
@@ -282,8 +306,12 @@ class Ldpr(metaclass=ABCMeta):
         @return rdflib.resource.Resource
         '''
         if not hasattr(self, '_imr'):
-            self._logger.debug('IMR options: {}'.format(self._imr_options))
-            options = dict(self._imr_options, strict=True)
+            if hasattr(self, '_imr_options'):
+                self._logger.debug('IMR options: {}'.format(self._imr_options))
+                imr_options = self._imr_options
+            else:
+                imr_options = {}
+            options = dict(imr_options, strict=True)
             self._imr = self.rdfly.extract_imr(self.urn, **options)
 
         return self._imr
@@ -300,7 +328,12 @@ class Ldpr(metaclass=ABCMeta):
         @return rdflib.resource.Resource
         '''
         if not hasattr(self, '_imr'):
-            options = dict(self._imr_options, strict=True)
+            if hasattr(self, '_imr_options'):
+                self._logger.debug('IMR options: {}'.format(self._imr_options))
+                imr_options = self._imr_options
+            else:
+                imr_options = {}
+            options = dict(imr_options, strict=True)
             try:
                 self._imr = self.rdfly.extract_imr(self.urn, **options)
             except ResourceNotExistsError:
@@ -329,7 +362,7 @@ class Ldpr(metaclass=ABCMeta):
         # Remove digest hash.
         self.imr.remove(nsc['premis'].hasMessageDigest)
 
-        if not self._imr_options.setdefault('incl_srv_mgd', False):
+        if not self._imr_options.setdefault('incl_srv_mgd', True):
             for p in srv_mgd_predicates:
                 self._logger.debug('Removing predicate: {}'.format(p))
                 self.imr.remove(p)
@@ -382,7 +415,6 @@ class Ldpr(metaclass=ABCMeta):
         '''
         out_headers = defaultdict(list)
 
-        self._logger.debug('IMR options in head(): {}'.format(self._imr_options))
         digest = self.imr.value(nsc['premis'].hasMessageDigest)
         if digest:
             etag = digest.identifier.split(':')[-1]
@@ -437,7 +469,8 @@ class Ldpr(metaclass=ABCMeta):
 
         for child_uri in children:
             child_rsrc = Ldpr.inst(
-                Toolbox().uri_to_uuid(child_uri.identifier), self.repr_opts)
+                Toolbox().uri_to_uuid(child_uri.identifier),
+                repr_opts={'incl_children' : False})
             child_rsrc._delete_rsrc(inbound, leave_tstone,
                     tstone_pointer=self.urn)
 
@@ -502,8 +535,8 @@ class Ldpr(metaclass=ABCMeta):
         '''
         self._logger.info('Removing resource {}'.format(self.urn))
 
-        remove_trp = set(self.imr.graph)
-        add_trp = set()
+        remove_trp = self.imr.graph
+        add_trp = Graph()
 
         if leave_tstone:
             if tstone_pointer:
@@ -527,18 +560,37 @@ class Ldpr(metaclass=ABCMeta):
         return self.RES_DELETED
 
 
-    def _modify_rsrc(self, ev_type, remove_trp={}, add_trp={}):
+    def _modify_rsrc(self, ev_type, remove_trp=Graph(), add_trp=Graph()):
         '''
         Low-level method to modify a graph for a single resource.
 
-        @param remove_trp (Iterable) Triples to be removed. This can be a graph
-        @param add_trp (Iterable) Triples to be added. This can be a graph.
-        '''
+        @param ev_type (string) The type of event (create, update, delete).
+        @param remove_trp (rdflib.Graph) Triples to be removed.
+        @param add_trp (rdflib.Graph) Triples to be added.
+        '''
+        # If one of the triple sets is not a graph, do a set merge and
+        # filtering. This is necessary to support non-RDF terms (e.g.
+        # variables).
+        if not isinstance(remove_trp, Graph) or not isinstance(add_trp, Graph):
+            if isinstance(remove_trp, Graph):
+                remove_trp = set(remove_trp)
+            if isinstance(add_trp, Graph):
+                add_trp = set(add_trp)
+            merge_g = remove_trp | add_trp
+            type = { trp[2] for trp in merge_g if trp[1] == RDF.type }
+            actor = { trp[2] for trp in merge_g \
+                    if trp[1] == nsc['fcrepo'].createdBy }
+        else:
+            merge_g = remove_trp | add_trp
+            type = merge_g[ self.urn : RDF.type ]
+            actor = merge_g[ self.urn : nsc['fcrepo'].createdBy ]
+
+
         return self.rdfly.modify_dataset(remove_trp, add_trp, metadata={
             'ev_type' : ev_type,
             'time' : arrow.utcnow(),
-            'type' : list(self.imr.graph.objects(self.urn, RDF.type)),
-            'actor' : self.imr.value(nsc['fcrepo'].lastModifiedBy),
+            'type' : type,
+            'actor' : actor,
         })
 
 
@@ -644,8 +696,8 @@ class Ldpr(metaclass=ABCMeta):
 
         @param cont_uri (rdflib.term.URIRef)  The container URI.
         '''
-        repr_opts = {'parameters' : {'omit' : Ldpr.RETURN_CHILD_RES_URI }}
-        cont_rsrc = Ldpr.inst(cont_uri, repr_opts=repr_opts)
+        cont_uuid = Toolbox().uri_to_uuid(cont_uri)
+        cont_rsrc = Ldpr.inst(cont_uuid, repr_opts={'incl_children' : False})
         cont_p = set(cont_rsrc.imr.graph.predicates())
         add_g = Graph()
 
@@ -677,7 +729,7 @@ class Ldpr(metaclass=ABCMeta):
             add_g = self._check_mgd_terms(add_g)
             self._logger.debug('Adding DC/IC triples: {}'.format(
                 add_g.serialize(format='turtle').decode('utf-8')))
-            rsrc._modify_rsrc(self.RES_UPDATED, attr_trp=add_g)
+            rsrc._modify_rsrc(self.RES_UPDATED, add_trp=add_g)
 
 
     def _send_event_msg(self, remove_trp, add_trp, metadata):

lakesuperior/store_layouts/ldp_rs/base_rdf_layout.py

@@ -2,6 +2,7 @@ import logging
 
 from abc import ABCMeta, abstractmethod
 
+from rdflib import Graph
 from rdflib.namespace import RDF
 from rdflib.query import ResultException
 from rdflib.resource import Resource
@@ -119,7 +120,8 @@ class BaseRdfLayout(metaclass=ABCMeta):
 
 
     @abstractmethod
-    def modify_dataset(self, remove_trp=[], add_trp=[], metadata={}):
+    def modify_dataset(self, remove_trp=Graph(), add_trp=Graph(),
+            metadata=None):
         '''
         Adds and/or removes triples from the graph.
 
@@ -141,29 +143,3 @@ class BaseRdfLayout(metaclass=ABCMeta):
         pass
 
 
-    def _enqueue_event(self, remove_trp, add_trp):
-        '''
-        Group delta triples by subject and send out to event queue.
-
-        The event queue is stored in the request context and is processed
-        after `store.commit()` is called by the `atomic` decorator.
-        '''
-        remove_grp = groupby(remove_trp, lambda x : x[0])
-        remove_dict = { k[0] : k[1] for k in remove_grp }
-
-        add_grp = groupby(add_trp, lambda x : x[0])
-        add_dict = { k[0] : k[1] for k in add_grp }
-
-        subjects = set(remove_dict.keys()) | set(add_dict.keys())
-        for rsrc_uri in subjects:
-            request.changelog.append(
-                uri=rsrc_uri,
-                ev_type=None,
-                time=arrow.utcnow(),
-                type=list(imr.graph.subjects(imr.identifier, RDF.type)),
-                data=imr.graph,
-                metadata={
-                    'actor' : imr.value(nsc['fcrepo'].lastModifiedBy),
-                }
-            )
-

lakesuperior/store_layouts/ldp_rs/simple_layout.py

@@ -106,7 +106,8 @@ class SimpleLayout(BaseRdfLayout):
             's' : urn})
 
 
-    def modify_dataset(self, remove_trp=[], add_trp=[], metadata=None):
+    def modify_dataset(self, remove_trp=Graph(), add_trp=Graph(),
+            metadata=None):
         '''
         See base_rdf_layout.update_rsrc.
         '''
@@ -119,4 +120,4 @@ class SimpleLayout(BaseRdfLayout):
             self.ds.add(t)
 
         if current_app.config.setdefault('messaging') and metadata:
-            request.changelog.append((remove_trp, add_trp, metadata))
+            request.changelog.append((set(remove_trp), set(add_trp), metadata))

lakesuperior/toolbox.py

@@ -209,3 +209,4 @@ class Toolbox:
 
         return hash
 
+

tests/endpoints/test_ldp.py

@@ -63,7 +63,8 @@ class TestLdp:
         with open('tests/data/marcel_duchamp_single_subject.ttl', 'rb') as f:
             self.client.put('/ldp/ldprs01', data=f, content_type='text/turtle')
 
-        resp = self.client.get('/ldp/ldprs01', headers={'accept' : 'text/turtle'})
+        resp = self.client.get('/ldp/ldprs01',
+                headers={'accept' : 'text/turtle'})
         assert resp.status_code == 200
 
         g = Graph().parse(data=resp.data, format='text/turtle')
@@ -251,7 +252,7 @@ class TestPrefHeader:
         assert self.client.put(path).status_code == 204
         with open('tests/data/rdf_payload_w_srv_mgd_trp.ttl', 'rb') as f:
             rsp_len = self.client.put(
-                '/ldp/{}'.format(random_uuid),
+                path,
                 headers={
                     'Prefer' : 'handling=lenient',
                     'Content-Type' : 'text/turtle',