pyPreservica 2.9.1__tar.gz → 2.9.2__tar.gz

{pypreservica-2.9.1 → pypreservica-2.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyPreservica
-Version: 2.9.1
+Version: 2.9.2
 Summary: Python library for the Preservica API
 Home-page: https://pypreservica.readthedocs.io/
 Author: James Carr

{pypreservica-2.9.1 → pypreservica-2.9.2}/pyPreservica/__init__.py

@@ -23,6 +23,6 @@ from .mdformsAPI import MetadataGroupsAPI, Group, GroupField, GroupFieldType
 __author__ = "James Carr (drjamescarr@gmail.com)"
 
 # Version of the pyPreservica package
-__version__ = "2.9.1"
+__version__ = "2.9.2"
 
 __license__ = "Apache License Version 2.0"

{pypreservica-2.9.1 → pypreservica-2.9.2}/pyPreservica/common.py

@@ -79,9 +79,9 @@ class FileHash:
 
 def identifiersToDict(identifiers: set) -> dict:
     """
-    Convert a set of tuples to a dict
-    :param identifiers:
-    :return:
+        Convert a set of tuples to a dict
+        :param identifiers:
+        :return:
     """
     result = {}
     for identifier_tuple in identifiers:

{pypreservica-2.9.1 → pypreservica-2.9.2}/pyPreservica/contentAPI.py

@@ -238,6 +238,10 @@ class ContentAPI(AuthenticatedAPI):
         :param page_size:  The default search page size
         :return: search result
         """
+
+        if self.major_version < 7 and self.minor_version < 5:
+            raise RuntimeError("search_fields API call is not available when connected to a v7.5 System")
+
         search_result = self._search_fields(query=query, fields=fields, start_index=0, page_size=page_size)
         for e in search_result.results_list:
             yield e

{pypreservica-2.9.1 → pypreservica-2.9.2}/pyPreservica/entityAPI.py

@@ -454,6 +454,7 @@ class EntityAPI(AuthenticatedAPI):
             logger.error(request)
             raise RuntimeError(request.status_code, "delete_identifier failed")
 
+
     def identifiers_for_entity(self, entity: Entity) -> set[Tuple]:
         """
              Get all external identifiers on an entity
@@ -491,6 +492,8 @@ class EntityAPI(AuthenticatedAPI):
             logger.error(exception)
             raise exception
 
+
+
     def identifier(self, identifier_type: str, identifier_value: str) -> set[Entity]:
         """
              Get all entities which have the external identifier

{pypreservica-2.9.1 → pypreservica-2.9.2}/pyPreservica/mdformsAPI.py

@@ -8,6 +8,7 @@ author:     James Carr
 licence:    Apache License 2.0
 
 """
+import json
 import xml.etree.ElementTree
 from typing import Callable, List, Union, Generator
 
@@ -247,6 +248,75 @@ class MetadataGroupsAPI(AuthenticatedAPI):
         json_response: dict = self.add_group_json(json_document)
         return json_response
 
+    def add_form(self, json_form: Union[dict, str]):
+        """
+        Create a new Metadata fORM using a JSON dictionary object or document
+
+        :param json_form: JSON dictionary or string
+        :type json_form: dict
+
+        :return:  JSON document
+        :rtype: dict
+
+        """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/forms/'
+
+        if isinstance(json_form, dict):
+            with self.session.post(url, headers=headers, json=json_form) as request:
+                if request.status_code == requests.codes.unauthorized:
+                    self.token = self.__token__()
+                    return self.add_form_json(json_form)
+                elif request.status_code == requests.codes.created:
+                    return json.loads(str(request.content.decode('utf-8')))
+                else:
+                    exception = HTTPException(None, request.status_code, request.url, "add_form_json",
+                                              request.content.decode('utf-8'))
+                    logger.error(exception)
+                    raise exception
+
+        elif isinstance(json_form, str):
+            with self.session.post(url, headers=headers, data=json_form) as request:
+                if request.status_code == requests.codes.unauthorized:
+                    self.token = self.__token__()
+                    return self.add_form_json(json_form)
+                elif request.status_code == requests.codes.created:
+                    return json.loads(str(request.content.decode('utf-8')))
+                else:
+                    exception = HTTPException(None, request.status_code, request.url, "add_form_json",
+                                              request.content.decode('utf-8'))
+                    logger.error(exception)
+                    raise exception
+        else:
+            raise RuntimeError("Argument must be a JSON dictionary or a JSON str")
+
+
+    # def set_default_form(self, form_id: str):
+    #     """
+    #     Set the default form
+    #
+    #     """
+    #
+    #     headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+    #     url = f'{self.protocol}://{self.server}/api/metadata/forms/{form_id}/default'
+    #
+    #     payload: dict = {"default": True, "useAsDefault": True}
+    #
+    #     with self.session.get(url, headers=headers, json=json.dumps(payload)) as request:
+    #         if request.status_code == requests.codes.unauthorized:
+    #             self.token = self.__token__()
+    #             return self.set_default_form(form_id)
+    #         elif request.status_code == requests.codes.ok:
+    #             return json.loads(str(request.content.decode('utf-8')))
+    #         else:
+    #             exception = HTTPException(None, request.status_code, request.url, "set_default_form",
+    #                                       request.content.decode('utf-8'))
+    #             logger.error(exception)
+    #             raise exception
+
+
+
+
     def add_group_json(self, json_object: Union[dict, str]) -> dict:
         """
           Create a new Metadata Group using a JSON dictionary object or document
@@ -351,6 +421,63 @@ class MetadataGroupsAPI(AuthenticatedAPI):
                 logger.error(exception)
                 raise exception
 
+    def forms(self, schema_uri: str|None = None) -> dict:
+        """
+            Return all the metadata Forms in the tenancy as a list of JSON dict objects
+
+            :param schema_uri: The Form schema Uri
+            :type schema_uri: str
+
+            :return: List of JSON dictionary object
+            :rtype: dict
+
+        """
+
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/forms'
+        params = {}
+        if schema_uri is not None:
+            params = {'schemaUri': schema_uri}
+        with self.session.get(url, headers=headers, params=params) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.forms_json()
+            elif request.status_code == requests.codes.ok:
+                return json.loads(str(request.content.decode('utf-8')))['metadataForms']
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "forms_json",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+
+    def form(self, form_id: str) -> dict:
+        """
+             Return a Form as a JSON dict object
+
+             :param form_id: The Form id
+             :type form_id: str
+
+             :return:  JSON document
+             :rtype: dict
+
+         """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/forms/{form_id}'
+        with self.session.get(url, headers=headers) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.form_json(form_id)
+            elif request.status_code == requests.codes.ok:
+                return json.loads(str(request.content.decode('utf-8')))
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "form_json",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+
+
     def groups(self) -> Generator[Group, None, None]:
         """
         Return all the metadata Groups in the tenancy as Group Objects

{pypreservica-2.9.1 → pypreservica-2.9.2}/pyPreservica.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyPreservica
-Version: 2.9.1
+Version: 2.9.2
 Summary: Python library for the Preservica API
 Home-page: https://pypreservica.readthedocs.io/
 Author: James Carr

{pypreservica-2.9.1 → pypreservica-2.9.2}/setup.py

@@ -21,7 +21,7 @@ if sys.argv[-1] == 'publish':
 # This call to setup() does all the work
 setup(
     name=PKG,
-    version="2.9.1",
+    version="2.9.2",
     description="Python library for the Preservica API",
     long_description=README,
     long_description_content_type="text/markdown",

{pypreservica-2.9.1 → pypreservica-2.9.2}/tests/test_workflow.py

@@ -11,7 +11,7 @@ def test_get_workflow_contexts():
 def test_get_workflow_contexts2():
     workflow = WorkflowAPI()
     workflows = workflow.get_workflow_contexts("com.preservica.core.workflow.ingest")
-    assert len(workflows) == 1
+    assert len(workflows) == 3
 
 
 def test_get_workflow_contexts3():
@@ -24,7 +24,7 @@ def test_get_workflow_contexts_type():
     workflow = WorkflowAPI()
 
     workflows = workflow.get_workflow_contexts_by_type("Ingest")
-    assert len(workflows) == 6
+    assert len(workflows) == 8
 
     workflows = workflow.get_workflow_contexts_by_type("Access")
     assert len(workflows) == 5