pyPreservica 3.2.2__tar.gz → 3.2.4__tar.gz

{pypreservica-3.2.2 → pypreservica-3.2.4}/PKG-INFO

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

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/__init__.py

@@ -35,6 +35,6 @@ from .settingsAPI import SettingsAPI
 __author__ = "James Carr (drjamescarr@gmail.com)"
 
 # Version of the pyPreservica package
-__version__ = "3.2.2"
+__version__ = "3.2.4"
 
 __license__ = "Apache License Version 2.0"

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/adminAPI.py

@@ -10,7 +10,7 @@ licence:    Apache License 2.0
 """
 import csv
 import xml.etree.ElementTree
-from typing import List, Any
+from typing import List, Any, Union
 
 from pyPreservica.common import *
 
@@ -36,7 +36,7 @@ class AdminAPI(AuthenticatedAPI):
         request = self.session.delete(f'{self.protocol}://{self.server}/api/admin/security/roles/{role_name}',
                                       headers=headers)
         if request.status_code == requests.codes.no_content:
-            return
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.delete_system_role(role_name)
@@ -61,7 +61,7 @@ class AdminAPI(AuthenticatedAPI):
         request = self.session.delete(f'{self.protocol}://{self.server}/api/admin/security/tags/{tag_name}',
                                       headers=headers)
         if request.status_code == requests.codes.no_content:
-            return
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.delete_security_tag(tag_name)
@@ -211,7 +211,7 @@ class AdminAPI(AuthenticatedAPI):
         headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/xml;charset=UTF-8'}
         request = self.session.delete(f'{self.protocol}://{self.server}/api/admin/users/{username}', headers=headers)
         if request.status_code == requests.codes.no_content:
-            return
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.delete_user(username)
@@ -463,7 +463,7 @@ class AdminAPI(AuthenticatedAPI):
                                     params=params,
                                     data=xml_data)
         if request.status_code == requests.codes.created:
-            return
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.add_xml_schema(name, description, originalName, xml_data)
@@ -513,7 +513,7 @@ class AdminAPI(AuthenticatedAPI):
                                     params=params,
                                     data=xml_data)
         if request.status_code == requests.codes.created:
-            return
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.add_xml_document(name, xml_data, document_type)
@@ -543,13 +543,14 @@ class AdminAPI(AuthenticatedAPI):
                     f"{self.protocol}://{self.server}/api/admin/documents/{document['ApiId']}",
                     headers=headers)
                 if request.status_code == requests.codes.no_content:
-                    return
+                    return None
                 elif request.status_code == requests.codes.unauthorized:
                     self.token = self.__token__()
                     return self.delete_xml_document(uri)
                 else:
                     logger.error(request.content.decode('utf-8'))
                     raise RuntimeError(request.status_code, "delete_xml_document failed")
+        return None
 
     def delete_xml_schema(self, uri: str):
         """
@@ -572,15 +573,16 @@ class AdminAPI(AuthenticatedAPI):
                 request = self.session.delete(f"{self.protocol}://{self.server}/api/admin/schemas/{schema['ApiId']}",
                                               headers=headers)
                 if request.status_code == requests.codes.no_content:
-                    return
+                    return None
                 elif request.status_code == requests.codes.unauthorized:
                     self.token = self.__token__()
                     return self.delete_xml_schema(uri)
                 else:
                     logger.error(request.content.decode('utf-8'))
                     raise RuntimeError(request.status_code, "delete_xml_schema failed")
+        return None
 
-    def xml_schema(self, uri: str) -> str:
+    def xml_schema(self, uri: str) -> Union[str, None]:
         """
          Fetch the metadata schema XSD document as a string by its URI
 
@@ -607,8 +609,9 @@ class AdminAPI(AuthenticatedAPI):
                 else:
                     logger.error(request.content.decode('utf-8'))
                     raise RuntimeError(request.status_code, "xml_schema failed")
+        return None
 
-    def xml_document(self, uri: str) -> str:
+    def xml_document(self, uri: str) -> Union[str, None]:
         """
         fetch the metadata XML document as a string by its URI
 
@@ -634,6 +637,7 @@ class AdminAPI(AuthenticatedAPI):
                 else:
                     logger.error(request.content.decode('utf-8'))
                     raise RuntimeError(request.status_code, "xml_document failed")
+        return None
 
     def xml_documents(self) -> List:
         """
@@ -754,7 +758,7 @@ class AdminAPI(AuthenticatedAPI):
             logger.error(request.content.decode('utf-8'))
             raise RuntimeError(request.status_code, "xml_transforms failed")
 
-    def xml_transform(self, input_uri: str, output_uri: str) -> str:
+    def xml_transform(self, input_uri: str, output_uri: str) -> Union[str, None]:
         """
         fetch the XML transform as a string by its URIs
 
@@ -782,6 +786,7 @@ class AdminAPI(AuthenticatedAPI):
                 else:
                     logger.error(request.content.decode('utf-8'))
                     raise RuntimeError(request.status_code, "xml_transform failed")
+        return None
 
     def delete_xml_transform(self, input_uri: str, output_uri: str):
         """
@@ -808,13 +813,14 @@ class AdminAPI(AuthenticatedAPI):
                     f"{self.protocol}://{self.server}/api/admin/transforms/{transform['ApiId']}",
                     headers=headers)
                 if request.status_code == requests.codes.no_content:
-                    return
+                    return None
                 elif request.status_code == requests.codes.unauthorized:
                     self.token = self.__token__()
                     return self.delete_xml_transform(input_uri, output_uri)
                 else:
                     logger.error(request.content.decode('utf-8'))
                     raise RuntimeError(request.status_code, "delete_xml_transform failed")
+        return None
 
     def add_xml_transform(self, name: str, input_uri: str, output_uri: str, purpose: str, originalName: str,
                           xml_data: Any):
@@ -860,7 +866,7 @@ class AdminAPI(AuthenticatedAPI):
                                     params=params,
                                     data=xml_data)
         if request.status_code == requests.codes.created:
-            return
+            return None
 
         if request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/authorityAPI.py

@@ -54,7 +54,7 @@ class AuthorityAPI(AuthenticatedAPI):
             self.token = self.__token__()
             return self.delete_record(reference)
         if response.status_code == requests.codes.no_content:
-            return
+            return None
         else:
             exception = HTTPException("", response.status_code, response.url, "delete_record",
                                       response.content.decode('utf-8'))

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/common.py

@@ -673,19 +673,24 @@ class AuthenticatedAPI:
             logger.error(f"The AdminAPI requires the user to have ROLE_SDB_MANAGER_USER")
             raise RuntimeError(f"The API requires the user to have at least the ROLE_SDB_MANAGER_USER")
 
-    def _find_user_roles_(self) -> list:
+    def _find_user_roles_(self) -> list[str]:
         """
             Get a list of roles for the user
             :return list of roles:
         """
-        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/xml;charset=UTF-8'}
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json'}
         request = self.session.get(f"{self.protocol}://{self.server}/api/user/details", headers=headers)
+        logger.debug(request.headers)
         if request.status_code == requests.codes.ok:
-            roles = json.loads(str(request.content.decode('utf-8')))['roles']
+            json_document = str(request.content.decode('utf-8'))
+            logger.debug(json_document)
+            roles: list[str] = json.loads(json_document)['roles']
             return roles
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self._find_user_roles_()
+        return []
+
 
     def security_tags_base(self, with_permissions: bool = False) -> dict:
         """
@@ -817,8 +822,6 @@ class AuthenticatedAPI:
             self.minor_version = int(version_numbers[1])
             self.patch_version = int(version_numbers[2])
 
-            if self.server == "preview.preservica.com":
-                self.minor_version = 1
 
             return version
         elif request.status_code == requests.codes.unauthorized:
@@ -847,7 +850,7 @@ class AuthenticatedAPI:
         with open('credentials.properties', 'wt', encoding="utf-8") as configfile:
             config.write(configfile)
 
-    def manager_token(self, username: str, password: str):
+    def manager_token(self, username: str, password: str) -> str:
         data = {'username': username, 'password': password, 'tenant': self.tenant}
         response = self.session.post(f'{self.protocol}://{self.server}/api/accesstoken/login', data=data)
         if response.status_code == requests.codes.ok:
@@ -859,7 +862,7 @@ class AuthenticatedAPI:
             logger.error(str(response.content))
             RuntimeError(response.status_code, "Could not generate valid manager approval token")
 
-    def __token__(self):
+    def __token__(self) -> str:
         """
             Generate am API token to use to authenticate calls
             :return: API Token

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/entityAPI.py

@@ -82,28 +82,28 @@ class EntityAPI(AuthenticatedAPI):
 
     def bitstream_bytes(self, bitstream: Bitstream, chunk_size: int = CHUNK_SIZE) -> Union[BytesIO, None]:
         """
-                Download a file represented as a Bitstream to a byteIO array
+        Download a file represented as a Bitstream to a byteIO array
 
-                Returns the byteIO
-                Returns None if the file does not contain the correct number of bytes (default 2k)
+        Returns the byteIO
+        Returns None if the file does not contain the correct number of bytes (default 2k)
 
-                :param chunk_size: The buffer copy chunk size in bytes default
-                :param bitstream: A Bitstream object
-                :type bitstream: Bitstream
+        :param chunk_size: The buffer copy chunk size in bytes default
+        :param bitstream: A Bitstream object
+        :type bitstream: Bitstream
 
-                :return: The file in bytes
-                :rtype: byteIO
+        :return: The file in bytes
+        :rtype: byteIO
         """
         if not isinstance(bitstream, Bitstream):
             logger.error("bitstream_content argument is not a Bitstream object")
             raise RuntimeError("bitstream_bytes argument is not a Bitstream object")
-        with self.session.get(bitstream.content_url, headers={HEADER_TOKEN: self.token}, stream=True) as request:
-            if request.status_code == requests.codes.unauthorized:
+        with self.session.get(bitstream.content_url, headers={HEADER_TOKEN: self.token}, stream=True) as response:
+            if response.status_code == requests.codes.unauthorized:
                 self.token = self.__token__()
                 return self.bitstream_bytes(bitstream)
-            elif request.status_code == requests.codes.ok:
+            elif response.status_code == requests.codes.ok:
                 file_bytes = BytesIO()
-                for chunk in request.iter_content(chunk_size=chunk_size):
+                for chunk in response.iter_content(chunk_size=chunk_size):
                     file_bytes.write(chunk)
                 file_bytes.seek(0)
                 if file_bytes.getbuffer().nbytes == bitstream.length:
@@ -113,8 +113,8 @@ class EntityAPI(AuthenticatedAPI):
                     logger.error("Downloaded file size did not match the Preservica held value")
                     return None
             else:
-                exception = HTTPException(bitstream.filename, request.status_code, request.url, "bitstream_content",
-                                          request.content.decode('utf-8'))
+                exception = HTTPException(bitstream.filename, response.status_code, response.url, "bitstream_content",
+                                          response.content.decode('utf-8'))
                 logger.error(exception)
                 raise exception
 
@@ -131,23 +131,25 @@ class EntityAPI(AuthenticatedAPI):
         url: str = f'{self.protocol}://{self.server}/api/entity/content-objects/{bitstream.co_ref}/generations/{bitstream.gen_index}/bitstreams/{bitstream.bs_index}/storage-locations'
 
         with self.session.get(url, headers={HEADER_TOKEN: self.token}, stream=True) as request:
-            if request.status_code == requests.codes.unauthorized:
-                self.token = self.__token__()
-                return self.bitstream_location(bitstream)
-            elif request.status_code == requests.codes.ok:
+            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)
                 locations = entity_response.find(f'.//{{{self.entity_ns}}}StorageLocation')
                 for adapter in locations:
                     storage_locations.append(adapter.attrib['name'])
+                return storage_locations
+
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.bitstream_location(bitstream)
             else:
                 exception = HTTPException(bitstream.filename, request.status_code, request.url, "bitstream_location",
                                           request.content.decode('utf-8'))
                 logger.error(exception)
                 raise exception
 
-        return storage_locations
+
 
     def bitstream_content(self, bitstream: Bitstream, filename: str, chunk_size: int = CHUNK_SIZE) -> Union[int, None]:
         """
@@ -760,7 +762,7 @@ class EntityAPI(AuthenticatedAPI):
         end_point = f"{entity.path}/{entity.reference}/links/{relationship.api_id}"
         request = self.session.delete(f'{self.protocol}://{self.server}/api/entity/{end_point}', headers=headers)
         if request.status_code == requests.codes.no_content:
-            print(relationship)
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.__delete_relationship(relationship)
@@ -779,7 +781,7 @@ class EntityAPI(AuthenticatedAPI):
             :type: page_size: int
 
             :param entity: The Source Entity
-            :type: entity: Entity
+            :type: entity: An Entity type such as Asset, Folder etc
 
             :return: Generator
             :rtype:  Relationship
@@ -847,7 +849,7 @@ class EntityAPI(AuthenticatedAPI):
 
             return PagedSet(results, has_more, int(total_hits.text), url)
         elif request.status_code == requests.codes.unauthorized:
-            self.__relationships__(entity=entity, maximum=maximum, next_page=next_page)
+            return self.__relationships__(entity=entity, maximum=maximum, next_page=next_page)
         else:
             exception = HTTPException(entity.reference, request.status_code, request.url, "relationships",
                                       request.content.decode('utf-8'))
@@ -1042,7 +1044,6 @@ class EntityAPI(AuthenticatedAPI):
         xml_request = xml.etree.ElementTree.tostring(xml_object, encoding='utf-8')
         end_point = f"/{entity.path}/{entity.reference}/metadata"
         logger.debug(xml_request)
-        print(xml_request)
         request = self.session.post(f'{self.protocol}://{self.server}/api/entity{end_point}', data=xml_request,
                                     headers=headers)
         if request.status_code == requests.codes.ok:
@@ -1108,6 +1109,7 @@ class EntityAPI(AuthenticatedAPI):
                 if 'CustomType' in response:
                     content_object.custom_type = response['CustomType']
                 return content_object
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self.save(entity)
@@ -1296,9 +1298,9 @@ class EntityAPI(AuthenticatedAPI):
         for uri, schema_name in entity.metadata.items():
             if schema == schema_name:
                 return self.metadata(uri)
-        return
+        return None
 
-    def metadata_tag_for_entity(self, entity: Entity, schema: str, tag: str, isXpath: bool = False) -> str:
+    def metadata_tag_for_entity(self, entity: Entity, schema: str, tag: str, isXpath: bool = False) -> Union[str, None]:
         """
         Retrieve the first value of the tag from a metadata template given by schema
 
@@ -1313,10 +1315,11 @@ class EntityAPI(AuthenticatedAPI):
         xml_doc = self.metadata_for_entity(entity, schema)
         if xml_doc:
             xml_object = xml.etree.ElementTree.fromstring(xml_doc)
-            if isXpath is False:
+            if not isXpath:
                 return xml_object.find(f'.//{{*}}{tag}').text
             else:
                 return xml_object.find(tag).text
+        return None
 
     def security_tag_sync(self, entity: EntityT, new_tag: str) -> EntityT:
         """
@@ -1413,6 +1416,7 @@ class EntityAPI(AuthenticatedAPI):
             return self.folder(reference)
         if entity_type is EntityType.ASSET:
             return self.asset(reference)
+        return None
 
     def add_physical_asset(self, title: str, description: str, parent: Folder, security_tag: str = "open") -> Asset:
         """
@@ -1460,11 +1464,62 @@ class EntityAPI(AuthenticatedAPI):
             logger.error(exception)
             raise exception
 
-    def merge_folder(self, folder: Folder)-> str:
+    def merge_assets(self, assets: list[Asset], title: str, description: str) -> str:
+        """
+            Create a new Asset with the content from each Asset in supplied list
+            This call will create a new multipart Asset which contains all the content from list of Assets.
+
+            The return value is the progress status of the merge operation.
+        """
+
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Content-Type": "application/xml;charset=UTF-8",
+            "accept": "text/plain;charset=UTF-8",
+        }
+
+        merge_object = xml.etree.ElementTree.Element("MergeAction", {"xmlns": self.entity_ns, "xmlns:xip": self.xip_ns})
+        xml.etree.ElementTree.SubElement(merge_object, "Title").text = str(title)
+        xml.etree.ElementTree.SubElement(merge_object, "Description").text = str(description)
+        for a in assets:
+            xml.etree.ElementTree.SubElement(merge_object, "Entity", {
+                "excludeIdentifiers": "true",
+                "excludeLinks": "true",
+                "excludeMetadata": "true",
+                "ref": a.reference,
+                "type": EntityType.ASSET.value}
+            )
+  #      order_object = xml.etree.ElementTree.SubElement(merge_object, "Order")
+  #      for a in assets:
+  #          xml.etree.ElementTree.SubElement(order_object, "Entity", {
+  #              "ref": a.reference,
+  #              "type": EntityType.CONTENT_OBJECT.value}
+  #          )
+        xml_request = xml.etree.ElementTree.tostring(merge_object, encoding="utf-8")
+        print(xml_request)
+        request = self.session.post(
+            f"{self.protocol}://{self.server}/api/entity/actions/merges", data=xml_request, headers=headers)
+        if request.status_code == requests.codes.accepted:
+            return request.content.decode('utf-8')
+        elif request.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            return self.merge_assets(assets, title, description)
+        else:
+            exception = HTTPException(
+                "",
+                request.status_code,
+                request.url,
+                "merge_assets",
+                request.content.decode("utf-8"),
+            )
+            logger.error(exception)
+            raise exception
+
+    def merge_folder(self, folder: Folder) -> str:
         """
             Create a new Asset with the content from each Asset in the Folder
 
-            This call will create a new multi-part Asset which contains all the content from the Folder.
+            This call will create a new multipart Asset which contains all the content from the Folder.
 
             The new Asset which is created will have the same title, description and parent as the Folder.
 
@@ -1495,7 +1550,6 @@ class EntityAPI(AuthenticatedAPI):
             logger.error(exception)
             raise exception
 
-
     def asset(self, reference: str) -> Asset:
         """
          Retrieve an Asset by its reference
@@ -2118,7 +2172,7 @@ class EntityAPI(AuthenticatedAPI):
             params=params, headers=headers)
 
         if request.status_code == requests.codes.ok:
-            pass
+            return None
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
             return self._event_actions(entity, maximum=maximum)
@@ -2262,6 +2316,7 @@ class EntityAPI(AuthenticatedAPI):
             else:
                 url = next_url.text
             return PagedSet(result_list, has_more, int(total_hits.text), url)
+        return None
 
     def entity_from_event(self, event_id: str) -> Generator:
         self.token = self.__token__()
@@ -2592,3 +2647,4 @@ class EntityAPI(AuthenticatedAPI):
                                   "_delete_entity", request.content.decode('utf-8'))
         logger.error(exception)
         raise exception
+

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/mdformsAPI.py

@@ -451,6 +451,26 @@ class MetadataGroupsAPI(AuthenticatedAPI):
                 raise exception
 
 
+    def delete_form(self, form_id: str):
+        """
+        Delete a form by its ID
+        """
+        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.delete(url, headers=headers) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.delete_form(form_id)
+            elif request.status_code == requests.codes.no_content:
+                return None
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "delete_form",
+                                          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

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/uploadAPI.py

@@ -1633,6 +1633,52 @@ class UploadAPI(AuthenticatedAPI):
             logger.error(exception)
             raise exception
 
+    def clean_upload_bucket(self, bucket_name: str,  older_than_days: int = 90):
+        """
+        Clean up objects in an upload bucket which are older than older_than_days.
+
+        """
+        from azure.storage.blob import ContainerClient
+
+        for location in self.upload_locations():
+            if location['containerName'] == bucket_name:
+
+                if location['type'] != 'AWS':
+                    credentials = self.upload_credentials(location['apiId'])
+                    account_key = credentials['key']
+                    session_token = credentials['sessionToken']
+                    sas_url = f"https://{account_key}.blob.core.windows.net/{bucket_name}"
+                    container = ContainerClient.from_container_url(container_url=sas_url, credential=session_token)
+                    now = datetime.now(timezone.utc)
+                    for blob in container.list_blobs():
+                        if abs((blob.last_modified - now).days) > older_than_days:
+                            logger.debug(f"Deleting expired object {blob.name}")
+                            container.delete_blob(blob.name)
+
+                if location['type'] == 'AWS':
+                    credentials = self.upload_credentials(location['apiId'])
+                    access_key = credentials['key']
+                    secret_key = credentials['secret']
+                    session_token = credentials['sessionToken']
+                    session = boto3.Session(aws_access_key_id=access_key, aws_secret_access_key=secret_key,
+                                            aws_session_token=session_token)
+                    s3_client = session.client("s3")
+                    paginator = s3_client.get_paginator('list_objects_v2')
+                    now = datetime.now(timezone.utc)
+                    for page in paginator.paginate(Bucket=bucket_name):
+                        if 'Contents' in page:
+                            for key in page['Contents']:
+                                last_modified = key["LastModified"]
+                                if abs((last_modified - now).days) > older_than_days:
+                                    logger.debug(f"Deleting expired object {key["Key"]}")
+                                    s3_client.delete_object(Bucket=bucket_name, Key=key["Key"])
+
+
+
+
+
+
+
     def upload_locations(self):
         """
         Upload locations are configured on the Sources page as 'SIP Upload'.

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica/webHooksAPI.py

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

{pypreservica-3.2.2 → pypreservica-3.2.4}/pyPreservica.egg-info/PKG-INFO

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

{pypreservica-3.2.2 → pypreservica-3.2.4}/setup.py

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

{pypreservica-3.2.2 → pypreservica-3.2.4}/tests/test_export_opex.py

@@ -1,24 +1,48 @@
+from os.path import isfile
+
 import pytest
 
 from zipfile import ZipFile
 from pyPreservica import *
 
 
-def test_export_file_wait():
+
+
+def setup():
+    pass
+
+
+def tear_down(zip_files):
+    for f in zip_files:
+        if os.path.exists(f):
+            os.remove(f)
+
+
+@pytest.fixture
+def setup_data():
+    print("\nSetting up resources...")
+    zip_files = []
+    setup()
+    yield zip_files
+    print(f"\nTearing down resources...")
+    tear_down(zip_files)
+
+def test_export_file_wait(setup_data):
     client = EntityAPI()
     asset = client.asset("683f9db7-ff81-4859-9c03-f68cfa5d9c3d")
-    zip_file = client.export_opex_sync(asset, IncludeContent='true')
+    zip_file = client.export_opex_sync(asset, IncludeContent='true', IncludeMetadata='true')
     assert os.path.exists(zip_file)
+    setup_data.append(zip_file)
     assert 1066650 < os.stat(zip_file).st_size
     with ZipFile(zip_file, 'r') as zipObj:
         assert len(zipObj.namelist()) == 6
     os.remove(zip_file)
 
 
-def test_export_file_no_wait():
+def test_export_file_no_wait(setup_data):
     client = EntityAPI()
     asset = client.asset("683f9db7-ff81-4859-9c03-f68cfa5d9c3d")
-    pid = client.export_opex_async(asset)
+    pid = client.export_opex_async(asset, IncludeContent='true', IncludeMetadata='true')
     status = "ACTIVE"
 
     while status == "ACTIVE":
@@ -28,6 +52,7 @@ def test_export_file_no_wait():
 
     zip_file = client.download_opex(pid)
     assert os.path.exists(zip_file)
+    setup_data.append(zip_file)
     assert 1066650 < os.stat(zip_file).st_size
     with ZipFile(zip_file, 'r') as zipObj:
         assert len(zipObj.namelist()) == 6

{pypreservica-3.2.2 → pypreservica-3.2.4}/tests/test_schema.py

@@ -38,11 +38,11 @@ def test_get_xml_documents():
     xml_documents = client.xml_documents()
     assert type(xml_documents) is list
     assert len(xml_documents) > 10
-    for xml in xml_documents:
-        assert type(xml) is dict
-        assert "Name" in xml
-        assert "SchemaUri" in xml
-        assert "ApiId" in xml
+    for x in xml_documents:
+        assert type(x) is dict
+        assert "Name" in x
+        assert "SchemaUri" in x
+        assert "ApiId" in x
 
 
 def test_get_xml_document_by_uri():
@@ -73,12 +73,12 @@ def test_get_xml_transforms():
     xml_transforms = client.xml_transforms()
     assert type(xml_transforms) is list
     assert len(xml_transforms) > 10
-    for xml in xml_transforms:
-        assert type(xml) is dict
-        assert "Name" in xml
-        assert "FromSchemaUri" in xml
-        assert "ToSchemaUri" in xml
-        assert "ApiId" in xml
+    for x in xml_transforms:
+        assert type(x) is dict
+        assert "Name" in x
+        assert "FromSchemaUri" in x
+        assert "ToSchemaUri" in x
+        assert "ApiId" in x
 
 
 def test_get_xml_transform_by_uri():