pyPreservica 2.7.3__tar.gz → 2.8.0__tar.gz

{pypreservica-2.7.3 → pypreservica-2.8.0}/PKG-INFO

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

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica/__init__.py

@@ -18,11 +18,11 @@ from .adminAPI import AdminAPI
 from .monitorAPI import MonitorAPI, MonitorCategory, MonitorStatus, MessageStatus
 from .webHooksAPI import WebHooksAPI, TriggerType, WebHookHandler
 from .authorityAPI import AuthorityAPI, Table
-from .mdformsAPI import MDFormsAPI
+from .mdformsAPI import MetadataGroupsAPI, GroupFieldType, GroupField, Group
 
 __author__ = "James Carr (drjamescarr@gmail.com)"
 
 # Version of the pyPreservica package
-__version__ = "2.7.3"
+__version__ = "2.8.0"
 
 __license__ = "Apache License Version 2.0"

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica/common.py

@@ -477,10 +477,10 @@ class Entity:
     def __repr__(self):
         return self.__str__()
 
-    def has_metadata(self):
+    def has_metadata(self) -> bool:
         return bool(self.metadata)
 
-    def metadata_namespaces(self):
+    def metadata_namespaces(self) -> list:
         return list(self.metadata.values())
 
 
@@ -714,11 +714,33 @@ class AuthenticatedAPI:
 
         return entity_dict
 
+    def edition(self) -> str:
+        """
+        Return the edition of this tenancy
+        """
+        if self.major_version < 8 and self.minor_version < 3:
+            raise RuntimeError("Entitlement  API is only available when connected to a v7.3 System")
+
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json'}
+
+        response = self.session.get(f'{self.protocol}://{self.server}/api/entitlement/edition', headers=headers)
+
+        if response.status_code == requests.codes.ok:
+            return response.json()['edition']
+        elif response.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            return self.edition()
+        else:
+            exception = HTTPException("", response.status_code, response.url,
+                                      "edition", response.content.decode('utf-8'))
+            logger.error(exception)
+            raise exception
+
     def __version_namespace__(self):
         """
         Generate version specific namespaces from the server version
         """
-        if self.major_version == 7:
+        if self.major_version > 6:
             self.xip_ns = f"{NS_XIP_ROOT}v{self.major_version}.{self.minor_version}"
             self.entity_ns = f"{NS_ENTITY_ROOT}v{self.major_version}.{self.minor_version}"
             self.rm_ns = f"{NS_RM_ROOT}v{6}.{2}"
@@ -857,12 +879,16 @@ class AuthenticatedAPI:
                 raise RuntimeError(response.status_code, msg)
 
     def __init__(self, username: str = None, password: str = None, tenant: str = None, server: str = None,
-                 use_shared_secret: bool = False, two_fa_secret_key: str = None, protocol: str = "https"):
+                 use_shared_secret: bool = False, two_fa_secret_key: str = None,
+                 protocol: str = "https", request_hook=None):
 
         config = configparser.ConfigParser(interpolation=configparser.Interpolation())
         config.read('credentials.properties', encoding='utf-8')
         self.session: Session = requests.Session()
 
+        if request_hook is not None:
+            self.session.hooks['response'].append(request_hook)
+
         retries = Retry(
             total=3,
             backoff_factor=0.1,

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica/contentAPI.py

@@ -10,7 +10,7 @@ licence:    Apache License 2.0
 """
 
 import csv
-from typing import Generator
+from typing import Generator, Callable
 from pyPreservica.common import *
 
 logger = logging.getLogger(__name__)
@@ -19,8 +19,10 @@ logger = logging.getLogger(__name__)
 class ContentAPI(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"):
-        super().__init__(username, password, tenant, server, use_shared_secret, two_fa_secret_key, protocol)
+                 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)
         self.callback = None
 
     class SearchResult:
@@ -130,7 +132,8 @@ class ContentAPI(AuthenticatedAPI):
             logger.error(f"indexed_fields failed with error code: {results.status_code}")
             raise RuntimeError(results.status_code, f"indexed_fields failed with error code: {results.status_code}")
 
-    def simple_search_csv(self, query: str = "%", page_size: int = 50, csv_file="search.csv", list_indexes: list = None):
+    def simple_search_csv(self, query: str = "%", page_size: int = 50, csv_file="search.csv",
+                          list_indexes: list = None):
         if list_indexes is None or len(list_indexes) == 0:
             metadata_fields = ["xip.reference", "xip.title", "xip.description", "xip.document_type",
                                "xip.parent_ref", "xip.security_descriptor"]
@@ -193,7 +196,8 @@ class ContentAPI(AuthenticatedAPI):
             logger.error(f"search failed with error code: {results.status_code}")
             raise RuntimeError(results.status_code, f"simple_search failed with error code: {results.status_code}")
 
-    def search_index_filter_csv(self, query: str = "%", csv_file="search.csv", page_size: int = 50, filter_values: dict = None,
+    def search_index_filter_csv(self, query: str = "%", csv_file="search.csv", page_size: int = 50,
+                                filter_values: dict = None,
                                 sort_values: dict = None):
         if filter_values is None:
             filter_values = {}

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica/entityAPI.py

@@ -15,7 +15,7 @@ import xml.etree.ElementTree
 from datetime import datetime, timedelta, timezone
 from io import BytesIO
 from time import sleep
-from typing import Any, Generator, Tuple, Iterable, Union
+from typing import Any, Generator, Tuple, Iterable, Union, Callable
 
 from pyPreservica.common import *
 
@@ -34,8 +34,12 @@ class EntityAPI(AuthenticatedAPI):
     """
 
     def __init__(self, username: str = None, password: str = None, tenant: str = None, server: str = None,
-                 use_shared_secret: bool = False, two_fa_secret_key: str = None, protocol: str = "https"):
-        super().__init__(username, password, tenant, server, use_shared_secret, two_fa_secret_key, protocol)
+                 use_shared_secret: bool = 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)
+
         xml.etree.ElementTree.register_namespace("oai_dc", "http://www.openarchives.org/OAI/2.0/oai_dc/")
         xml.etree.ElementTree.register_namespace("ead", "urn:isbn:1-931666-22-9")
 

pypreservica-2.8.0/pyPreservica/mdformsAPI.py

@@ -0,0 +1,300 @@
+"""
+pyPreservica MDFormsAPI module definition
+
+A client library for the Preservica Repository web services Metadata API
+https://demo.preservica.com/api/metadata/documentation.html
+
+author:     James Carr
+licence:    Apache License 2.0
+
+"""
+import json
+import xml.etree.ElementTree
+from typing import Callable, List
+
+from pyPreservica.common import *
+
+
+class GroupFieldType(Enum):
+    STRING = "STRING"
+    LONG_STRING = "LONGSTRING"
+    DATE = "DATE"
+    NUMBER = "NUMBER"
+
+
+class GroupField:
+    field_id: str
+    name: str
+    field_type: GroupFieldType
+    maxLength: int
+    default: str
+    visible: bool
+    editable: bool
+    minOccurs: int
+    maxOccurs: int
+    values: List[str]
+    indexed: bool
+
+    def __init__(self, field_id: str, name: str, field_type: GroupFieldType = GroupFieldType.STRING,
+                 maxLength: int = -1, default: str = "", visible: bool = True, editable: bool = True,
+                 minOccurs: int = 0, maxOccurs: int = 1, indexed: bool = True, values: List = None):
+        self.field_id = field_id
+        self.name = name
+        self.field_type = field_type
+        self.maxLength = maxLength
+        self.default = default
+        self.visible = visible
+        self.editable = editable
+        self.minOccurs = minOccurs
+        self.maxOccurs = maxOccurs
+        self.values = values
+        self.indexed = indexed
+
+    def __str__(self):
+        return (f"Field ID: {self.field_id}\n" + f"Field Name: {self.name}\n" + f"Field Type: {self.field_type}\n" +
+                f"Field Visible: {self.visible}\n" + f"Field Editable: {self.editable}\n")
+
+
+class Group:
+    group_id: str
+    name: str
+    description: str
+    schemaUri: str
+    fields: List[GroupField] = []
+
+    def __str__(self):
+        return (f"Group ID: {self.group_id}\n" + f"Group Name: {self.name}\n" +
+                f"Group Description: {self.description}\n" + f"Group Schema URI: {self.schemaUri}")
+
+
+class MetadataGroupsAPI(AuthenticatedAPI):
+    def __init__(self, username: str = None, password: str = None, tenant: str = None, server: str = None,
+                 use_shared_secret: bool = 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)
+
+        xml.etree.ElementTree.register_namespace("oai_dc", "http://www.openarchives.org/OAI/2.0/oai_dc/")
+        xml.etree.ElementTree.register_namespace("ead", "urn:isbn:1-931666-22-9")
+
+    def delete_group_namespace(self, schema: str):
+        """
+         Delete a new Metadata Group using its schema URI
+
+         :param schema: The Group namespace schema URI
+         :type schema: str
+
+         :return: None
+         :rtype: None
+
+         """
+        for group in self.groups():
+            if group.schemaUri == schema:
+                self.delete_group(group.group_id)
+
+    def delete_group(self, group_id: str):
+        """
+         Delete a new Metadata Group using its ID
+
+         :param group_id: Group ID
+         :type group_id: str
+
+         :return: None
+         :rtype: None
+
+         """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/groups/{group_id}'
+        with self.session.delete(url, headers=headers) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.delete_group(group_id)
+            elif request.status_code == requests.codes.no_content:
+                return None
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "delete_group",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+    def add_group(self, group_name: str, group_description: str, fields: List[GroupField]):
+        """
+          Create a new Metadata Group GroupFields
+
+          :param group_name: The name of the new Group
+          :type group_name: str
+
+          :param group_description: The description of the new Group
+          :type group_description: str
+
+          :param fields: The list of fields
+          :type fields: List[GroupField]
+
+          :return:  JSON document
+          :rtype: str
+
+          """
+
+        fields_str_list = []
+        for field in fields:
+
+            values = ""
+            if (field.values is not None) and (len(field.values) > 0):
+                values = f"""\n"values" : [ {",".join('"' + item + '"' for item in field.values)} ],
+                """
+
+            fields_str = f"""{{
+            "id" : "{field.field_id}",
+            "name": "{field.name}",
+            "type": "{field.field_type.value}",
+            "minOccurs": "{field.minOccurs}",
+            "maxOccurs": "{field.maxOccurs}",
+            "visible": "{field.visible}", {values}
+            "editable": "{field.editable}",
+            "defaultValue": "{field.default}",
+            "indexed": "{field.indexed}"
+            }}"""
+            
+            fields_str_list.append(fields_str)
+
+        json_doc = f"""{{
+          "name" : "{group_name}",
+          "description" : "{group_description}",
+          "fields" : [ {",".join(fields_str_list)}  ]
+        }}"""
+
+        print(json_doc)
+
+        json_response = self.add_group_json(json_doc)
+        group_id = json_response['id']
+        return self.group(group_id)
+
+    def add_group_json(self, json_document: str) -> str:
+        """
+         Create a new Metadata Group using a JSON document
+
+         :param json_document: JSON document
+         :type json_document: str
+
+         :return:  JSON document
+         :rtype: str
+
+         """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/groups/'
+        with self.session.post(url, headers=headers, data=json_document) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.add_group_json(json_document)
+            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_group_json",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+    def group_json(self, group_id: str) -> str:
+        """
+         Return a Group as a JSON document
+
+         :param group_id: The Group id
+         :type group_id: str
+
+         :return:  JSON document
+         :rtype: str
+
+         """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/groups/{group_id}'
+        with self.session.get(url, headers=headers) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.group_json(group_id)
+            elif request.status_code == requests.codes.ok:
+                return str(request.content.decode('utf-8'))
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "group_json",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+    def group(self, group_id: str) -> Group:
+        """
+         Return a Group object by its id
+
+         :param group_id: The Group id
+         :type group_id: str
+
+         :return: The Group
+         :rtype: Group
+
+         """
+        json_group = json.loads(self.group_json(group_id))
+        group: Group = Group()
+        group.group_id = json_group['id']
+        group.name = json_group['name']
+        group.description = json_group['description']
+        group.schemaUri = json_group['schemaUri']
+
+        for f in json_group['fields']:
+            gf: GroupField = GroupField(f['id'], f['name'])
+            if 'type' in f:
+                gf.field_type = f['type']
+            if 'visible' in f:
+                gf.visible = f['visible']
+            if 'editable' in f:
+                gf.editable = f['editable']
+            if 'indexed' in f:
+                gf.indexed = f['indexed']
+            if 'maxOccurs' in f:
+                gf.maxOccurs = f['maxOccurs']
+            if 'minOccurs' in f:
+                gf.minOccurs = f['minOccurs']
+            if 'values' in f:
+                gf.values = f['values']
+            group.fields.append(gf)
+        return group
+
+    def groups_json(self) -> str:
+        """
+        Return all the groups in the tenancy as a single json document
+
+        :return: JSON document
+        :rtype: str
+
+        """
+
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/groups'
+        with self.session.get(url, headers=headers) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.groups_json()
+            elif request.status_code == requests.codes.ok:
+                return str(request.content.decode('utf-8'))
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "groups_json",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+    def groups(self) -> List[Group]:
+        """
+        Return all the groups in the tenancy
+
+        :return: list of Groups
+        :rtype: List[Group]
+
+        """
+        groups = json.loads(self.groups_json())['groups']
+        return_groups = []
+        for g in groups:
+            group: Group = Group()
+            group.group_id = g['id']
+            group.name = g['name']
+            group.description = g['description']
+            group.schemaUri = g['schemaUri']
+            return_groups.append(group)
+        return return_groups

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica/retentionAPI.py

@@ -11,7 +11,7 @@ licence:    Apache License 2.0
 
 
 import xml.etree.ElementTree
-from typing import Set
+from typing import Set, Callable
 
 from pyPreservica.common import *
 
@@ -59,8 +59,10 @@ class RetentionPolicy:
 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"):
-        super().__init__(username, password, tenant, server, use_shared_secret, two_fa_secret_key, protocol)
+                 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:
             raise RuntimeError("Retention API is only available when connected to a v6.2 System")
 

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica/uploadAPI.py

@@ -80,7 +80,8 @@ class PutObjectTask(s3transfer.tasks.Task):
 class CompleteMultipartUploadTask(s3transfer.tasks.Task):
     # Copied from s3transfer/tasks.py, changed to return a result.
     def _main(self, client, bucket, key, upload_id, parts, extra_args):
-        return client.complete_multipart_upload(Bucket=bucket, Key=key, UploadId=upload_id, MultipartUpload={"Parts": parts},
+        return client.complete_multipart_upload(Bucket=bucket, Key=key, UploadId=upload_id,
+                                                MultipartUpload={"Parts": parts},
                                                 **extra_args, )
 
 
@@ -224,7 +225,8 @@ def __make_representation_multiple_co__(xip, rep_name, rep_type, rep_files, io_r
     return refs_dict
 
 
-def cvs_to_cmis_xslt(csv_file, xml_namespace, root_element, title="Metadata Title", export_folder=None, additional_namespaces=None):
+def cvs_to_cmis_xslt(csv_file, xml_namespace, root_element, title="Metadata Title", export_folder=None,
+                     additional_namespaces=None):
     """
             Create a custom CMIS transform to display metadata within UA.
 
@@ -242,7 +244,8 @@ def cvs_to_cmis_xslt(csv_file, xml_namespace, root_element, title="Metadata Titl
 
     namespaces = {"version": "2.0", "xmlns:xsl": "http://www.w3.org/1999/XSL/Transform",
                   "xmlns:fn": "http://www.w3.org/2005/xpath-functions", "xmlns:xs": "http://www.w3.org/2001/XMLSchema",
-                  "xmlns:csv": xml_namespace, "xmlns": "http://www.tessella.com/sdb/cmis/metadata", "exclude-result-prefixes": "csv"}
+                  "xmlns:csv": xml_namespace, "xmlns": "http://www.tessella.com/sdb/cmis/metadata",
+                  "exclude-result-prefixes": "csv"}
 
     if additional_namespaces is not None:
         for prefix, uri in additional_namespaces.items():
@@ -311,7 +314,8 @@ def cvs_to_xsd(csv_file, xml_namespace, root_element, export_folder=None, additi
                 headers.add(xml_tag)
             break
 
-    namespaces = {"xmlns:xs": "http://www.w3.org/2001/XMLSchema", "attributeFormDefault": "unqualified", "elementFormDefault": "qualified",
+    namespaces = {"xmlns:xs": "http://www.w3.org/2001/XMLSchema", "attributeFormDefault": "unqualified",
+                  "elementFormDefault": "qualified",
                   "targetNamespace": xml_namespace}
 
     if additional_namespaces is not None:
@@ -333,7 +337,8 @@ def cvs_to_xsd(csv_file, xml_namespace, root_element, export_folder=None, additi
             prefix, sep, tag = header.partition(":")
             try:
                 namespace = additional_namespaces[prefix]
-                xml.etree.ElementTree.SubElement(xml_sequence, "xs:element", {"ref": header, "xmlns:" + prefix: namespace})
+                xml.etree.ElementTree.SubElement(xml_sequence, "xs:element",
+                                                 {"ref": header, "xmlns:" + prefix: namespace})
             except KeyError:
                 xml.etree.ElementTree.SubElement(xml_sequence, "xs:element", {"type": "xs:string", "name": header})
         else:
@@ -350,7 +355,8 @@ def cvs_to_xsd(csv_file, xml_namespace, root_element, export_folder=None, additi
     return xsd_file
 
 
-def csv_to_search_xml(csv_file, xml_namespace, root_element, title="Metadata Title", export_folder=None, additional_namespaces=None):
+def csv_to_search_xml(csv_file, xml_namespace, root_element, title="Metadata Title", export_folder=None,
+                      additional_namespaces=None):
     """
         Create a custom Preservica search index based on the columns in a csv file
 
@@ -400,7 +406,8 @@ def csv_to_search_xml(csv_file, xml_namespace, root_element, title="Metadata Tit
     return search_xml
 
 
-def cvs_to_xml(csv_file, xml_namespace, root_element, file_name_column="filename", export_folder=None, additional_namespaces=None):
+def cvs_to_xml(csv_file, xml_namespace, root_element, file_name_column="filename", export_folder=None,
+               additional_namespaces=None):
     """
         Export the rows of a CSV file as XML metadata documents which can be added to Preservica assets
 
@@ -451,7 +458,8 @@ def cvs_to_xml(csv_file, xml_namespace, root_element, file_name_column="filename
                 yield name
 
 
-def generic_asset_package(preservation_files_dict=None, access_files_dict=None, export_folder=None, parent_folder=None, compress=True,
+def generic_asset_package(preservation_files_dict=None, access_files_dict=None, export_folder=None, parent_folder=None,
+                          compress=True,
                           **kwargs):
     # some basic validation
     if export_folder is None:
@@ -501,8 +509,10 @@ def generic_asset_package(preservation_files_dict=None, access_files_dict=None,
     if has_preservation_files:
         for representation_name in preservation_files_dict.keys():
             preservation_files_list = preservation_files_dict[representation_name]
-            preservation_refs_dict = __make_representation_multiple_co__(xip, rep_name=representation_name, rep_type="Preservation",
-                                                                         rep_files=preservation_files_list, io_ref=io_ref)
+            preservation_refs_dict = __make_representation_multiple_co__(xip, rep_name=representation_name,
+                                                                         rep_type="Preservation",
+                                                                         rep_files=preservation_files_list,
+                                                                         io_ref=io_ref)
             preservation_representation_refs_dict[representation_name] = preservation_refs_dict
 
     if has_access_files:
@@ -519,13 +529,16 @@ def generic_asset_package(preservation_files_dict=None, access_files_dict=None,
                 default_content_objects_title = os.path.splitext(os.path.basename(filename))[0]
 
                 preservation_content_title = kwargs.get('Preservation_Content_Title', default_content_objects_title)
-                preservation_content_description = kwargs.get('Preservation_Content_Description', default_content_objects_title)
+                preservation_content_description = kwargs.get('Preservation_Content_Description',
+                                                              default_content_objects_title)
 
                 if isinstance(preservation_content_title, dict):
-                    preservation_content_title = preservation_content_title.get("filename", default_content_objects_title)
+                    preservation_content_title = preservation_content_title.get("filename",
+                                                                                default_content_objects_title)
 
                 if isinstance(preservation_content_description, dict):
-                    preservation_content_description = preservation_content_description.get("filename", default_content_objects_title)
+                    preservation_content_description = preservation_content_description.get("filename",
+                                                                                            default_content_objects_title)
 
                 __make_content_objects__(xip, preservation_content_title, content_ref, io_ref, security_tag,
                                          preservation_content_description, content_type)
@@ -545,7 +558,8 @@ def generic_asset_package(preservation_files_dict=None, access_files_dict=None,
                 if isinstance(access_content_description, dict):
                     access_content_description = access_content_title.get("filename", default_content_objects_title)
 
-                __make_content_objects__(xip, access_content_title, content_ref, io_ref, security_tag, access_content_description,
+                __make_content_objects__(xip, access_content_title, content_ref, io_ref, security_tag,
+                                         access_content_description,
                                          content_type)
 
     if has_preservation_files:
@@ -816,7 +830,8 @@ def multi_asset_package(asset_file_list=None, export_folder=None, parent_folder=
         return top_level_folder + ".zip"
 
 
-def complex_asset_package(preservation_files_list=None, access_files_list=None, export_folder=None, parent_folder=None, compress=True,
+def complex_asset_package(preservation_files_list=None, access_files_list=None, export_folder=None, parent_folder=None,
+                          compress=True,
                           **kwargs):
     """
 
@@ -909,13 +924,15 @@ def complex_asset_package(preservation_files_list=None, access_files_list=None,
     if has_preservation_files:
         # add the content objects
         representation_name = kwargs.get('Preservation_Representation_Name', "Preservation")
-        preservation_refs_dict = __make_representation_multiple_co__(xip, rep_name=representation_name, rep_type="Preservation",
+        preservation_refs_dict = __make_representation_multiple_co__(xip, rep_name=representation_name,
+                                                                     rep_type="Preservation",
                                                                      rep_files=preservation_files_list, io_ref=io_ref)
 
     if has_access_files:
         # add the content objects
         access_name = kwargs.get('Access_Representation_Name', "Access")
-        access_refs_dict = __make_representation_multiple_co__(xip, rep_name=access_name, rep_type="Access", rep_files=access_files_list,
+        access_refs_dict = __make_representation_multiple_co__(xip, rep_name=access_name, rep_type="Access",
+                                                               rep_files=access_files_list,
                                                                io_ref=io_ref)
 
     if has_preservation_files:
@@ -923,7 +940,8 @@ def complex_asset_package(preservation_files_list=None, access_files_list=None,
         for content_ref, filename in preservation_refs_dict.items():
             default_content_objects_title = os.path.splitext(os.path.basename(filename))[0]
             preservation_content_title = kwargs.get('Preservation_Content_Title', default_content_objects_title)
-            preservation_content_description = kwargs.get('Preservation_Content_Description', default_content_objects_title)
+            preservation_content_description = kwargs.get('Preservation_Content_Description',
+                                                          default_content_objects_title)
 
             if isinstance(preservation_content_title, dict):
                 preservation_content_title = preservation_content_title[filename]
@@ -931,7 +949,8 @@ def complex_asset_package(preservation_files_list=None, access_files_list=None,
             if isinstance(preservation_content_description, dict):
                 preservation_content_description = preservation_content_description[filename]
 
-            __make_content_objects__(xip, preservation_content_title, content_ref, io_ref, security_tag, preservation_content_description,
+            __make_content_objects__(xip, preservation_content_title, content_ref, io_ref, security_tag,
+                                     preservation_content_description,
                                      content_type)
 
     if has_access_files:
@@ -948,7 +967,8 @@ def complex_asset_package(preservation_files_list=None, access_files_list=None,
             if isinstance(access_content_description, dict):
                 access_content_title = access_content_title[filename]
 
-            __make_content_objects__(xip, access_content_title, content_ref, io_ref, security_tag, access_content_description, content_type)
+            __make_content_objects__(xip, access_content_title, content_ref, io_ref, security_tag,
+                                     access_content_description, content_type)
 
     if has_preservation_files:
 
@@ -956,7 +976,8 @@ def complex_asset_package(preservation_files_list=None, access_files_list=None,
 
         for content_ref, filename in preservation_refs_dict.items():
             preservation_file_name = os.path.basename(filename)
-            __make_generation__(xip, preservation_file_name, content_ref, preservation_generation_label, PRESERVATION_CONTENT_FOLDER)
+            __make_generation__(xip, preservation_file_name, content_ref, preservation_generation_label,
+                                PRESERVATION_CONTENT_FOLDER)
 
     if has_access_files:
 
@@ -1071,7 +1092,8 @@ def complex_asset_package(preservation_files_list=None, access_files_list=None,
         return top_level_folder + ".zip"
 
 
-def simple_asset_package(preservation_file=None, access_file=None, export_folder=None, parent_folder=None, compress=True, **kwargs):
+def simple_asset_package(preservation_file=None, access_file=None, export_folder=None, parent_folder=None,
+                         compress=True, **kwargs):
     """
             Create a Preservica package containing a single Asset from a single preservation file
             and an optional access file.
@@ -1131,7 +1153,8 @@ def _unpad(s):
 
 class UploadAPI(AuthenticatedAPI):
 
-    def ingest_tweet(self, twitter_user=None, tweet_id: int = 0, twitter_consumer_key=None, twitter_secret_key=None, folder=None,
+    def ingest_tweet(self, twitter_user=None, tweet_id: int = 0, twitter_consumer_key=None, twitter_secret_key=None,
+                     folder=None,
                      callback=None, **kwargs):
 
         """
@@ -1175,7 +1198,8 @@ class UploadAPI(AuthenticatedAPI):
                     video_name_document_.close()
                     return video_name_, True
 
-        entity_client = pyPreservica.EntityAPI(username=self.username, password=self.password, server=self.server, tenant=self.tenant)
+        entity_client = pyPreservica.EntityAPI(username=self.username, password=self.password, server=self.server,
+                                               tenant=self.tenant)
         if hasattr(folder, "reference"):
             folder = entity_client.folder(folder.reference)
         else:
@@ -1313,7 +1337,8 @@ class UploadAPI(AuthenticatedAPI):
                 os.remove(ob)
             os.remove("metadata.xml")
 
-    def ingest_twitter_feed(self, twitter_user=None, num_tweets: int = 25, twitter_consumer_key=None, twitter_secret_key=None, folder=None,
+    def ingest_twitter_feed(self, twitter_user=None, num_tweets: int = 25, twitter_consumer_key=None,
+                            twitter_secret_key=None, folder=None,
                             callback=None, **kwargs):
 
         """
@@ -1358,7 +1383,8 @@ class UploadAPI(AuthenticatedAPI):
                                 video_name_document_.flush()
                         return video_name_, True
 
-        entity_client = pyPreservica.EntityAPI(username=self.username, password=self.password, server=self.server, tenant=self.tenant)
+        entity_client = pyPreservica.EntityAPI(username=self.username, password=self.password, server=self.server,
+                                               tenant=self.tenant)
         if hasattr(folder, "reference"):
             folder = entity_client.folder(folder.reference)
         else:
@@ -1489,7 +1515,8 @@ class UploadAPI(AuthenticatedAPI):
                 asset_title = kwargs.get("Title", text)
                 asset_description = kwargs.get("Description", full_text)
 
-                p = complex_asset_package(preservation_files_list=content_objects, parent_folder=folder, Title=asset_title,
+                p = complex_asset_package(preservation_files_list=content_objects, parent_folder=folder,
+                                          Title=asset_title,
                                           Description=asset_description, CustomType="Tweet", Identifiers=identifiers,
                                           Asset_Metadata=asset_metadata, SecurityTag=security_tag)
                 self.upload_zip_package(p, folder=folder, callback=callback)
@@ -1573,7 +1600,8 @@ class UploadAPI(AuthenticatedAPI):
             duration = meta.get('duration')
 
             package = simple_asset_package(preservation_file=f"{vid_id}.mp4", parent_folder=parent_folder, Title=title,
-                                           Description=description, Identifiers=identifier_map, Asset_Metadata=descriptive_metadata,
+                                           Description=description, Identifiers=identifier_map,
+                                           Asset_Metadata=descriptive_metadata,
                                            Preservation_Content_Title=title, SecurityTag=security_tag)
 
             self.upload_zip_package(path_to_zip_package=package, folder=parent_folder, callback=callback)
@@ -1594,7 +1622,8 @@ class UploadAPI(AuthenticatedAPI):
             self.token = self.__token__()
             return self.upload_credentials(location_id)
         else:
-            exception = HTTPException(location_id, request.status_code, request.url, "upload_credentials", request.content.decode('utf-8'))
+            exception = HTTPException(location_id, request.status_code, request.url, "upload_credentials",
+                                      request.content.decode('utf-8'))
             logger.error(exception)
             raise exception
 
@@ -1613,7 +1642,8 @@ class UploadAPI(AuthenticatedAPI):
             self.token = self.__token__()
             return self.upload_locations()
         else:
-            exception = HTTPException("", request.status_code, request.url, "upload_locations", request.content.decode('utf-8'))
+            exception = HTTPException("", request.status_code, request.url, "upload_locations",
+                                      request.content.decode('utf-8'))
             logger.error(exception)
             raise exception
 
@@ -1625,7 +1655,8 @@ class UploadAPI(AuthenticatedAPI):
         """
         return self.upload_locations()
 
-    def crawl_filesystem(self, filesystem_path, bucket_name, preservica_parent, callback: bool = False, security_tag: str = "open",
+    def crawl_filesystem(self, filesystem_path, bucket_name, preservica_parent, callback: bool = False,
+                         security_tag: str = "open",
                          delete_after_upload: bool = True, max_MB_ingested: int = -1):
 
         def get_parent(client, identifier, parent_reference):
@@ -1652,8 +1683,10 @@ class UploadAPI(AuthenticatedAPI):
             return folder
 
         from pyPreservica import EntityAPI
-        entity_client = EntityAPI(username=self.username, password=self.password, server=self.server, tenant=self.tenant,
-                                  two_fa_secret_key=self.two_fa_secret_key, use_shared_secret=self.shared_secret, protocol=self.protocol)
+        entity_client = EntityAPI(username=self.username, password=self.password, server=self.server,
+                                  tenant=self.tenant,
+                                  two_fa_secret_key=self.two_fa_secret_key, use_shared_secret=self.shared_secret,
+                                  protocol=self.protocol)
 
         if preservica_parent:
             parent = entity_client.folder(preservica_parent)
@@ -1697,8 +1730,14 @@ class UploadAPI(AuthenticatedAPI):
                 else:
                     progress_display = None
 
-                self.upload_zip_package_to_S3(path_to_zip_package=package, bucket_name=bucket_name, callback=progress_display,
-                                              delete_after_upload=delete_after_upload)
+                if bucket_name is None:
+                    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,
+                                                  delete_after_upload=delete_after_upload)
+
                 logger.info(f"Uploaded " + "{:.1f}".format(bytes_ingested / (1024 * 1024)) + " MB")
 
                 if max_MB_ingested > 0:
@@ -1706,7 +1745,8 @@ class UploadAPI(AuthenticatedAPI):
                         logger.info(f"Reached Max Upload Limit")
                         break
 
-    def upload_zip_to_Source(self, path_to_zip_package, container_name, folder=None, delete_after_upload=False, show_progress=False):
+    def upload_zip_to_Source(self, path_to_zip_package, container_name, folder=None, delete_after_upload=False,
+                             show_progress=False):
 
         """
              Uploads a zip file package to either an Azure container or S3 bucket
@@ -1727,13 +1767,17 @@ class UploadAPI(AuthenticatedAPI):
                     callback = None
                     if show_progress:
                         callback = UploadProgressConsoleCallback(path_to_zip_package)
-                    self.upload_zip_package_to_S3(path_to_zip_package=path_to_zip_package, bucket_name=container_name, folder=folder,
+                    self.upload_zip_package_to_S3(path_to_zip_package=path_to_zip_package, bucket_name=container_name,
+                                                  folder=folder,
                                                   callback=callback, delete_after_upload=delete_after_upload)
                 else:
-                    self.upload_zip_package_to_Azure(path_to_zip_package=path_to_zip_package, container_name=container_name, folder=folder,
-                                                     delete_after_upload=delete_after_upload, show_progress=show_progress)
+                    self.upload_zip_package_to_Azure(path_to_zip_package=path_to_zip_package,
+                                                     container_name=container_name, folder=folder,
+                                                     delete_after_upload=delete_after_upload,
+                                                     show_progress=show_progress)
 
-    def upload_zip_package_to_Azure(self, path_to_zip_package, container_name, folder=None, delete_after_upload=False, show_progress=False):
+    def upload_zip_package_to_Azure(self, path_to_zip_package, container_name, folder=None, delete_after_upload=False,
+                                    show_progress=False):
 
         """
          Uploads a zip file package to an Azure container connected to a Preservica Cloud System
@@ -1746,7 +1790,8 @@ class UploadAPI(AuthenticatedAPI):
         """
 
         if (self.major_version < 7) and (self.minor_version < 5):
-            raise RuntimeError("This call [upload_zip_package_to_Azure] is only available against v6.5 systems and above")
+            raise RuntimeError(
+                "This call [upload_zip_package_to_Azure] is only available against v6.5 systems and above")
 
         from azure.storage.blob import ContainerClient
 
@@ -1774,11 +1819,13 @@ class UploadAPI(AuthenticatedAPI):
 
                 if show_progress:
                     with tqdm.wrapattr(open(path_to_zip_package, 'rb'), "read", total=len_bytes) as data:
-                        blob_client = container.upload_blob(name=upload_key, data=data, metadata=metadata, length=len_bytes)
+                        blob_client = container.upload_blob(name=upload_key, data=data, metadata=metadata,
+                                                            length=len_bytes)
                         properties = blob_client.get_blob_properties()
                 else:
                     with open(path_to_zip_package, "rb") as data:
-                        blob_client = container.upload_blob(name=upload_key, data=data, metadata=metadata, length=len_bytes)
+                        blob_client = container.upload_blob(name=upload_key, data=data, metadata=metadata,
+                                                            length=len_bytes)
                         properties = blob_client.get_blob_properties()
 
                 if delete_after_upload:
@@ -1786,7 +1833,8 @@ class UploadAPI(AuthenticatedAPI):
 
                 return properties
 
-    def upload_zip_package_to_S3(self, path_to_zip_package, bucket_name, folder=None, callback=None, delete_after_upload=False):
+    def upload_zip_package_to_S3(self, path_to_zip_package, bucket_name, folder=None, callback=None,
+                                 delete_after_upload=False):
 
         """
            Uploads a zip file package to an S3 bucket connected to a Preservica Cloud System
@@ -1815,7 +1863,8 @@ class UploadAPI(AuthenticatedAPI):
                 session_token = credentials['sessionToken']
                 endpoint = credentials['endpoint']
 
-                session = boto3.Session(aws_access_key_id=access_key, aws_secret_access_key=secret_key, aws_session_token=session_token)
+                session = boto3.Session(aws_access_key_id=access_key, aws_secret_access_key=secret_key,
+                                        aws_session_token=session_token)
                 s3 = session.resource(service_name="s3")
 
                 logger.debug(f"S3 Session: {s3}")
@@ -1834,7 +1883,8 @@ class UploadAPI(AuthenticatedAPI):
 
                 metadata_map = {'Metadata': metadata}
 
-                s3_object.upload_file(path_to_zip_package, Callback=callback, ExtraArgs=metadata_map, Config=transfer_config)
+                s3_object.upload_file(path_to_zip_package, Callback=callback, ExtraArgs=metadata_map,
+                                      Config=transfer_config)
 
                 if delete_after_upload:
                     os.remove(path_to_zip_package)
@@ -1860,7 +1910,8 @@ class UploadAPI(AuthenticatedAPI):
         endpoint = f'{self.protocol}://{self.server}/api/s3/buckets'
         self.token = self.__token__()
 
-        s3_client = boto3.client('s3', endpoint_url=endpoint, aws_access_key_id=self.token, aws_secret_access_key="NOT_USED",
+        s3_client = boto3.client('s3', endpoint_url=endpoint, aws_access_key_id=self.token,
+                                 aws_secret_access_key="NOT_USED",
                                  config=Config(s3={'addressing_style': 'path'}))
 
         metadata = {}
@@ -1880,7 +1931,8 @@ class UploadAPI(AuthenticatedAPI):
                 transfer.CompleteMultipartUploadTask = CompleteMultipartUploadTask
                 transfer.upload_file = upload_file
 
-                response = transfer.upload_file(self=transfer, filename=path_to_zip_package, bucket=bucket, key=key_id, extra_args=metadata,
+                response = transfer.upload_file(self=transfer, filename=path_to_zip_package, bucket=bucket, key=key_id,
+                                                extra_args=metadata,
                                                 callback=callback)
 
                 if delete_after_upload:

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica/workflowAPI.py

@@ -11,6 +11,7 @@ licence:    Apache License 2.0
 
 import uuid
 import datetime
+from typing import Callable
 from xml.etree import ElementTree
 
 from pyPreservica.common import *
@@ -21,7 +22,7 @@ logger = logging.getLogger(__name__)
 class WorkflowInstance:
     """
         Defines a workflow Instance.
-        The workflow Instance is context which has been executed
+        The workflow Instance is a context which has been executed
     """
 
     def __init__(self, instance_id: int):
@@ -79,8 +80,11 @@ class WorkflowAPI(AuthenticatedAPI):
     workflow_types = ['Ingest', 'Access', 'Transformation', 'DataManagement']
 
     def __init__(self, username: str = None, password: str = None, tenant: str = None, server: str = None,
-                 use_shared_secret: bool = False, two_fa_secret_key: str = None, protocol: str = "https"):
-        super().__init__(username, password, tenant, server, use_shared_secret, two_fa_secret_key, protocol)
+                 use_shared_secret: bool = 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)
         self.base_url = "sdb/rest/workflow"
 
     def get_workflow_contexts_by_type(self, workflow_type: str):

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica.egg-info/PKG-INFO

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

{pypreservica-2.7.3 → pypreservica-2.8.0}/pyPreservica.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ tests/test_delete.py
 tests/test_download.py
 tests/test_entity.py
 tests/test_export_opex.py
+tests/test_groups.py
 tests/test_identifier.py
 tests/test_ingest.py
 tests/test_integrity_check.py

{pypreservica-2.7.3 → pypreservica-2.8.0}/setup.py

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

{pypreservica-2.7.3 → pypreservica-2.8.0}/tests/test_crawl_fs.py

@@ -1,7 +1,7 @@
 import pytest
 from pyPreservica import *
 
-
+@pytest.mark.filterwarnings("ignore:datetime.datetime.utcnow")
 def test_crawl_fs():
     path = "./test_data/"
     bucket = "com.preservica.dev.preview.sales.autoupload"

pypreservica-2.8.0/tests/test_groups.py

@@ -0,0 +1,8 @@
+import pytest
+from pyPreservica import *
+
+
+def test_cam_get_all_groups():
+    client = MetadataGroupsAPI()
+    for g in client.groups():
+        assert isinstance(g, Group)

{pypreservica-2.7.3 → pypreservica-2.8.0}/tests/test_ingest.py

@@ -81,7 +81,7 @@ def test_ingest_access_file():
 
     client.delete_asset(asset, "operator comment", "supervisor")
 
-
+@pytest.mark.filterwarnings("ignore:datetime.datetime.utcnow")
 def test_s3_upload():
     client = EntityAPI()
     upload = UploadAPI()

{pypreservica-2.7.3 → pypreservica-2.8.0}/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) == 3
+    assert len(workflows) == 1
 
 
 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) == 8
+    assert len(workflows) == 6
 
     workflows = workflow.get_workflow_contexts_by_type("Access")
     assert len(workflows) == 5

pypreservica-2.7.3/pyPreservica/mdformsAPI.py

@@ -1,100 +0,0 @@
-"""
-pyPreservica MDFormsAPI module definition
-
-A client library for the Preservica Repository web services Metadata API
-https://demo.preservica.com/api/metadata/documentation.html
-
-author:     James Carr
-licence:    Apache License 2.0
-
-"""
-import json
-import xml.etree.ElementTree
-
-from pyPreservica.common import *
-
-
-class MDFormsAPI(AuthenticatedAPI):
-    def __init__(self, username: str = None, password: str = None, tenant: str = None, server: str = None,
-                 use_shared_secret: bool = False, two_fa_secret_key: str = None, protocol: str = "https"):
-        super().__init__(username, password, tenant, server, use_shared_secret, two_fa_secret_key, protocol)
-        xml.etree.ElementTree.register_namespace("oai_dc", "http://www.openarchives.org/OAI/2.0/oai_dc/")
-        xml.etree.ElementTree.register_namespace("ead", "urn:isbn:1-931666-22-9")
-
-    def delete_group(self, id: str):
-        """
-        Delete a group
-        :param id: Group ID
-        :return:
-        """
-        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
-        url = f'{self.protocol}://{self.server}/api/metadata/groups/{id}'
-        with self.session.delete(url, headers=headers) as request:
-            if request.status_code == requests.codes.unauthorized:
-                self.token = self.__token__()
-                return self.delete_group(id)
-            elif request.status_code == requests.codes.no_content:
-                return None
-            else:
-                exception = HTTPException(None, request.status_code, request.url, "delete_group",
-                                          request.content.decode('utf-8'))
-                logger.error(exception)
-                raise exception
-
-    def add_group(self, document):
-        """
-        Add a new group
-        :return:
-        """
-        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
-        url = f'{self.protocol}://{self.server}/api/metadata/groups/'
-        with self.session.post(url, headers=headers, json=document) as request:
-            if request.status_code == requests.codes.unauthorized:
-                self.token = self.__token__()
-                return self.add_group(document)
-            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, "group",
-                                          request.content.decode('utf-8'))
-                logger.error(exception)
-                raise exception
-
-    def group(self, id: str):
-        """
-        Fetch a metadata Group by its id
-        :param id: The group ID
-        :return: JSON Document
-        """
-        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
-        url = f'{self.protocol}://{self.server}/api/metadata/groups/{id}'
-        with self.session.get(url, headers=headers) as request:
-            if request.status_code == requests.codes.unauthorized:
-                self.token = self.__token__()
-                return self.group(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, "group",
-                                          request.content.decode('utf-8'))
-                logger.error(exception)
-                raise exception
-
-    def groups(self):
-        """
-        Fetch all the Metadata Groups as JSON
-        :return: JSON Document
-        """
-        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
-        url = f'{self.protocol}://{self.server}/api/metadata/groups'
-        with self.session.get(url, headers=headers) as request:
-            if request.status_code == requests.codes.unauthorized:
-                self.token = self.__token__()
-                return self.groups()
-            elif request.status_code == requests.codes.ok:
-                return json.loads(str(request.content.decode('utf-8')))['groups']
-            else:
-                exception = HTTPException(None, request.status_code, request.url, "groups",
-                                          request.content.decode('utf-8'))
-                logger.error(exception)
-                raise exception