pyPreservica 2.7.2__py3-none-any.whl → 2.7.3__py3-none-any.whl

pyPreservica/__init__.py

@@ -23,6 +23,6 @@ from .mdformsAPI import MDFormsAPI
 __author__ = "James Carr (drjamescarr@gmail.com)"
 
 # Version of the pyPreservica package
-__version__ = "2.7.2"
+__version__ = "2.7.3"
 
 __license__ = "Apache License Version 2.0"

pyPreservica/uploadAPI.py

@@ -99,8 +99,8 @@ def prettify(elem):
 def __create_io__(xip=None, file_name=None, parent_folder=None, **kwargs):
     if xip is None:
         xip = Element('xip:XIP')
+        xip.set('xmlns:xip', 'http://preservica.com/XIP/v6.0')
     assert xip is not None
-    xip.set('xmlns:xip', 'http://preservica.com/XIP/v6.0')
     io = SubElement(xip, 'xip:InformationObject')
     ref = SubElement(io, 'xip:Ref')
 
@@ -598,12 +598,12 @@ def generic_asset_package(preservation_files_dict=None, access_files_dict=None,
         for identifier_key, identifier_value in identifier_map.items():
             if identifier_key:
                 if identifier_value:
-                    identifier = SubElement(xip, 'Identifier')
-                    id_type = SubElement(identifier, "Type")
+                    identifier = SubElement(xip, 'xip:Identifier')
+                    id_type = SubElement(identifier, "xip:Type")
                     id_type.text = identifier_key
-                    id_value = SubElement(identifier, "Value")
+                    id_value = SubElement(identifier, "xip:Value")
                     id_value.text = identifier_value
-                    id_io = SubElement(identifier, "Entity")
+                    id_io = SubElement(identifier, "xip:Entity")
                     id_io.text = io_ref
 
     if 'Asset_Metadata' in kwargs:
@@ -613,22 +613,22 @@ def generic_asset_package(preservation_files_dict=None, access_files_dict=None,
                 if metadata_path:
                     if os.path.exists(metadata_path) and os.path.isfile(metadata_path):
                         descriptive_metadata = xml.etree.ElementTree.parse(source=metadata_path)
-                        metadata = SubElement(xip, 'Metadata', {'schemaUri': metadata_ns})
-                        metadata_ref = SubElement(metadata, 'Ref')
+                        metadata = SubElement(xip, 'xip:Metadata', {'schemaUri': metadata_ns})
+                        metadata_ref = SubElement(metadata, 'xip:Ref')
                         metadata_ref.text = str(uuid.uuid4())
-                        entity = SubElement(metadata, 'Entity')
+                        entity = SubElement(metadata, 'xip:Entity')
                         entity.text = io_ref
-                        content = SubElement(metadata, 'Content')
+                        content = SubElement(metadata, 'xip:Content')
                         content.append(descriptive_metadata.getroot())
                     elif isinstance(metadata_path, str):
                         try:
                             descriptive_metadata = xml.etree.ElementTree.fromstring(metadata_path)
-                            metadata = SubElement(xip, 'Metadata', {'schemaUri': metadata_ns})
-                            metadata_ref = SubElement(metadata, 'Ref')
+                            metadata = SubElement(xip, 'xip:Metadata', {'schemaUri': metadata_ns})
+                            metadata_ref = SubElement(metadata, 'xip:Ref')
                             metadata_ref.text = str(uuid.uuid4())
-                            entity = SubElement(metadata, 'Entity')
+                            entity = SubElement(metadata, 'xip:Entity')
                             entity.text = io_ref
-                            content = SubElement(metadata, 'Content')
+                            content = SubElement(metadata, 'xip:Content')
                             content.append(descriptive_metadata)
                         except RuntimeError:
                             logging.info(f"Could not parse asset metadata in namespace {metadata_ns}")
@@ -712,71 +712,72 @@ def multi_asset_package(asset_file_list=None, export_folder=None, parent_folder=
     os.mkdir(os.path.join(inner_folder, CONTENT_FOLDER))
 
     asset_map = dict()
-    xip = Element('XIP')
+    xip = Element('xip:XIP')
+    xip.set('xmlns:xip', 'http://preservica.com/XIP/v6.0')
     for file in asset_file_list:
         default_asset_title = os.path.splitext(os.path.basename(file))[0]
         xip, io_ref = __create_io__(xip, file_name=default_asset_title, parent_folder=parent_folder, **kwargs)
         asset_map[file] = io_ref
-        representation = SubElement(xip, 'Representation')
-        io_link = SubElement(representation, 'InformationObject')
+        representation = SubElement(xip, 'xip:Representation')
+        io_link = SubElement(representation, 'xip:InformationObject')
         io_link.text = io_ref
-        access_name = SubElement(representation, 'Name')
+        access_name = SubElement(representation, 'xip:Name')
         access_name.text = "Preservation"
-        access_type = SubElement(representation, 'Type')
+        access_type = SubElement(representation, 'xip:Type')
         access_type.text = "Preservation"
-        content_objects = SubElement(representation, 'ContentObjects')
-        content_object = SubElement(content_objects, 'ContentObject')
+        content_objects = SubElement(representation, 'xip:ContentObjects')
+        content_object = SubElement(content_objects, 'xip:ContentObject')
         content_object_ref = str(uuid.uuid4())
         content_object.text = content_object_ref
 
         default_content_objects_title = os.path.splitext(os.path.basename(file))[0]
-        content_object = SubElement(xip, 'ContentObject')
-        ref_element = SubElement(content_object, "Ref")
+        content_object = SubElement(xip, 'xip:ContentObject')
+        ref_element = SubElement(content_object, "xip:Ref")
         ref_element.text = content_object_ref
-        title = SubElement(content_object, "Title")
+        title = SubElement(content_object, "xip:Title")
         title.text = default_content_objects_title
-        description = SubElement(content_object, "Description")
+        description = SubElement(content_object, "xip:Description")
         description.text = default_content_objects_title
-        security_tag_element = SubElement(content_object, "SecurityTag")
+        security_tag_element = SubElement(content_object, "xip:SecurityTag")
         security_tag_element.text = security_tag
-        custom_type = SubElement(content_object, "CustomType")
+        custom_type = SubElement(content_object, "xip:CustomType")
         custom_type.text = content_type
-        parent = SubElement(content_object, "Parent")
+        parent = SubElement(content_object, "xip:Parent")
         parent.text = io_ref
 
-        generation = SubElement(xip, 'Generation', {"original": "true", "active": "true"})
-        content_object = SubElement(generation, "ContentObject")
+        generation = SubElement(xip, 'xip:Generation', {"original": "true", "active": "true"})
+        content_object = SubElement(generation, "xip:ContentObject")
         content_object.text = content_object_ref
-        label = SubElement(generation, "Label")
+        label = SubElement(generation, "xip:Label")
         label.text = os.path.splitext(os.path.basename(file))[0]
-        effective_date = SubElement(generation, "EffectiveDate")
+        effective_date = SubElement(generation, "xip:EffectiveDate")
         effective_date.text = datetime.now().isoformat()
-        bitstreams = SubElement(generation, "Bitstreams")
-        bitstream = SubElement(bitstreams, "Bitstream")
+        bitstreams = SubElement(generation, "xip:Bitstreams")
+        bitstream = SubElement(bitstreams, "xip:Bitstream")
         bitstream.text = os.path.basename(file)
-        SubElement(generation, "Formats")
-        SubElement(generation, "Properties")
+        SubElement(generation, "xip:Formats")
+        SubElement(generation, "xip:Properties")
 
-        bitstream = SubElement(xip, 'Bitstream')
-        filename_element = SubElement(bitstream, "Filename")
+        bitstream = SubElement(xip, 'xip:Bitstream')
+        filename_element = SubElement(bitstream, "xip:Filename")
         filename_element.text = os.path.basename(file)
-        filesize = SubElement(bitstream, "FileSize")
+        filesize = SubElement(bitstream, "xip:FileSize")
         file_stats = os.stat(file)
         filesize.text = str(file_stats.st_size)
-        physical_location = SubElement(bitstream, "PhysicalLocation")
-        fixities = SubElement(bitstream, "Fixities")
+        physical_location = SubElement(bitstream, "xip:PhysicalLocation")
+        fixities = SubElement(bitstream, "xip:Fixities")
         fixity_result = fixity_callback(filename_element.text, file)
         if type(fixity_result) == tuple:
-            fixity = SubElement(fixities, "Fixity")
-            fixity_algorithm_ref = SubElement(fixity, "FixityAlgorithmRef")
-            fixity_value = SubElement(fixity, "FixityValue")
+            fixity = SubElement(fixities, "xip:Fixity")
+            fixity_algorithm_ref = SubElement(fixity, "xip:FixityAlgorithmRef")
+            fixity_value = SubElement(fixity, "xip:FixityValue")
             fixity_algorithm_ref.text = fixity_result[0]
             fixity_value.text = fixity_result[1]
         elif type(fixity_result) == dict:
             for key, val in fixity_result.items():
-                fixity = SubElement(fixities, "Fixity")
-                fixity_algorithm_ref = SubElement(fixity, "FixityAlgorithmRef")
-                fixity_value = SubElement(fixity, "FixityValue")
+                fixity = SubElement(fixities, "xip:Fixity")
+                fixity_algorithm_ref = SubElement(fixity, "xip:FixityAlgorithmRef")
+                fixity_value = SubElement(fixity, "xip:FixityValue")
                 fixity_algorithm_ref.text = key
                 fixity_value.text = val
         else:
@@ -790,12 +791,12 @@ def multi_asset_package(asset_file_list=None, export_folder=None, parent_folder=
                 for identifier_key, identifier_value in identifier_map_values.items():
                     if identifier_key:
                         if identifier_value:
-                            identifier = SubElement(xip, 'Identifier')
-                            id_type = SubElement(identifier, "Type")
+                            identifier = SubElement(xip, 'xip:Identifier')
+                            id_type = SubElement(identifier, "xip:Type")
                             id_type.text = identifier_key
-                            id_value = SubElement(identifier, "Value")
+                            id_value = SubElement(identifier, "xip:Value")
                             id_value.text = identifier_value
-                            id_io = SubElement(identifier, "Entity")
+                            id_io = SubElement(identifier, "xip:Entity")
                             id_io.text = io_ref
 
         src_file = file

pyPreservica/workflowAPI.py

@@ -245,13 +245,13 @@ class WorkflowAPI(AuthenticatedAPI):
             assert instance_id == w_id
             workflow_instance = WorkflowInstance(int(instance_id))
             started_element = entity_response.find(f".//{{{NS_WORKFLOW}}}Started")
-            if started_element:
+            if started_element is not None:
                 if hasattr(started_element, "text"):
                     workflow_instance.started = datetime.datetime.strptime(started_element.text,
                                                                            '%Y-%m-%dT%H:%M:%S.%fZ')
 
             finished_element = entity_response.find(f".//{{{NS_WORKFLOW}}}Finished")
-            if finished_element:
+            if finished_element is not None:
                 if hasattr(finished_element, "text"):
                     workflow_instance.finished = datetime.datetime.strptime(finished_element.text,
                                                                             '%Y-%m-%dT%H:%M:%S.%fZ')
@@ -353,13 +353,13 @@ class WorkflowAPI(AuthenticatedAPI):
                 workflow_instance = WorkflowInstance(int(instance_id))
 
                 started_element = instance.find(f".//{{{NS_WORKFLOW}}}Started")
-                if started_element:
+                if started_element is not None:
                     if hasattr(started_element, "text"):
                         workflow_instance.started = datetime.datetime.strptime(started_element.text,
                                                                                '%Y-%m-%dT%H:%M:%S.%fZ')
 
                 finished_element = instance.find(f".//{{{NS_WORKFLOW}}}Finished")
-                if finished_element:
+                if finished_element is not None:
                     if hasattr(finished_element, "text"):
                         workflow_instance.finished = datetime.datetime.strptime(finished_element.text,
                                                                                 '%Y-%m-%dT%H:%M:%S.%fZ')

{pyPreservica-2.7.2.dist-info → pyPreservica-2.7.3.dist-info}/METADATA

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

{pyPreservica-2.7.2.dist-info → pyPreservica-2.7.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyPreservica/__init__.py,sha256=7niGhdk2fS4pMgHaqr-x-oZMJQg5-Nte_jfMNxZ3Lkk,1117
+pyPreservica/__init__.py,sha256=P43ePSmYs5TNWNeovJk4fDofqeOnOMPORRNB7U_1XQw,1117
 pyPreservica/adminAPI.py,sha256=511bc5KtrCAXbDyBk39dmDnxUVDaOu6xaiyu0jYhxa4,37781
 pyPreservica/authorityAPI.py,sha256=Eule8g6LXr8c8SFcJgpRah4lH1FgevUItO5HhHDEaZE,9172
 pyPreservica/common.py,sha256=upTmwvPK9kcgSO3L8mfIMVrCOWJCCYIHi5GK516jOok,36518
@@ -9,12 +9,11 @@ pyPreservica/monitorAPI.py,sha256=HD-PUPdSI9wGAa07e2_2_-FLINH8PoWUwpFogz7F-j4,62
 pyPreservica/opex.py,sha256=ccra1S4ojUXS3PlbU8WfxajOkJrwG4OykBnNrYP_jus,4875
 pyPreservica/parAPI.py,sha256=bgaQvYfWNnzdD7ibKMV3ZV85pNkEdSoLsgVigoiFFfw,10771
 pyPreservica/retentionAPI.py,sha256=Cx1ofz9V31a8c8utEfKYLlfQaHSaaqg_D4R3LUFBEx0,23612
-pyPreservica/uploadAPI.py,sha256=8GCQlofg-fxJEY_djeValbVwBZoTBujJEDFxpS_fEkQ,93894
-pyPreservica/vocabularyAPI.py,sha256=jPl6KDZoBGqlY0oEYjTpZ9kNEPzchDW-gyp-HH-MSKk,5729
+pyPreservica/uploadAPI.py,sha256=4-WFkIYH825sO3Eche-35VVod7JLylzq8cTdaxPPpMo,94154
 pyPreservica/webHooksAPI.py,sha256=0wP-59mep8gtlIZ9P5vV68-HnNdTuuo2kzGcDWj0bNg,6790
-pyPreservica/workflowAPI.py,sha256=ENFWxcuPW5WX9jG2CAha6UzTywULWvosgTUVsmvs8f8,17323
-pyPreservica-2.7.2.dist-info/LICENSE.txt,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-pyPreservica-2.7.2.dist-info/METADATA,sha256=GDQ2AtPbqDpmjxUGGIwq-8EIoOXkz_fsxwkpMf68TDc,2784
-pyPreservica-2.7.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyPreservica-2.7.2.dist-info/top_level.txt,sha256=iIBh6NAznYQHOV8mv_y_kGKSDITek9rANyFDwJsbU-c,13
-pyPreservica-2.7.2.dist-info/RECORD,,
+pyPreservica/workflowAPI.py,sha256=WprAIqq_iLFZWB20CEhH30f3b9_lv_C4_3HP6cEFa6s,17371
+pyPreservica-2.7.3.dist-info/LICENSE.txt,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+pyPreservica-2.7.3.dist-info/METADATA,sha256=yr3jrAmSy5J1nMluuhSlqtwDz_BSlgb8TUgGs1cTmwA,2784
+pyPreservica-2.7.3.dist-info/WHEEL,sha256=YiKiUUeZQGmGJoR_0N1Y933DOBowq4AIvDe2-UIy8E4,91
+pyPreservica-2.7.3.dist-info/top_level.txt,sha256=iIBh6NAznYQHOV8mv_y_kGKSDITek9rANyFDwJsbU-c,13
+pyPreservica-2.7.3.dist-info/RECORD,,

{pyPreservica-2.7.2.dist-info → pyPreservica-2.7.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: setuptools (71.0.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyPreservica/vocabularyAPI.py

@@ -1,141 +0,0 @@
-"""
-pyPreservica ControlledVocabularyAPI module definition
-
-A client library for the Preservica Repository web services Webhook API
-https://us.preservica.com/api/reference-metadata/documentation.html
-
-author:     James Carr
-licence:    Apache License 2.0
-
-"""
-
-from pyPreservica.common import *
-
-logger = logging.getLogger(__name__)
-
-BASE_ENDPOINT = '/api/reference-metadata'
-
-
-class Table:
-    def __init__(self, reference: str, name: str, security_tag: str, displayField: str, metadataConnections: list):
-        self.reference = reference
-        self.name = name
-        self.security_tag = security_tag
-        self.displayField = displayField
-        self.metadataConnections = metadataConnections
-        self.fields = None
-
-    def __str__(self):
-        return f"Ref:\t\t\t{self.reference}\n" \
-               f"Name:\t\t\t{self.name}\n" \
-               f"Security Tag:\t{self.security_tag}\n" \
-               f"Display Field:\t\t\t{self.displayField}\n" \
-               f"Metadata Connections:\t\t\t{self.metadataConnections}\n" \
-               f"Fields:\t\t\t{self.fields}\n"
-
-
-class ControlledVocabularyAPI(AuthenticatedAPI):
-
-
-    def load_skos(self, uri):
-        """
-        Load a SKOS controlled vocabulary in skos RDF format
-
-        Simple Knowledge Organization System (SKOS)
-
-        :param uri:
-        :return:
-        """
-        pass
-
-    def record(self, reference: str):
-        """
-        Get individual record by its ref.
-        :param reference:
-        :return:
-        """
-        headers = {HEADER_TOKEN: self.token, 'accept': 'application/json;charset=UTF-8'}
-        response = self.session.get(f'{self.protocol}://{self.server}{BASE_ENDPOINT}/records/{reference}',
-                                    headers=headers)
-        if response.status_code == requests.codes.unauthorized:
-            self.token = self.__token__()
-            return self.record(reference)
-        if response.status_code == requests.codes.ok:
-            json_response = str(response.content.decode('utf-8'))
-            return json.loads(json_response)
-        else:
-            exception = HTTPException("", response.status_code, response.url, "record",
-                                      response.content.decode('utf-8'))
-            logger.error(exception)
-            raise exception
-
-    def records(self, table: Table):
-        """
-        Get all records from a table.
-        :return:
-        """
-        headers = {HEADER_TOKEN: self.token, 'accept': 'application/json;charset=UTF-8'}
-        response = self.session.get(f'{self.protocol}://{self.server}{BASE_ENDPOINT}/tables/{table.reference}/records',
-                                    headers=headers)
-        if response.status_code == requests.codes.unauthorized:
-            self.token = self.__token__()
-            return self.records(table)
-        if response.status_code == requests.codes.ok:
-            json_response = str(response.content.decode('utf-8'))
-            return json.loads(json_response)['records']
-        else:
-            exception = HTTPException("", response.status_code, response.url, "records",
-                                      response.content.decode('utf-8'))
-            logger.error(exception)
-            raise exception
-
-    def table(self, reference: str):
-        """
-        fetch a metadata table by id
-
-        :param reference:
-        :return:
-        """
-        headers = {HEADER_TOKEN: self.token, 'accept': 'application/json;charset=UTF-8'}
-        response = self.session.get(f'{self.protocol}://{self.server}{BASE_ENDPOINT}/tables/{reference}',
-                                    headers=headers)
-        if response.status_code == requests.codes.unauthorized:
-            self.token = self.__token__()
-            return self.table(reference)
-        if response.status_code == requests.codes.ok:
-            json_response = str(response.content.decode('utf-8'))
-            doc = json.loads(json_response)
-            table = Table(doc['ref'], doc['name'], doc['securityDescriptor'], doc['displayField'],
-                          doc['metadataConnections'])
-            table.fields = doc['fields']
-            return table
-        else:
-            exception = HTTPException("", response.status_code, response.url, "table",
-                                      response.content.decode('utf-8'))
-            logger.error(exception)
-            raise exception
-
-    def tables(self):
-        """
-        List reference metadata tables, optionally filtering by metadata connections.
-        :return:
-        """
-        headers = {HEADER_TOKEN: self.token, 'accept': 'application/json;charset=UTF-8'}
-        response = self.session.get(f'{self.protocol}://{self.server}{BASE_ENDPOINT}/tables', headers=headers)
-        if response.status_code == requests.codes.unauthorized:
-            self.token = self.__token__()
-            return self.tables()
-        if response.status_code == requests.codes.ok:
-            json_response = str(response.content.decode('utf-8'))
-            doc = json.loads(json_response)
-            results = set()
-            for table in doc['tables']:
-                t = Table(table['ref'], table['name'], table['securityDescriptor'], table['displayField'],
-                          table['metadataConnections'])
-                results.add(t)
-            return results
-        else:
-            exception = HTTPException("", response.status_code, response.url, "tables",
-                                      response.content.decode('utf-8'))
-            logger.error(exception)
-            raise exception