pyPreservica 3.0.6__tar.gz → 3.2.0__tar.gz

{pypreservica-3.0.6 → pypreservica-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyPreservica
-Version: 3.0.6
+Version: 3.2.0
 Summary: Python library for the Preservica API
 Home-page: https://pypreservica.readthedocs.io/
 Author: James Carr
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: System :: Archiving
 Description-Content-Type: text/markdown
@@ -39,6 +38,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: summary

{pypreservica-3.0.6 → pypreservica-3.2.0}/pyPreservica/__init__.py

@@ -30,10 +30,11 @@ from .monitorAPI import MonitorAPI, MonitorCategory, MonitorStatus, MessageStatu
 from .webHooksAPI import WebHooksAPI, TriggerType, WebHookHandler
 from .authorityAPI import AuthorityAPI, Table
 from .mdformsAPI import MetadataGroupsAPI, Group, GroupField, GroupFieldType
+from .settingsAPI import SettingsAPI
 
 __author__ = "James Carr (drjamescarr@gmail.com)"
 
 # Version of the pyPreservica package
-__version__ = "3.0.6"
+__version__ = "3.2.0"
 
 __license__ = "Apache License Version 2.0"

{pypreservica-3.0.6 → pypreservica-3.2.0}/pyPreservica/common.py

@@ -853,6 +853,7 @@ class AuthenticatedAPI:
                         if self.tenant is None:
                             self.tenant = response.json()['tenant']
                         if self.two_fa_secret_key:
+                            logger.debug("Found Two Factor Token")
                             totp = pyotp.TOTP(self.two_fa_secret_key)
                             data = {'username': self.username,
                                     'continuationToken': response.json()['continuationToken'],
@@ -865,8 +866,8 @@ class AuthenticatedAPI:
                             else:
                                 msg = "Failed to create a 2FA authentication token. Check your credentials are correct"
                                 logger.error(msg)
-                                logger.error(str(response.content))
-                                raise RuntimeError(response.status_code, msg)
+                                logger.error(str(response_2fa.content))
+                                raise RuntimeError(response_2fa.status_code, msg)
                         else:
                             msg = "2FA twoFactorToken required to authenticate against this account using 2FA"
                             logger.error(msg)

{pypreservica-3.0.6 → pypreservica-3.2.0}/pyPreservica/contentAPI.py

@@ -34,6 +34,11 @@ class Field:
 
 
 class ContentAPI(AuthenticatedAPI):
+    """
+        The ContentAPI class provides the search interface to the Preservica repository.
+
+    """
+
 
     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,

{pypreservica-3.0.6 → pypreservica-3.2.0}/pyPreservica/entityAPI.py

@@ -918,7 +918,7 @@ class EntityAPI(AuthenticatedAPI):
                     content.append(tree.getroot())
                 else:
                     raise RuntimeError("Unknown data type")
-                xml_request = xml.etree.ElementTree.tostring(xml_object, encoding='utf-8')
+                xml_request = xml.etree.ElementTree.tostring(xml_object, encoding='utf-8').decode("utf-8")
                 logger.debug(xml_request)
                 request = self.session.put(url, data=xml_request, headers=headers)
                 if request.status_code == requests.codes.ok:
@@ -933,6 +933,43 @@ class EntityAPI(AuthenticatedAPI):
                     raise exception
         return self.entity(entity.entity_type, entity.reference)
 
+    def add_metadata_as_fragment(self, entity: Entity, schema: str, xml_fragment: str) -> Entity:
+        """
+        Add a metadata fragment with a given namespace URI to an Entity
+
+        Don't parse the xml fragment which may add extra namespaces etc
+
+        Returns The updated Entity
+
+        :param xml_fragment:  The new XML as a string
+        :param entity: The Entity to update
+        :param schema: The schema URI of the XML document
+        """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/xml;charset=UTF-8'}
+
+        xml_doc = f"""<xip:MetadataContainer xmlns="{schema}" schemaUri="{schema}" xmlns:xip="{self.xip_ns}">
+            <xip:Entity>{entity.reference}</xip:Entity>
+                <xip:Content>
+                   {xml_fragment}
+                </xip:Content>
+            </xip:MetadataContainer>"""
+
+        end_point = f"/{entity.path}/{entity.reference}/metadata"
+        logger.debug(xml_doc)
+        request = self.session.post(f'{self.protocol}://{self.server}/api/entity{end_point}', data=xml_doc,
+                                    headers=headers)
+        if request.status_code == requests.codes.ok:
+            return self.entity(entity_type=entity.entity_type, reference=entity.reference)
+        elif request.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            return self.add_metadata(entity, schema, xml_fragment)
+        else:
+            exception = HTTPException(entity.reference, request.status_code, request.url, "add_metadata",
+                                      request.content.decode('utf-8'))
+            logger.error(exception)
+            raise exception
+
+
     def add_metadata(self, entity: Entity, schema: str, data) -> Entity:
         """
         Add a metadata fragment with a given namespace URI
@@ -960,6 +997,7 @@ 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:
@@ -2126,9 +2164,15 @@ class EntityAPI(AuthenticatedAPI):
             actions = entity_response.findall(f'.//{{{self.xip_ns}}}EventAction')
             result_list = []
             for action in actions:
-                entity_ref = action.findall(f'.//{{{self.xip_ns}}}Entity')
-                for refs in entity_ref:
-                    result_list.append(refs.text)
+                item: dict = {}
+                event = action.find(f'.//{{{self.xip_ns}}}Event')
+                event_type = event.attrib["type"]
+                item['EventType'] = event_type
+                entity_date = action.find(f'.//{{{self.xip_ns}}}Date')
+                item['Date'] = entity_date.text
+                entity_ref = action.find(f'.//{{{self.xip_ns}}}Entity')
+                item['Entity'] = entity_ref.text
+                result_list.append(item)
             next_url = entity_response.find(f'.//{{{self.entity_ns}}}Next')
             total_hits = entity_response.find(f'.//{{{self.entity_ns}}}TotalResults')
             has_more = True
@@ -2162,6 +2206,9 @@ class EntityAPI(AuthenticatedAPI):
             params["from"] = kwargs.get("from_date")
         if "to_date" in kwargs:
             params["to"] = kwargs.get("to_date")
+        if "username" in kwargs:
+            params["username"] = kwargs.get("username")
+
 
         if next_page is None:
             request = self.session.get(f'{self.protocol}://{self.server}/api/entity/events', params=params,

pypreservica-3.2.0/pyPreservica/settingsAPI.py

@@ -0,0 +1,295 @@
+"""
+pyPreservica Settings API  module definition
+
+API for retrieving information about configuration settings.
+
+author:     James Carr
+licence:    Apache License 2.0
+
+"""
+
+from typing import Callable
+
+from pyPreservica.common import *
+
+logger = logging.getLogger(__name__)
+
+
+class SettingsAPI(AuthenticatedAPI):
+    """
+    API for retrieving information about configuration settings.
+
+    Includes  methods for:
+
+    *  metadata-enrichment
+
+    """
+
+    def __init__(
+        self,
+        username=None,
+        password=None,
+        tenant=None,
+        server=None,
+        use_shared_secret=False,
+        two_fa_secret_key: str = None,
+        protocol: str = "https",
+        request_hook: Callable = None,
+        credentials_path: str = "credentials.properties",
+    ):
+        super().__init__(
+            username,
+            password,
+            tenant,
+            server,
+            use_shared_secret,
+            two_fa_secret_key,
+            protocol,
+            request_hook,
+            credentials_path,
+        )
+
+        if self.major_version < 7 and self.minor_version < 7:
+            raise RuntimeError(
+                "Settings API is only available when connected to a v7.7 System or higher"
+            )
+
+        self.base_url = "api/settings"
+
+    def metadata_enrichment_rules(self, profile_id: str = None) -> dict:
+        """
+        Returns a list of metadata enrichment rules.
+        An empty selection implies that the rule is applied to all content.
+        Rules define where particular behaviours, defined by profiles, will be applied.
+        Rules are evaluated in order, with the first matching rule being applied.
+
+        :param profile_id: The rules for a specific profile id, Set to None for all rules
+        :type profile_id: str
+
+        """
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Accept": "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+
+        endpoint: str = "/metadata-enrichment/config/rules"
+
+        request = self.session.get(
+            f"{self.protocol}://{self.server}/{self.base_url}{endpoint}",
+            headers=headers)
+
+        if request.status_code == requests.codes.ok:
+            rules: dict = json.loads(request.content.decode("utf-8"))
+            if profile_id is None:
+                return rules
+            else:
+                profile_rules = []
+                for rule in rules["rules"]:
+                    if rule["profileId"] == profile_id:
+                        profile_rules.append(rule)
+                return {"rules": profile_rules}
+        else:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(request.status_code, f"metadata_enrichment_rules failed")
+
+    def metadata_enrichment_delete_rule(self, rule_id: str):
+        """
+        Deletes a metadata enrichment rule.
+
+        :param rule_id: The rule id
+        :type rule_id: str
+
+        :return: No return value
+        :rtype: None
+
+        """
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Accept": "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+
+        endpoint: str = f"/metadata-enrichment/config/rules/{rule_id}"
+
+        request = self.session.delete(
+            f"{self.protocol}://{self.server}/{self.base_url}{endpoint}", headers=headers)
+
+        if request.status_code == requests.codes.no_content:
+            return
+        else:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(request.status_code, f"metadata_enrichment_delete_rule failed")
+
+    def metadata_enrichment_add_rule(self, profile_id: str, priority: int = 1):
+        """
+        Create a metadata enrichment rule to control when metadata enrichment profiles are applied and return it.
+        Rules define where particular behaviours, defined by profiles, will be applied.
+        Rules are evaluated in order, with the first matching rule being applied.
+        Note that not specifying, or specifying an empty selection implies that the rule will be applied to all content.
+        Currently only securityDescriptorSelector, representationSelector and hierarchySelector are supported selectors.
+        If a rule already exists for the requested priority, existing rules will be shifted down priority to accommodate the new entry.
+
+        :param profile_id: The profile id
+        :type profile_id: str
+
+        :param priority: The rule priority
+        :type priority: int
+
+        :return: The metadata enrichment rule
+        :rtype: dict
+        """
+
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Accept": "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+
+        endpoint: str = "/metadata-enrichment/config/rules"
+
+        rule: dict = {
+            "profileId": profile_id,
+            "priority": str(priority),
+            "selectorSettings": {},
+        }
+
+        request = self.session.post(
+            f"{self.protocol}://{self.server}/{self.base_url}/{endpoint}",
+            headers=headers,
+            json=rule,
+        )
+        if request.status_code == requests.codes.created:
+            return json.loads(request.content.decode("utf-8"))
+        else:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(
+                request.status_code, f"metadata_enrichment_add_rule failed"
+            )
+
+    def metadata_enrichment_add_profile(self, name: str, active: bool = True):
+        """
+        Create a metadata enrichment profile to control automatic metadata enrichment of content and return it.
+        Profiles define a set of behaviours that will be applied when the profile is selected by a rule.
+        A profile has no effect if it is not used by a rule. Includes settings for PII identification.
+        PII detection tools may be run against the full text extracted from content.
+
+
+        :param name: The profile name
+        :type name: str
+
+        :param active: The profile active status
+        :type active: bool
+
+        :return: The metadata enrichment profile
+        :rtype: dict
+
+        """
+
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Accept": "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+
+        endpoint: str = "/metadata-enrichment/config/profiles"
+
+        profile: dict = {"name": name, "piiSettings": {"active": str(active).lower()}}
+
+        request = self.session.post(
+            f"{self.protocol}://{self.server}/{self.base_url}{endpoint}",
+            headers=headers, json=profile)
+
+        if request.status_code == requests.codes.created:
+            return json.loads(request.content.decode("utf-8"))
+        else:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(request.status_code, f"metadata_enrichment_add_profile failed")
+
+    def metadata_enrichment_profile(self, profile_id: str) -> dict:
+        """
+        Returns a single profile by its ID
+        Profiles define a set of behaviours that will be applied when the profile is selected by a rule.
+        A profile has no effect if it is not used by a rule. Includes settings for PII identification.
+        PII detection tools may be run against the full text extracted from content.
+
+        :param profile_id: The profile name
+        :type profile_id: str
+
+        :return: The metadata enrichment profile
+        :rtype: dict
+
+        """
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Accept": "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+
+        endpoint: str = f"/metadata-enrichment/config/profiles/{profile_id}"
+
+        request = self.session.get(
+            f"{self.protocol}://{self.server}/{self.base_url}{endpoint}", headers=headers)
+
+        if request.status_code == requests.codes.ok:
+            return json.loads(request.content.decode("utf-8"))
+        else:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(request.status_code, f"metadata_enrichment_profile failed")
+
+    def metadata_enrichment_delete_profile(self, profile_id: str) -> None:
+        """
+        Deletes a metadata enrichment profile
+
+        :param profile_id: The profile name
+        :type profile_id: str
+
+        :return: No return value
+        :rtype: None
+
+        """
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Accept": "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+
+        endpoint: str = f"/metadata-enrichment/config/profiles/{profile_id}"
+
+        request = self.session.delete(
+            f"{self.protocol}://{self.server}/{self.base_url}{endpoint}", headers=headers)
+
+        if request.status_code == requests.codes.forbidden:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(request.status_code, f"Can't delete a profile with rules assigned")
+
+        if request.status_code == requests.codes.no_content:
+            return
+        else:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(request.status_code, f"metadata_enrichment_delete_profile failed")
+
+    def metadata_enrichment_profiles(self) -> dict:
+        """
+        Returns the list of all metadata enrichment profiles.
+        Profiles define a set of behaviours that will be applied when the profile is selected by a rule.
+        A profile has no effect if it is not used by a rule. Includes settings for PII identification.
+        PII detection tools may be run against the full text extracted from content.
+        """
+
+        headers = {
+            HEADER_TOKEN: self.token,
+            "Accept": "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+
+        endpoint: str = "/metadata-enrichment/config/profiles"
+
+        request = self.session.get(
+            f"{self.protocol}://{self.server}/{self.base_url}{endpoint}", headers=headers)
+
+        if request.status_code == requests.codes.ok:
+            return json.loads(request.content.decode("utf-8"))
+        else:
+            logger.debug(request.content.decode("utf-8"))
+            raise RuntimeError(request.status_code, f"metadata_enrichment_profiles failed")

{pypreservica-3.0.6 → pypreservica-3.2.0}/pyPreservica/uploadAPI.py

@@ -911,17 +911,22 @@ def complex_asset_package(preservation_files_list=None, access_files_list=None,
     if has_preservation_files:
         if default_asset_title is None:
             default_asset_title = os.path.splitext(os.path.basename(preservation_files_list[0]))[0]
-
         # create the asset
-        xip, io_ref = __create_io__(file_name=default_asset_title, parent_folder=parent_folder, **kwargs)
+        if io_ref is None:
+            xip, io_ref = __create_io__(file_name=default_asset_title, parent_folder=parent_folder, **kwargs)
 
     if has_access_files:
         if default_asset_title is None:
             default_asset_title = os.path.splitext(os.path.basename(access_files_list[0]))[0]
-
         if io_ref is None:
             xip, io_ref = __create_io__(file_name=default_asset_title, parent_folder=parent_folder, **kwargs)
 
+    if io_ref is None:
+        default_asset_title = kwargs.get('Title', None)
+        if default_asset_title is None:
+            default_asset_title = "New Asset"
+        xip, io_ref = __create_io__(file_name=default_asset_title, parent_folder=parent_folder, **kwargs)
+
     if has_preservation_files:
         # add the content objects
         representation_name = kwargs.get('Preservation_Representation_Name', "Preservation")

{pypreservica-3.0.6 → pypreservica-3.2.0}/pyPreservica.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyPreservica
-Version: 3.0.6
+Version: 3.2.0
 Summary: Python library for the Preservica API
 Home-page: https://pypreservica.readthedocs.io/
 Author: James Carr
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: System :: Archiving
 Description-Content-Type: text/markdown
@@ -39,6 +38,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: summary

{pypreservica-3.0.6 → pypreservica-3.2.0}/pyPreservica.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ pyPreservica/monitorAPI.py
 pyPreservica/opex.py
 pyPreservica/parAPI.py
 pyPreservica/retentionAPI.py
+pyPreservica/settingsAPI.py
 pyPreservica/uploadAPI.py
 pyPreservica/webHooksAPI.py
 pyPreservica/workflowAPI.py
@@ -39,6 +40,7 @@ tests/test_replace.py
 tests/test_retention.py
 tests/test_schema.py
 tests/test_security.py
+tests/test_settings.py
 tests/test_thumbnail.py
 tests/test_upload.py
 tests/test_users.py

{pypreservica-3.0.6 → pypreservica-3.2.0}/setup.py

@@ -21,7 +21,7 @@ if sys.argv[-1] == 'publish':
 # This call to setup() does all the work
 setup(
     name=PKG,
-    version="3.0.6",
+    version="3.2.0",
     description="Python library for the Preservica API",
     long_description=README,
     long_description_content_type="text/markdown",
@@ -37,7 +37,6 @@ setup(
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
-        "License :: OSI Approved :: Apache Software License",
         "Operating System :: OS Independent",
         "Topic :: System :: Archiving",
     ],

{pypreservica-3.0.6 → pypreservica-3.2.0}/tests/test_content_api.py

@@ -84,7 +84,7 @@ def test_simple_search_list(setup_data):
     client = ContentAPI()
     results = list(client.simple_search_list(query="pyPreservica"))
     assert len(results) == 5
-    assert results.pop()['xip.reference'] == '9fd239eb-19a3-4a46-9495-40fd9a5d8f93'
+    assert results.pop()['xip.reference'] == '7fbeba9f-8067-46d9-bb00-8c8c7b3b0475'
 
 
 def test_simple_search_list2(setup_data):
@@ -94,7 +94,7 @@ def test_simple_search_list2(setup_data):
 
     results = list(client.simple_search_list("pyPreservica", 25, columns))
     assert len(results) == 5
-    assert results.pop()['xip.reference'] == '9fd239eb-19a3-4a46-9495-40fd9a5d8f93'
+    assert results.pop()['xip.reference'] == '7fbeba9f-8067-46d9-bb00-8c8c7b3b0475'
 
 
 def test_field_search(setup_data):

{pypreservica-3.0.6 → pypreservica-3.2.0}/tests/test_metadata.py

@@ -9,14 +9,25 @@ from pyPreservica import *
 
 FOLDER_ID = "ebd977f6-bebd-4ecf-99be-e054989f9af4"
 ASSET_ID = "683f9db7-ff81-4859-9c03-f68cfa5d9c3d"
-CO_ID = "0f2997f7-728c-4e55-9f92-381ed1260d70"
-
-XML_DOCUMENT = "<person:Person  xmlns:person='https://www.person.com/person'>" \
-               "<person:Name>Name</person:Name>" \
-               "<person:Phone>01234 100 100</person:Phone>" \
-               "<person:Email>test@test.com</person:Email>" \
-               "<person:Address>Abingdon, UK</person:Address>" \
-               "</person:Person>"
+CO_ID =  "0f2997f7-728c-4e55-9f92-381ed1260d70"
+
+XML_DOCUMENT = """
+               <person:Person  xmlns:person="https://www.person.com/person">
+                   <person:Name>Name</person:Name>
+                   <person:Phone>01234 100 100</person:Phone>
+                   <person:Email>test@test.com</person:Email>
+                   <person:Address>Abingdon, UK</person:Address>
+               </person:Person>
+"""
+
+XML_DOCUMENT_NO_PREFIX = """
+               <Person xmlns="https://www.person.com/person">
+                   <Name>Name</Name>
+                   <Phone>01234 100 100</Phone>
+                   <Email>test@test.com</Email>
+                   <Address>Abingdon, UK</Address>
+               </Person>
+"""
 
 
 def test_get_folder_metadata():
@@ -50,6 +61,28 @@ def test_update_folder_metadata():
     folder = client.update_metadata(entity, "http://purl.org/dc/elements/1.1/", xml_string)
 
 
+def test_add_folder_metadata_no_prefix():
+    client = EntityAPI()
+    entity = client.entity(EntityType.FOLDER, FOLDER_ID)
+    folder = client.add_metadata(entity, "https://www.person.com/person", XML_DOCUMENT_NO_PREFIX)
+
+def test_add_folder_metadata_with_ns():
+    client = EntityAPI()
+    entity = client.entity(EntityType.FOLDER, FOLDER_ID)
+    folder = client.add_metadata(entity, "https://www.person.com/person", XML_DOCUMENT)
+
+def test_add_asset_metadata_no_prefix():
+    client = EntityAPI()
+    entity = client.entity(EntityType.ASSET, ASSET_ID)
+    folder = client.add_metadata(entity, "https://www.person.com/person", XML_DOCUMENT_NO_PREFIX)
+
+def test_add_asset_metadata_with_ns():
+    client = EntityAPI()
+    entity = client.entity(EntityType.ASSET, ASSET_ID)
+    folder = client.add_metadata(entity, "https://www.person.com/person", XML_DOCUMENT)
+
+
+
 def test_add_folder_metadata_string():
     client = EntityAPI()
     entity = client.entity(EntityType.FOLDER, FOLDER_ID)
@@ -85,8 +118,8 @@ def test_get_all_asset_metadata():
 
 def test_get_co_metadata():
     client = EntityAPI()
-    entity = client.entity(EntityType.CONTENT_OBJECT, CO_ID)
-    entity = client.delete_metadata(entity, "https://www.person.com/person")
+    entity_object = client.entity(EntityType.CONTENT_OBJECT, CO_ID)
+    entity = client.delete_metadata(entity_object, "https://www.person.com/person")
     xml_string = client.metadata_for_entity(entity, "https://www.person.com/person")
     assert xml_string is None
     co = client.add_metadata(entity, "https://www.person.com/person", XML_DOCUMENT)

{pypreservica-3.0.6 → pypreservica-3.2.0}/tests/test_par.py

@@ -6,7 +6,7 @@ from pyPreservica import *
 def test_format_families():
     par = PreservationActionRegistry()
     document = par.format_families()
-    assert len(json.loads(document)['formatFamilies']) == 190
+    assert len(json.loads(document)['formatFamilies']) == 192
 
 
 def test_format():

{pypreservica-3.0.6 → pypreservica-3.2.0}/tests/test_schema.py

@@ -53,16 +53,16 @@ def test_get_xml_document_by_uri():
 
 def test_add_xml_document():
     client = AdminAPI()
-    client.delete_xml_document("http://www.crossref.org/schema/5.3.0")
-    xml = requests.get(
+    client.delete_xml_document("http://www.crossref.org/schema/5.4.0")
+    xml_doc = requests.get(
         "https://gitlab.com/crossref/schema/-/raw/master/best-practice-examples/book5.3.0.xml").content.decode("utf-8")
-    client.add_xml_document("book5.3.0", xml)
-    xml_document = client.xml_document("http://www.crossref.org/schema/5.3.0")
-    assert len(xml_document) == len(xml)
-    client.delete_xml_document("http://www.crossref.org/schema/5.3.0")
+    client.add_xml_document("book5.4.0", xml_doc)
+    xml_document = client.xml_document("http://www.crossref.org/schema/5.4.0")
+    assert len(xml_document) == len(xml_doc)
+    client.delete_xml_document("http://www.crossref.org/schema/5.4.0")
 
     with open("test_data/mods.xml", mode="rb") as fd:
-        client.add_xml_document("mods31", xml)
+        client.add_xml_document("mods31", xml_doc)
 
     xml_document = client.xml_document("http://www.loc.gov/mods/v31")
     client.delete_xml_document("http://www.loc.gov/mods/v31")

pypreservica-3.2.0/tests/test_settings.py

@@ -0,0 +1,28 @@
+import pytest
+
+from pyPreservica.settingsAPI import SettingsAPI
+
+
+def setup():
+    pass
+
+
+def tear_down():
+    pass
+
+
+@pytest.fixture
+def setup_data():
+    setup()
+    yield
+    tear_down()
+
+
+
+def test_get_enrichment_profiles(setup_data):
+    client = SettingsAPI()
+    profiles = client.metadata_enrichment_profiles()
+    assert profiles is not None
+
+def test_can_add_enrichment_profile(setup_data):
+    client = SettingsAPI()