pyPreservica 2.9.0__py3-none-any.whl → 2.9.2__py3-none-any.whl

pyPreservica/__init__.py

@@ -7,7 +7,7 @@ licence:    Apache License 2.0
 
 """
 from .common import *
-from .contentAPI import ContentAPI
+from .contentAPI import ContentAPI, Field, SortOrder
 from .entityAPI import EntityAPI
 from .uploadAPI import UploadAPI, simple_asset_package, complex_asset_package, cvs_to_xsd, cvs_to_xml, \
                     cvs_to_cmis_xslt, csv_to_search_xml, generic_asset_package, upload_config, multi_asset_package
@@ -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.0"
+__version__ = "2.9.2"
 
 __license__ = "Apache License Version 2.0"

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/contentAPI.py

@@ -10,11 +10,28 @@ licence:    Apache License 2.0
 """
 
 import csv
-from typing import Generator, Callable
+from typing import Generator, Callable, Optional
 from pyPreservica.common import *
 
 logger = logging.getLogger(__name__)
 
+class SortOrder(Enum):
+    asc = 1
+    desc = 2
+
+class Field:
+    name: str
+    value: Optional[str]
+    operator: Optional[str]
+    sort_order: Optional[SortOrder]
+
+    def __init__(self, name: str, value: str, operator: Optional[str]=None, sort_order: Optional[SortOrder]=None):
+        self.name = name
+        self.value = value
+        self.operator = operator
+        self.sort_order = sort_order
+
+
 
 class ContentAPI(AuthenticatedAPI):
 
@@ -212,6 +229,97 @@ class ContentAPI(AuthenticatedAPI):
             writer.writeheader()
             writer.writerows(self.search_index_filter_list(query, page_size, filter_values, sort_values))
 
+    def search_fields(self, query: str = "%",  fields: list[Field]=None,  page_size: int = 25) -> Generator:
+        """
+        Run a search query with multiple fields
+
+        :param query: The main search query.
+        :param fields:  List of search fields
+        :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
+        found = len(search_result.results_list)
+        while search_result.hits > found:
+            search_result = self._search_fields(query=query, fields=fields, start_index=found, page_size=page_size)
+            for e in search_result.results_list:
+                yield e
+            found = found + len(search_result.results_list)
+
+    def _search_fields(self, query: str = "%", fields: list[Field]=None, start_index: int = 0, page_size: int = 25):
+
+        start_from = str(start_index)
+        headers = {'Content-Type': 'application/x-www-form-urlencoded', HEADER_TOKEN: self.token}
+
+        if fields is None:
+            fields = []
+
+        field_list = []
+        sort_list = []
+        metadata_elements = []
+        for field in fields:
+            metadata_elements.append(field.name)
+            if field.value is None or field.value == "":
+                field_list.append('{' f' "name": "{field.name}", "values": [] ' + '}')
+            elif field.operator == "NOT":
+                field_list.append('{' f' "name": "{field.name}", "values": ["{field.value}"], "operator": "NOT" ' + '}')
+            else:
+                field_list.append('{' f' "name": "{field.name}", "values": ["{field.value}"] ' + '}')
+
+            if field.sort_order is not None:
+                sort_list.append(f'{{"sortFields": ["{field.name}"], "sortOrder": "{field.sort_order.name}"}}')
+
+
+        filter_terms = ','.join(field_list)
+
+        if len(sort_list) == 0:
+            query_term = ('{ "q":  "%s",  "fields":  [ %s ] }' % (query, filter_terms))
+        else:
+            sort_terms = ','.join(sort_list)
+            query_term = ('{ "q":  "%s",  "fields":  [ %s ],  "sort": [ %s ]}' % (query, filter_terms, sort_terms))
+
+        if len(metadata_elements) == 0:
+            metadata_elements.append("xip.title")
+
+
+        payload = {'start': start_from, 'max': str(page_size), 'metadata': list(metadata_elements), 'q': query_term}
+        logger.debug(payload)
+        results = self.session.post(f'{self.protocol}://{self.server}/api/content/search', data=payload,
+                                    headers=headers)
+        results_list = []
+        if results.status_code == requests.codes.ok:
+            json_doc = results.json()
+            metadata = json_doc['value']['metadata']
+            refs = list(json_doc['value']['objectIds'])
+            refs = list(map(lambda x: content_api_identifier_to_type(x), refs))
+            hits = int(json_doc['value']['totalHits'])
+
+            for m_row, r_row in zip(metadata, refs):
+                results_map = {'xip.reference': r_row[1]}
+                for li in m_row:
+                    results_map[li['name']] = li['value']
+                results_list.append(results_map)
+            next_start = start_index + page_size
+
+            if self.callback is not None:
+                value = str(f'{len(results_list) + start_index}:{hits}')
+                self.callback(value)
+
+            search_results = self.SearchResult(metadata, refs, hits, results_list, next_start)
+            return search_results
+        elif results.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            return self._search_predicates(query, predicates, start_index, page_size)
+        else:
+            logger.error(f"search failed with error code: {results.status_code}")
+            raise RuntimeError(results.status_code, f"search_index_filter failed")
+
     def search_index_filter_list(self, query: str = "%", page_size: int = 25, filter_values: dict = None,
                                  sort_values: dict = None) -> Generator:
         """

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/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.0.dist-info → pyPreservica-2.9.2.dist-info}/METADATA

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

{pyPreservica-2.9.0.dist-info → pyPreservica-2.9.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
-pyPreservica/__init__.py,sha256=N77d66uaSB90vUK9yTjkdd4yEEFtw_rCUWRXEkNiicE,1159
+pyPreservica/__init__.py,sha256=hzcuWdS8XXKexRdqvojfv-pqrW_vS9bF5Hh3Th3HkcY,1177
 pyPreservica/adminAPI.py,sha256=511bc5KtrCAXbDyBk39dmDnxUVDaOu6xaiyu0jYhxa4,37781
 pyPreservica/authorityAPI.py,sha256=Eule8g6LXr8c8SFcJgpRah4lH1FgevUItO5HhHDEaZE,9172
-pyPreservica/common.py,sha256=yZNMlq8aOOLSbFS2DDHYBUWyN5ojDjYUYmcePVbUd44,37636
-pyPreservica/contentAPI.py,sha256=F3VwaybSUel0OfhWOckqfM77AVQCD1erHbu-Xrv4cd0,17388
-pyPreservica/entityAPI.py,sha256=IqfFfmkEnttJEFuYy7aUAhXbaBL86BioMExcgtg31NE,118993
-pyPreservica/mdformsAPI.py,sha256=7hPRITkoSAfOKcfS3u-KJl0Gd9tWUt4nEnX6cXq4xHs,13614
+pyPreservica/common.py,sha256=qVmH5xazlxX02pZaYAX1GT-k0fDuzF8JmEIrYBGiTtw,37648
+pyPreservica/contentAPI.py,sha256=6L7z5KZZDuBBLTm9GQ9RLOhugAawPnuQIgv1NZf0vIU,22060
+pyPreservica/entityAPI.py,sha256=BxrJ-irL0-ohZGVd5uduvFgDgMvrB3Xf2pzTaZ00-Cg,118999
+pyPreservica/mdformsAPI.py,sha256=8atJKNi9mGoQR9DSaEJSIdVBEwBstAuktSPUiJczU3w,19128
 pyPreservica/monitorAPI.py,sha256=HD-PUPdSI9wGAa07e2_2_-FLINH8PoWUwpFogz7F-j4,6269
 pyPreservica/opex.py,sha256=ccra1S4ojUXS3PlbU8WfxajOkJrwG4OykBnNrYP_jus,4875
 pyPreservica/parAPI.py,sha256=bgaQvYfWNnzdD7ibKMV3ZV85pNkEdSoLsgVigoiFFfw,10771
@@ -12,8 +12,8 @@ pyPreservica/retentionAPI.py,sha256=31yKHbatxj9kt5vbqyTeg98nrMotd2iL4jsiNhcOLg4,
 pyPreservica/uploadAPI.py,sha256=3XV3_i7mwp0IPcnx1sW4U01rkphtAzq5Se3G_l28wIM,96469
 pyPreservica/webHooksAPI.py,sha256=_K3KUOsmwYf8qMa-mD47sAmNUW7Pzb9oKVpS0VoSbC0,6827
 pyPreservica/workflowAPI.py,sha256=wDDR5_CsJ3dhX79E5mJaziAtgYb830J0ZpNJppzgvqk,17493
-pyPreservica-2.9.0.dist-info/LICENSE.txt,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-pyPreservica-2.9.0.dist-info/METADATA,sha256=rQhmYZwL59NC8pB56qn6zHNSWURXb60FarovTMgLY1g,2779
-pyPreservica-2.9.0.dist-info/WHEEL,sha256=YiKiUUeZQGmGJoR_0N1Y933DOBowq4AIvDe2-UIy8E4,91
-pyPreservica-2.9.0.dist-info/top_level.txt,sha256=iIBh6NAznYQHOV8mv_y_kGKSDITek9rANyFDwJsbU-c,13
-pyPreservica-2.9.0.dist-info/RECORD,,
+pyPreservica-2.9.2.dist-info/LICENSE.txt,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+pyPreservica-2.9.2.dist-info/METADATA,sha256=pwbevSahu7N-Au96h32Qk_U-8Oyf2qNo66mZLh0dmlM,2779
+pyPreservica-2.9.2.dist-info/WHEEL,sha256=YiKiUUeZQGmGJoR_0N1Y933DOBowq4AIvDe2-UIy8E4,91
+pyPreservica-2.9.2.dist-info/top_level.txt,sha256=iIBh6NAznYQHOV8mv_y_kGKSDITek9rANyFDwJsbU-c,13
+pyPreservica-2.9.2.dist-info/RECORD,,