Merge branch 'to_DTS' of https://github.com/Capitains/flask-capitains…

…-nemo into to_DTS

.travis.yml

@@ -1,6 +1,5 @@
 language: python
 python:
-  - "3.4.5"
   - "3.5"
   - "3.6"
 # command to install dependencies

flask_nemo/plugins/annotations_api.py

@@ -34,7 +34,7 @@ class AnnotationsApiPlugin(PluginPrototype):
 
     def __init__(self, queryinterface, *args, **kwargs):
         super(AnnotationsApiPlugin, self).__init__(*args, **kwargs)
-        self.__queryinterface__ = queryinterface
+        self._queryinterface = queryinterface
 
     # TODO we should have a response at the base of annotations/api that returns link types and link relations
     # showing the next level of options 
@@ -63,13 +63,13 @@ def r_annotations(self):
             except ValueError:
                 return "invalid urn", 400
 
-            count, annotations = self.__queryinterface__.getAnnotations(urn, wildcard=wildcard, include=include,
-                                                                        exclude=exclude, limit=limit, start=start,
-                                                                        expand=expand)
+            count, annotations = self._queryinterface.getAnnotations(urn, wildcard=wildcard, include=include,
+                                                                     exclude=exclude, limit=limit, start=start,
+                                                                     expand=expand)
         else:
             #  Note that this implementation is not done for too much annotations
             #  because we do not implement pagination here
-            count, annotations = self.__queryinterface__.getAnnotations(None, limit=limit, start=start, expand=expand)
+            count, annotations = self._queryinterface.getAnnotations(None, limit=limit, start=start, expand=expand)
         mapped = []
         response = {
             "@context": type(self).JSONLD_CONTEXT,
@@ -102,7 +102,7 @@ def r_annotation(self, sha):
         :return: annotation contents
         :rtype: {str: Any}
         """
-        annotation = self.__queryinterface__.getResource(sha)
+        annotation = self._queryinterface.getResource(sha)
         if not annotation:
             return "invalid resource uri", 404
         response = {
@@ -125,7 +125,7 @@ def r_annotation_body(self, sha):
         :return: annotation contents
         :rtype: {str: Any}
         """
-        annotation = self.__queryinterface__.getResource(sha)
+        annotation = self._queryinterface.getResource(sha)
         if not annotation:
             return "invalid resource uri", 404
         # TODO this should inspect the annotation content

flask_nemo/query/annotation.py

@@ -25,16 +25,16 @@ def __init__(self, objectId, subreference=None, **kwargs):
                 subreference = None
         elif isinstance(objectId, tuple):
             objectId, subreference = objectId
-        self.__objectId__ = objectId
-        self.__subreference__ = subreference
+        self._objectId = objectId
+        self._subreference = subreference
 
     @property
     def objectId(self):
-        return self.__objectId__
+        return self._objectId
 
     @property
     def subreference(self):
-        return self.__subreference__
+        return self._subreference
 
     def to_json(self):
         """ Method to call to get a serializable object for json.dump or jsonify based on the target
@@ -84,45 +84,45 @@ class AnnotationResource(object):
     SLUG = "annotation"
 
     def __init__(self, uri, target, type_uri, resolver, target_class=Target, mimetype=None, slug=None, **kwargs):
-        self.__uri__ = uri
+        self._uri = uri
         if not isinstance(target, Target):
-            self.__target__ = target_class(target)
+            self._target = target_class(target)
         else:
-            self.__target__ = target
-        self.__type_uri__ = type_uri
-        self.__slug__ = slug or deepcopy(type(self).SLUG)
-        self.__sha__ = hashlib.sha256(
+            self._target = target
+        self._type_uri = type_uri
+        self._slug = slug or deepcopy(type(self).SLUG)
+        self._sha = hashlib.sha256(
             "{uri}::{type_uri}".format(uri=uri, type_uri=type_uri).encode('utf-8')
         ).hexdigest()
 
-        self.__content__ = None
-        self.__resolver__ = resolver
-        self.__retriever__ = None
-        self.__mimetype__ = mimetype
+        self._content = None
+        self._resolver = resolver
+        self._retriever = None
+        self._mimetype = mimetype
 
     @property
     def mimetype(self):
-        return self.__mimetype__
+        return self._mimetype
 
     @property
     def sha(self):
-        return self.__sha__
+        return self._sha
 
     @property
     def uri(self):
-        return self.__uri__
+        return self._uri
 
     @property
     def type_uri(self):
-        return self.__type_uri__
+        return self._type_uri
 
     @property
     def slug(self):
-        return self.__slug__
+        return self._slug
 
     @property
     def target(self):
-        return self.__target__
+        return self._target
 
     @property
     def expandable(self):
@@ -135,10 +135,10 @@ def read(self):
         :return: the contents of the resource
         :rtype: str or bytes or flask.response
         """
-        if not self.__content__:
-            self.__retriever__ = self.__resolver__.resolve(self.uri)
-            self.__content__, self.__mimetype__ = self.__retriever__.read(self.uri)
-        return self.__content__
+        if not self._content:
+            self._retriever = self._resolver.resolve(self.uri)
+            self._content, self._mimetype = self._retriever.read(self.uri)
+        return self._content
 
     def expand(self): 
         """ Expand the contents of the Annotation if it is expandable  (i.e. if it references  multiple resources)

flask_nemo/query/interface.py

@@ -23,22 +23,22 @@ class SimpleQuery(QueryPrototype):
 
     def __init__(self, annotations, resolver=None):
         super(SimpleQuery, self).__init__(None)
-        self.__annotations__ = []
-        self.__nemo__ = None
-        self.__resolver__ = resolver
+        self._annotations = []
+        self._nemo = None
+        self._resolver = resolver
 
         for resource in annotations:
             if isinstance(resource, tuple):
                 target, body, type_uri = resource
-                self.__annotations__.append(AnnotationResource(
-                    body, target, type_uri, self.__resolver__
+                self._annotations.append(AnnotationResource(
+                    body, target, type_uri, self._resolver
                 ))
             else:
-                self.__annotations__.append(resource)
+                self._annotations.append(resource)
 
     @property
     def textResolver(self):
-        return self.__nemo__.resolver
+        return self._nemo.resolver
 
     def process(self, nemo):
         """ Register nemo and parses annotations
@@ -47,16 +47,16 @@ def process(self, nemo):
 
         :param nemo: Nemo
         """
-        self.__nemo__ = nemo
-        for annotation in self.__annotations__:
+        self._nemo = nemo
+        for annotation in self._annotations:
             annotation.target.expanded = frozenset(
-                self.__getinnerreffs__(
+                self._getinnerreffs(
                     objectId=annotation.target.objectId,
                     subreference=annotation.target.subreference
                 )
             )
 
-    def __get_resource_metadata__(self, objectId):
+    def _get_resource_metadata(self, objectId):
         """ Return a metadata text object
 
         :param objectId: objectId of the text
@@ -66,7 +66,7 @@ def __get_resource_metadata__(self, objectId):
 
     @property
     def annotations(self):
-        return self.__annotations__
+        return self._annotations
 
     def getResource(self, sha):
         try:
@@ -92,7 +92,7 @@ def getAnnotations(self, targets, wildcard=".", include=None, exclude=None, limi
             else:
                 objectId, subreference = target, None
 
-            ref_in_range = list(self.__getinnerreffs__(
+            ref_in_range = list(self._getinnerreffs(
                 objectId=objectId,
                 subreference=subreference
             ))
@@ -110,7 +110,7 @@ def getAnnotations(self, targets, wildcard=".", include=None, exclude=None, limi
 
         return len(annotations), sorted(annotations, key=lambda x: x.uri)
 
-    def __getinnerreffs__(self, objectId, subreference):
+    def _getinnerreffs(self, objectId, subreference):
         """ Resolve the list of urns between in a range
 
         :param text_metadata: Resource Metadata
@@ -124,7 +124,7 @@ def __getinnerreffs__(self, objectId, subreference):
         yield subreference
         while level > -1:
             try:
-                reffs = self.__nemo__.resolver.getReffs(
+                reffs = self._nemo.resolver.getReffs(
                     objectId,
                     subreference=subreference,
                     level=level

flask_nemo/query/proto.py

@@ -18,7 +18,7 @@ class QueryPrototype(object):
     MATCH_ALL = "%.%"
 
     def __init__(self, getreffs, **kwargs):
-        self.__getreffs__ = getreffs
+        self._getreffs = getreffs
 
     def getAnnotations(self, targets, wildcard=".", include=None, exclude=None, limit=None, start=1, expand=False,
                        **kwargs):

flask_nemo/query/resolve.py

@@ -19,7 +19,7 @@ class Resolver(object):
     """
 
     def __init__(self, *retrievers, **kwargs):
-        self.__retrievers__ = retrievers
+        self._retrievers = retrievers
 
     def resolve(self, uri):
         """ Resolve a Resource identified by URI
@@ -28,7 +28,7 @@ def resolve(self, uri):
         :return: the contents of the resource as a string
         :rtype: str
         """
-        for r in self.__retrievers__:
+        for r in self._retrievers:
             if r.match(uri):
                 return r
         raise UnresolvableURIError()
@@ -62,7 +62,7 @@ def read(self, uri):
 class HTTPRetriever(RetrieverPrototype):
     """ Http retriever retrieves resources being remotely hosted in CTS
     """
-    __reg_exp__ = re.compile("^(https?:)?//")
+    _reg_exp = re.compile("^(https?:)?//")
 
     def match(self, uri):
         """ Check to see if this URI is retrievable by this Retriever implementation
@@ -73,7 +73,7 @@ def match(self, uri):
         :rtype: bool
         """
         # prototype implementation can't retrieve anything!
-        return HTTPRetriever.__reg_exp__.match(uri) is not None
+        return HTTPRetriever._reg_exp.match(uri) is not None
 
     def read(self, uri):
         """ Retrieve the contents of the resource
@@ -99,7 +99,7 @@ class LocalRetriever(RetrieverPrototype):
     def __init__(self, path="./"):
         self.__path__ = op.abspath(path)
 
-    def __absolute__(self, uri):
+    def _absolute(self, uri):
         """ Get the absolute uri for a file
 
         :param uri: URI of the resource to be retrieved
@@ -115,7 +115,7 @@ def match(self, uri):
         :return: True if it can be, False if not
         :rtype: bool
         """
-        absolute_uri = self.__absolute__(uri)
+        absolute_uri = self._absolute(uri)
 
         return absolute_uri.startswith(self.__path__) and op.exists(absolute_uri)
 
@@ -127,7 +127,7 @@ def read(self, uri):
         :return: the contents of the resource
         :rtype: str
         """
-        uri = self.__absolute__(uri)
+        uri = self._absolute(uri)
         mime, _ = guess_type(uri)
         if "image" in mime:
             return send_file(uri), mime
@@ -145,10 +145,10 @@ class CTSRetriever(RetrieverPrototype):
     :param resolver: CTS5 Resolver
     :type resolver: MyCapytain.resolver.cts.*
     """
-    __reg_exp__ = re.compile("^urn:cts:")
+    _reg_exp = re.compile("^urn:cts:")
 
     def __init__(self, resolver):
-        self.__resolver__ = resolver
+        self._resolver = resolver
 
     @staticmethod
     def match(uri):
@@ -160,7 +160,7 @@ def match(uri):
         :rtype: bool
         """
         # prototype implementation can't retrieve anything!
-        return CTSRetriever.__reg_exp__.match(uri) is not None
+        return CTSRetriever._reg_exp.match(uri) is not None
 
     def read(self, uri):
         """ Retrieve the contents of the resource
@@ -170,4 +170,4 @@ def read(self, uri):
         :return: the contents of the resource
         :rtype: str
         """
-        return self.__resolver__.getTextualNode(uri).export(Mimetypes.XML.TEI), "text/xml"
+        return self._resolver.getTextualNode(uri).export(Mimetypes.XML.TEI), "text/xml"

tests/test_plugins/test_annotations_api.py

@@ -37,7 +37,7 @@ def getResource(self, sha):
             annotation.read = lambda: Response("a", headers={"Content-Type": "text/plain"})
             annotation.read = lambda: Response("a", headers={"Content-Type": "text/plain"})
         else:
-            annotation.__mimetype__ = "application/xml"
+            annotation._mimetype = "application/xml"
             annotation.read = lambda: "123"
         return annotation
 

tests/test_query/test_retriever.py

@@ -168,7 +168,7 @@ def test_retrieve_resource(self):
             if sendfile:
                 with patch("flask_nemo.query.resolve.send_file", return_value=content) as patched:
                     data, mimetype = ret.read(uri)
-                    patched.assert_called_with(ret.__absolute__(uri))
+                    patched.assert_called_with(ret._absolute(uri))
             else:
                 data, mimetype = ret.read(uri)