Separate exceptions into their own module.

lakesuperior/endpoints/ldp.py

@@ -2,7 +2,7 @@ import logging
 
 from flask import Blueprint, request
 
-from lakesuperior.model.ldpr import InvalidResourceError, \
+from lakesuperior.exceptions import InvalidResourceError, \
         ResourceNotExistsError, ServerManagedTermError
 
 from lakesuperior.model.ldp_rs import Ldpc, LdpRs

lakesuperior/model/ldp_rs.py

@@ -8,8 +8,9 @@ from rdflib.term import URIRef, Literal, Variable
 from lakesuperior.dictionaries.namespaces import ns_collection as nsc
 from lakesuperior.dictionaries.srv_mgd_terms import  srv_mgd_subjects, \
         srv_mgd_predicates, srv_mgd_types
-from lakesuperior.model.ldpr import Ldpr, transactional, must_exist, \
-        ResourceNotExistsError, ServerManagedTermError
+from lakesuperior.model.ldpr import Ldpr, transactional, must_exist
+from lakesuperior.exceptions import ResourceNotExistsError, \
+        ServerManagedTermError, SingleSubjectError
 from lakesuperior.util.translator import Translator
 
 class LdpRs(Ldpr):
@@ -56,7 +57,7 @@ class LdpRs(Ldpr):
         '''
         im_rsrc = self.rdfly.out_rsrc(inbound)
         if not len(im_rsrc.graph):
-            raise ResourceNotExistsError()
+            raise ResourceNotExistsError(im_rsrc.uuid)
 
         return Translator.globalize_rsrc(im_rsrc)
 
@@ -119,21 +120,15 @@ class LdpRs(Ldpr):
         '''
         offending_subjects = set(g.subjects()) & srv_mgd_subjects
         if offending_subjects:
-            raise ServerManagedTermError('Some subjects in RDF payload '
-                    'are server managed and cannot be modified: {}'
-                    .format(' , '.join(offending_subjects)))
+            raise ServerManagedTermError(offending_subjects, 's')
 
         offending_predicates = set(g.predicates()) & srv_mgd_predicates
         if offending_predicates:
-            raise ServerManagedTermError('Some predicates in RDF payload '
-                    'are server managed and cannot be modified: {}'
-                    .format(' , '.join(offending_predicates)))
+            raise ServerManagedTermError(offending_predicates, 'p')
 
         offending_types = set(g.objects(predicate=RDF.type)) & srv_mgd_types
         if offending_types:
-            raise ServerManagedTermError('Some RDF types in RDF payload '
-                    'are server managed and cannot be modified: {}'
-                    .format(' , '.join(offending_types)))
+            raise ServerManagedTermError(offending_types, 't')
 
 
     def _check_mgd_terms_sparql(self, q):
@@ -162,17 +157,11 @@ class LdpRs(Ldpr):
 
         for s,p,o in delta:
             if s in srv_mgd_subjects:
-                raise ServerManagedTermError(
-                        'Subject {} is server managed and cannot be modified.'
-                        .format(s))
+                raise ServerManagedTermError(s, 's')
             if p in srv_mgd_predicates:
-                raise ServerManagedTermError(
-                        'Predicate {} is server managed and cannot be modified.'
-                        .format(p))
+                raise ServerManagedTermError(p, 'p')
             if p == RDF.type and o in srv_mgd_types:
-                raise ServerManagedTermError(
-                        'RDF type {} is server managed and cannot be modified.'
-                        .format(o))
+                raise ServerManagedTermError(o, 't')
 
 
     def _ensure_single_subject_sparql_update(self, qs):

lakesuperior/model/ldpr.py

@@ -12,51 +12,11 @@ from rdflib.namespace import RDF, XSD
 from lakesuperior.config_parser import config
 from lakesuperior.connectors.filesystem_connector import FilesystemConnector
 from lakesuperior.dictionaries.namespaces import ns_collection as nsc
+from lakesuperior.exceptions import InvalidResourceError, \
+        ResourceNotExistsError, ServerManagedTermError
 from lakesuperior.util.translator import Translator
 
 
-class ResourceExistsError(RuntimeError):
-    '''
-    Raised in an attempt to create a resource a URN that already exists and is
-    not supposed to.
-
-    This usually surfaces at the HTTP level as a 409.
-    '''
-    pass
-
-
-
-class ResourceNotExistsError(RuntimeError):
-    '''
-    Raised in an attempt to create a resource a URN that does not exist and is
-    supposed to.
-
-    This usually surfaces at the HTTP level as a 404.
-    '''
-    pass
-
-
-
-class InvalidResourceError(RuntimeError):
-    '''
-    Raised when an invalid resource is found.
-
-    This usually surfaces at the HTTP level as a 409 or other error.
-    '''
-    pass
-
-
-
-class ServerManagedTermError(RuntimeError):
-    '''
-    Raised in an attempt to change a triple containing a server-managed term.
-
-    This usually surfaces at the HTTP level as a 409 or other error.
-    '''
-    pass
-
-
-
 def transactional(fn):
     '''
     Decorator for methods of the Ldpr class to handle transactions in an RDF
@@ -83,8 +43,7 @@ def must_exist(fn):
     '''
     def wrapper(self, *args, **kwargs):
         if not self.is_stored:
-            raise ResourceNotExistsError(
-                'Resource #{} not found'.format(self.uuid))
+            raise ResourceNotExistsError(self.uuid)
         return fn(self, *args, **kwargs)
 
     return wrapper
@@ -97,8 +56,7 @@ def must_not_exist(fn):
     '''
     def wrapper(self, *args, **kwargs):
         if self.is_stored:
-            raise ResourceExistsError(
-                'Resource #{} already exists.'.format(self.uuid))
+            raise ResourceExistsError(self.uuid)
         return fn(self, *args, **kwargs)
 
     return wrapper
@@ -318,8 +276,7 @@ class Ldpr(metaclass=ABCMeta):
             if t == cls.LDP_RS_TYPE:
                 return LdpRs(uuid)
 
-        raise ResourceNotExistsError('Resource #{} does not exist or does not '
-                'have a valid LDP type.'.format(uuid))
+        raise ResourceNotExistsError(uuid)
 
 
     @classmethod
@@ -342,8 +299,7 @@ class Ldpr(metaclass=ABCMeta):
         if parent_uuid:
             parent_exists = rdfly.ask_rsrc_exists(parent_imr.identifier)
             if not parent_exists:
-                raise ResourceNotExistsError('Parent not found: {}.'
-                        .format(parent_uuid))
+                raise ResourceNotExistsError(parent_uuid)
 
             parent_types = { t.identifier for t in \
                     parent_imr.objects(RDF.type) }