pyPreservica 2.8.2__py3-none-any.whl → 2.9.1__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.8.2"
+__version__ = "2.9.1"
 
 __license__ = "Apache License Version 2.0"

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,93 @@ 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
+        """
+        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

@@ -572,6 +572,76 @@ class EntityAPI(AuthenticatedAPI):
             logger.error(exception)
             raise exception
 
+    def update_identifiers(self, entity: Entity, identifier_type: str = None, identifier_value: str = None):
+        """
+             Update external identifiers based on Entity and Type
+
+             Returns the internal identifier DB Key
+
+             :param entity: The entity to delete identifiers from
+             :param identifier_type: The type of the identifier to delete.
+             :param identifier_value: The value of the identifier to delete.
+          """
+
+        if (self.major_version < 7) and (self.minor_version < 1):
+            raise RuntimeError("update_identifiers API call is not available when connected to a v6.0 System")
+
+        headers = {HEADER_TOKEN: self.token}
+        response = self.session.get(
+            f'{self.protocol}://{self.server}/api/entity/{entity.path}/{entity.reference}/identifiers',
+            headers=headers)
+
+        if response.status_code == requests.codes.ok:
+            xml_response = str(response.content.decode('utf-8'))
+            entity_response = xml.etree.ElementTree.fromstring(xml_response)
+            identifier_list = entity_response.findall(f'.//{{{self.xip_ns}}}Identifier')
+            for identifier_element in identifier_list:
+                _ref = _type = _value = _aipid = None
+                for identifier in identifier_element:
+                    if identifier.tag.endswith("Entity"):
+                        _ref = identifier.text
+                    if identifier.tag.endswith("Type") and identifier_type is not None:
+                        _type = identifier.text
+                    if identifier.tag.endswith("Value") and identifier_value is not None:
+                        _value = identifier.text
+                    if identifier.tag.endswith("ApiId"):
+                        _aipid = identifier.text
+                if _ref == entity.reference and _type == identifier_type:
+
+                    headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/xml;charset=UTF-8'}
+
+                    xml_object = xml.etree.ElementTree.Element('Identifier', {"xmlns": self.xip_ns})
+                    xml.etree.ElementTree.SubElement(xml_object, "Type").text = identifier_type
+                    xml.etree.ElementTree.SubElement(xml_object, "Value").text = identifier_value
+                    xml.etree.ElementTree.SubElement(xml_object, "Entity").text = entity.reference
+                    xml_request = xml.etree.ElementTree.tostring(xml_object, encoding='utf-8')
+
+                    put_response = self.session.put(
+                        f'{self.protocol}://{self.server}/api/entity/{entity.path}/{entity.reference}/identifiers/{_aipid}',
+                        headers=headers, data=xml_request)
+                    if put_response.status_code == requests.codes.ok:
+                        xml_string = str(put_response.content.decode("utf-8"))
+                        identifier_response = xml.etree.ElementTree.fromstring(xml_string)
+                        aip_id = identifier_response.find(f'.//{{{self.xip_ns}}}ApiId')
+                        if hasattr(aip_id, 'text'):
+                            return aip_id.text
+                        else:
+                            return None
+                    if put_response.status_code == requests.codes.unauthorized:
+                        self.token = self.__token__()
+                        return self.update_identifiers(entity, identifier_type, identifier_value)
+                    if put_response.status_code == requests.codes.no_content:
+                        pass
+                    else:
+                        return None
+            return entity
+        elif response.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            return self.update_identifiers(entity, identifier_type, identifier_value)
+        else:
+            logger.error(response)
+            raise RuntimeError(response.status_code, "update_identifiers failed")
+
     def delete_relationships(self, entity: Entity, relationship_type: str = None):
         """
         Delete a relationship between two entities by its internal id
@@ -2275,6 +2345,8 @@ class EntityAPI(AuthenticatedAPI):
                     entity_response = xml.etree.ElementTree.fromstring(req.content.decode("utf-8"))
                     status = entity_response.find(".//{http://status.preservica.com}Status")
                     if hasattr(status, 'text'):
+                        if status.text == "COMPLETED":
+                            return entity.reference
                         if status.text == "PENDING":
                             headers = {HEADER_TOKEN: self.manager_token(manager_username, manager_password),
                                        'Content-Type': 'application/xml;charset=UTF-8'}

pyPreservica/mdformsAPI.py

@@ -96,6 +96,8 @@ def _object_from_json_(json_doc: dict) -> Group:
                 gf.editable = bool(field['editable'])
             if 'values' in field:
                 for v in field['values']:
+                    if gf.values is None:
+                        gf.values = []
                     gf.values.append(str(v))
             if 'defaultValue' in field:
                 gf.default = str(field['defaultValue'])

pyPreservica/retentionAPI.py

@@ -9,7 +9,6 @@ licence:    Apache License 2.0
 
 """
 
-
 import xml.etree.ElementTree
 from typing import Set, Callable
 
@@ -60,7 +59,6 @@ class RetentionAPI(AuthenticatedAPI):
 
     def __init__(self, username=None, password=None, tenant=None, server=None, use_shared_secret=False,
                  two_fa_secret_key: str = None, protocol: str = "https", request_hook: Callable = None):
-
         super().__init__(username, password, tenant, server, use_shared_secret, two_fa_secret_key,
                          protocol, request_hook)
         if self.major_version < 7 and self.minor_version < 2:
@@ -78,7 +76,8 @@ class RetentionAPI(AuthenticatedAPI):
 
          """
         headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/xml;charset=UTF-8'}
-        request = self.session.get(f'{self.protocol}://{self.server}/api/entity/retention-policies/{reference}', headers=headers)
+        request = self.session.get(f'{self.protocol}://{self.server}/api/entity/retention-policies/{reference}',
+                                   headers=headers)
         if request.status_code == requests.codes.ok:
             xml_response = str(request.content.decode('utf-8'))
             logger.debug(xml_response)
@@ -92,14 +91,22 @@ class RetentionAPI(AuthenticatedAPI):
             security_tag = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}SecurityTag').text
             rp.security_tag = security_tag
             start_date_field = entity_response.find(
-                f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}StartDateField').text
-            rp.start_date_field = start_date_field
-            period = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}Period').text
-            rp.period = period
-            period_unit = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}PeriodUnit').text
-            rp.period_unit = period_unit
-            expiry_action = entity_response.find(
-                f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}ExpiryAction')
+                f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}StartDateField')
+            if start_date_field is not None:
+                rp.start_date_field = start_date_field.text
+            else:
+                start_date_field = None
+            period = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}Period')
+            if period is not None:
+                rp.period = period.text
+            else:
+                rp.period = None
+            period_unit = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}PeriodUnit')
+            if period_unit is not None:
+                rp.period_unit = period_unit.text
+            else:
+                rp.period_unit = None
+            expiry_action = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}ExpiryAction')
             if expiry_action is not None:
                 rp.expiry_action = expiry_action.text
             else:
@@ -134,8 +141,9 @@ class RetentionAPI(AuthenticatedAPI):
         """
         headers = {HEADER_TOKEN: self.token, 'Content-Type': 'text/plain;charset=UTF-8'}
         data = str(status)
-        request = self.session.put(f'{self.protocol}://{self.server}/api/entity/retention-policies/{reference}/assignable',
-                                   headers=headers, data=data)
+        request = self.session.put(
+            f'{self.protocol}://{self.server}/api/entity/retention-policies/{reference}/assignable',
+            headers=headers, data=data)
         if request.status_code == requests.codes.ok:
             pass
         elif request.status_code == requests.codes.unauthorized:
@@ -230,7 +238,8 @@ class RetentionAPI(AuthenticatedAPI):
 
         xml_request = xml.etree.ElementTree.tostring(retention_policy, encoding='utf-8')
 
-        request = self.session.put(f'{self.protocol}://{self.server}/api/entity/retention-policies/{reference}', data=xml_request,
+        request = self.session.put(f'{self.protocol}://{self.server}/api/entity/retention-policies/{reference}',
+                                   data=xml_request,
                                    headers=headers)
         if request.status_code == requests.codes.ok:
             return self.policy(reference)
@@ -374,7 +383,8 @@ class RetentionAPI(AuthenticatedAPI):
          """
         headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/xml;charset=UTF-8'}
         data = {'start': str(0), 'max': "250"}
-        request = self.session.get(f'{self.protocol}://{self.server}/api/entity/retention-policies', data=data, headers=headers)
+        request = self.session.get(f'{self.protocol}://{self.server}/api/entity/retention-policies', data=data,
+                                   headers=headers)
         if request.status_code == requests.codes.ok:
             xml_response = str(request.content.decode('utf-8'))
             logger.debug(xml_response)
@@ -390,10 +400,10 @@ class RetentionAPI(AuthenticatedAPI):
         else:
             raise RuntimeError(request.status_code, "policies failed")
 
-    def policies(self) -> Set[RetentionPolicy]:
+    def policies(self, maximum: int = 250, next_page: str = None) -> PagedSet:
         """
         Return a list of all retention policies
-        Only returns the first 250 policies in the system
+        Returns a maxmium of 250 policies by default
 
 
         :return: Set of retention policies
@@ -401,22 +411,33 @@ class RetentionAPI(AuthenticatedAPI):
 
         """
         headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/xml;charset=UTF-8'}
-        data = {'start': str(0), 'max': "250"}
-        request = self.session.get(f'{self.protocol}://{self.server}/api/entity/retention-policies', data=data, headers=headers)
+
+        if next_page is None:
+            params = {'start': '0', 'max': str(maximum)}
+            request = self.session.get(f'{self.protocol}://{self.server}/api/entity/retention-policies', params=params,
+                                       headers=headers)
+        else:
+            request = self.session.get(next_page, headers=headers)
+
         if request.status_code == requests.codes.ok:
             xml_response = str(request.content.decode('utf-8'))
             entity_response = xml.etree.ElementTree.fromstring(xml_response)
             logger.debug(xml_response)
             result = set()
+            next_url = entity_response.find(f'.//{{{self.entity_ns}}}Paging/{{{self.entity_ns}}}Next')
             total_results = int(entity_response.find(
                 f'.//{{{self.entity_ns}}}TotalResults').text)
-            if total_results > 250:
-                logger.error("Not all retention policies have been returned.")
             for assignment in entity_response.findall(f'.//{{{self.entity_ns}}}RetentionPolicy'):
                 ref = assignment.attrib['ref']
                 name = assignment.attrib['name']
                 result.add(self.policy(reference=ref))
-            return result
+            has_more = True
+            url = None
+            if next_url is None:
+                has_more = False
+            else:
+                url = next_url.text
+            return PagedSet(result, has_more, total_results, url)
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.policies()
@@ -455,7 +476,11 @@ class RetentionAPI(AuthenticatedAPI):
             api_id = entity_response.find(f'.//{{{self.rm_ns}}}ApiId').text
             policy_ref = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy').text
             entity_ref = entity_response.find(f'.//{{{self.rm_ns}}}Entity').text
-            start_date = entity_response.find(f'.//{{{self.rm_ns}}}StartDate').text
+            start_date = entity_response.find(f'.//{{{self.rm_ns}}}StartDate')
+            if start_date is not None:
+                start_date = start_date.text
+            else:
+                start_date = None
             assert entity_ref == entity.reference
             assert policy_ref == policy.reference
             return RetentionAssignment(entity_ref, policy_ref, api_id, start_date)
@@ -516,7 +541,11 @@ class RetentionAPI(AuthenticatedAPI):
                 entity_ref = assignment.find(f'.//{{{self.rm_ns}}}Entity').text
                 assert entity_ref == entity.reference
                 policy = assignment.find(f'.//{{{self.rm_ns}}}RetentionPolicy').text
-                start_date = assignment.find(f'.//{{{self.rm_ns}}}StartDate').text
+                start_date = assignment.find(f'.//{{{self.rm_ns}}}StartDate')
+                if start_date is not None:
+                    start_date = start_date.text
+                else:
+                    start_date = None
                 expired = bool(assignment.find(f'.//{{{self.rm_ns}}}Expired').text == 'true')
                 api_id = assignment.find(f'.//{{{self.rm_ns}}}ApiId').text
                 ra = RetentionAssignment(entity_ref, policy, api_id, start_date, expired)

pyPreservica/uploadAPI.py

@@ -1421,7 +1421,7 @@ class UploadAPI(AuthenticatedAPI):
         try:
             auth = tweepy.AppAuthHandler(twitter_consumer_key, twitter_secret_key)
             api = tweepy.API(auth, wait_on_rate_limit=True)
-        except TweepError:
+        except RuntimeError:
             logger.error("No valid Twitter API keys. Could not authenticate")
             raise RuntimeError("No valid Twitter API keys. Could not authenticate")
         if api is not None:
@@ -1734,8 +1734,8 @@ class UploadAPI(AuthenticatedAPI):
                     self.upload_zip_package(path_to_zip_package=package, callback=progress_display,
                                             delete_after_upload=delete_after_upload)
                 else:
-                    self.upload_zip_package_to_S3(path_to_zip_package=package, bucket_name=bucket_name,
-                                                  callback=progress_display,
+                    self.upload_zip_to_Source(path_to_zip_package=package, container_name=bucket_name,
+                                                  show_progress= bool(progress_display is not None),
                                                   delete_after_upload=delete_after_upload)
 
                 logger.info(f"Uploaded " + "{:.1f}".format(bytes_ingested / (1024 * 1024)) + " MB")

pyPreservica/webHooksAPI.py

@@ -74,6 +74,7 @@ class TriggerType(Enum):
     MOVED = "MOVED"
     INDEXED = "FULL_TEXT_INDEXED"
     SECURITY_CHANGED = "CHANGED_SECURITY_DESCRIPTOR"
+    INGEST_FAILED = "INGEST_FAILED"
 
 
 class WebHooksAPI(AuthenticatedAPI):

{pyPreservica-2.8.2.dist-info → pyPreservica-2.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyPreservica
-Version: 2.8.2
+Version: 2.9.1
 Summary: Python library for the Preservica API
 Home-page: https://pypreservica.readthedocs.io/
 Author: James Carr
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: System :: Archiving
@@ -34,12 +35,9 @@ Requires-Dist: pyotp
 # pyPreservica
 
 
-<!---
-[![Downloads](https://pepy.tech/badge/pyPreservica/month)](https://pepy.tech/project/pyPreservica/month)
---->
-
 [![Supported Versions](https://img.shields.io/pypi/pyversions/pyPreservica.svg)](https://pypi.org/project/pyPreservica)
 [![CodeQL](https://github.com/carj/pyPreservica/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/carj/pyPreservica/actions/workflows/codeql-analysis.yml)
+![PyPI Downloads](https://static.pepy.tech/badge/pypreservica)
 
 Python language binding for the Preservica API
 

pyPreservica-2.9.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+pyPreservica/__init__.py,sha256=AORR-EHoHqoqhU19-cJ2pNZ33l01fxM5-_zjOrgcdNo,1177
+pyPreservica/adminAPI.py,sha256=511bc5KtrCAXbDyBk39dmDnxUVDaOu6xaiyu0jYhxa4,37781
+pyPreservica/authorityAPI.py,sha256=Eule8g6LXr8c8SFcJgpRah4lH1FgevUItO5HhHDEaZE,9172
+pyPreservica/common.py,sha256=yZNMlq8aOOLSbFS2DDHYBUWyN5ojDjYUYmcePVbUd44,37636
+pyPreservica/contentAPI.py,sha256=WUl03HkywOF3D-RaTOS50jOmcR8X8YWmYCnAIJMfvBc,21886
+pyPreservica/entityAPI.py,sha256=IqfFfmkEnttJEFuYy7aUAhXbaBL86BioMExcgtg31NE,118993
+pyPreservica/mdformsAPI.py,sha256=7hPRITkoSAfOKcfS3u-KJl0Gd9tWUt4nEnX6cXq4xHs,13614
+pyPreservica/monitorAPI.py,sha256=HD-PUPdSI9wGAa07e2_2_-FLINH8PoWUwpFogz7F-j4,6269
+pyPreservica/opex.py,sha256=ccra1S4ojUXS3PlbU8WfxajOkJrwG4OykBnNrYP_jus,4875
+pyPreservica/parAPI.py,sha256=bgaQvYfWNnzdD7ibKMV3ZV85pNkEdSoLsgVigoiFFfw,10771
+pyPreservica/retentionAPI.py,sha256=31yKHbatxj9kt5vbqyTeg98nrMotd2iL4jsiNhcOLg4,24770
+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.1.dist-info/LICENSE.txt,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+pyPreservica-2.9.1.dist-info/METADATA,sha256=XpwI82CtlJsPW_xAW6zKMNhM9wgpwwv3aGMf2IhEew8,2779
+pyPreservica-2.9.1.dist-info/WHEEL,sha256=YiKiUUeZQGmGJoR_0N1Y933DOBowq4AIvDe2-UIy8E4,91
+pyPreservica-2.9.1.dist-info/top_level.txt,sha256=iIBh6NAznYQHOV8mv_y_kGKSDITek9rANyFDwJsbU-c,13
+pyPreservica-2.9.1.dist-info/RECORD,,

pyPreservica-2.8.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-pyPreservica/__init__.py,sha256=6UJhvPCjdEjhKuNhURC9VU8lW_OIaHSQLv2SIXZmIKE,1159
-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=f-RlCEtUq0KDB62LuSPy0Kb-lT6Hp2gPOmSiTeomqkM,114853
-pyPreservica/mdformsAPI.py,sha256=bjfs9ZVvlIovrhKztFsY_S5V5dwppO9tQVSxuGHLWVc,13531
-pyPreservica/monitorAPI.py,sha256=HD-PUPdSI9wGAa07e2_2_-FLINH8PoWUwpFogz7F-j4,6269
-pyPreservica/opex.py,sha256=ccra1S4ojUXS3PlbU8WfxajOkJrwG4OykBnNrYP_jus,4875
-pyPreservica/parAPI.py,sha256=bgaQvYfWNnzdD7ibKMV3ZV85pNkEdSoLsgVigoiFFfw,10771
-pyPreservica/retentionAPI.py,sha256=EmQvmUW_I_sPslCiTZDZ2uqloesjfxmmc5AQImWX2cs,23695
-pyPreservica/uploadAPI.py,sha256=Nl6Z4h1cW9TmZyrhVLPff3jSAnzCdkfn0xDJ9Q_ZhdI,96444
-pyPreservica/webHooksAPI.py,sha256=0wP-59mep8gtlIZ9P5vV68-HnNdTuuo2kzGcDWj0bNg,6790
-pyPreservica/workflowAPI.py,sha256=wDDR5_CsJ3dhX79E5mJaziAtgYb830J0ZpNJppzgvqk,17493
-pyPreservica-2.8.2.dist-info/LICENSE.txt,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-pyPreservica-2.8.2.dist-info/METADATA,sha256=l0Uj8NmaGYxf_Fy7B8loUMCMF5JiNlDlnJ9Ai4TEkxI,2784
-pyPreservica-2.8.2.dist-info/WHEEL,sha256=YiKiUUeZQGmGJoR_0N1Y933DOBowq4AIvDe2-UIy8E4,91
-pyPreservica-2.8.2.dist-info/top_level.txt,sha256=iIBh6NAznYQHOV8mv_y_kGKSDITek9rANyFDwJsbU-c,13
-pyPreservica-2.8.2.dist-info/RECORD,,