pyPreservica 2.9.3__py3-none-any.whl → 3.3.3__py3-none-any.whl

pyPreservica/mdformsAPI.py

@@ -8,7 +8,6 @@ author:     James Carr
 licence:    Apache License 2.0
 
 """
-import json
 import xml.etree.ElementTree
 from typing import Callable, List, Union, Generator
 
@@ -134,16 +133,45 @@ def _json_from_object_(group: Group) -> dict:
 
 
 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):
+                 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)
+                         protocol, request_hook, credentials_path)
 
         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 download_template(self, form_name: str):
+        """
+        Download a template csv to allow bulk input of data
+
+        """
+        headers = {HEADER_TOKEN: self.token}
+        url = f'{self.protocol}://{self.server}/api/metadata/csv-templates/download'
+
+        for form in self.forms():
+            if form['title'] == form_name:
+                form_id: str = form['id']
+                params = {'ids': form_id}
+                with self.session.get(url, headers=headers, params=params) as response:
+                    if response.status_code == requests.codes.ok:
+                        with open(f"{form_name}.csv", mode="wt", encoding="utf-8") as fd:
+                            fd.write(response.content.decode("utf-8"))
+                            fd.flush()
+                            return f"{form_name}.csv"
+                    if response.status_code == requests.codes.unauthorized:
+                        self.token = self.__token__()
+                        return self.download_template(form_name)
+                    else:
+                        exception = HTTPException(None, response.status_code, response.url, "download_template",
+                                                  response.content.decode('utf-8'))
+                        logger.error(exception)
+                        raise exception
+        return None
+
     def delete_group_namespace(self, schema: str):
         """
          Delete a new Metadata Group using its schema URI
@@ -248,9 +276,42 @@ class MetadataGroupsAPI(AuthenticatedAPI):
         json_response: dict = self.add_group_json(json_document)
         return json_response
 
+    def update_form(self, form_id: str, json_form: Union[dict, str]):
+
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/forms/{form_id}'
+
+        if isinstance(json_form, dict):
+            with self.session.put(url, headers=headers, json=json_form) as request:
+                if request.status_code == requests.codes.unauthorized:
+                    self.token = self.__token__()
+                    return self.add_form(json_form)
+                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, "add_form_json",
+                                              request.content.decode('utf-8'))
+                    logger.error(exception)
+                    raise exception
+
+        elif isinstance(json_form, str):
+            with self.session.put(url, headers=headers, data=json_form) as request:
+                if request.status_code == requests.codes.unauthorized:
+                    self.token = self.__token__()
+                    return self.add_form(json_form)
+                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, "add_form_json",
+                                              request.content.decode('utf-8'))
+                    logger.error(exception)
+                    raise exception
+        else:
+            raise RuntimeError("Argument must be a JSON dictionary or a JSON str")
+
     def add_form(self, json_form: Union[dict, str]):
         """
-        Create a new Metadata fORM using a JSON dictionary object or document
+        Create a new Metadata form using a JSON dictionary object or document
 
         :param json_form: JSON dictionary or string
         :type json_form: dict
@@ -266,7 +327,7 @@ class MetadataGroupsAPI(AuthenticatedAPI):
             with self.session.post(url, headers=headers, json=json_form) as request:
                 if request.status_code == requests.codes.unauthorized:
                     self.token = self.__token__()
-                    return self.add_form_json(json_form)
+                    return self.add_form(json_form)
                 elif request.status_code == requests.codes.created:
                     return json.loads(str(request.content.decode('utf-8')))
                 else:
@@ -279,7 +340,7 @@ class MetadataGroupsAPI(AuthenticatedAPI):
             with self.session.post(url, headers=headers, data=json_form) as request:
                 if request.status_code == requests.codes.unauthorized:
                     self.token = self.__token__()
-                    return self.add_form_json(json_form)
+                    return self.add_form(json_form)
                 elif request.status_code == requests.codes.created:
                     return json.loads(str(request.content.decode('utf-8')))
                 else:
@@ -451,6 +512,26 @@ class MetadataGroupsAPI(AuthenticatedAPI):
                 raise exception
 
 
+    def delete_form(self, form_id: str):
+        """
+        Delete a form by its ID
+        """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/forms/{form_id}'
+        with self.session.delete(url, headers=headers) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.delete_form(form_id)
+            elif request.status_code == requests.codes.no_content:
+                return None
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "delete_form",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+
+
     def form(self, form_id: str) -> dict:
         """
              Return a Form as a JSON dict object

pyPreservica/monitorAPI.py

@@ -89,7 +89,7 @@ class MonitorAPI(AuthenticatedAPI):
 
         :param monitor_id:  The Process ID
         :type monitor_id:   str
-        :param status:      The message status, info, warning, error etc
+        :param status:      The message status, info, warning, error etc.
         :type status:   MessageStatus
         :return:            Generator for each message, each message is a dict object
         """
@@ -147,7 +147,7 @@ class MonitorAPI(AuthenticatedAPI):
                 yield monitor
         elif request.status_code == requests.codes.unauthorized:
             self.token = self.__token__()
-            return self.monitors(status, category)
+            yield from self.monitors(status, category)
         else:
             logger.error(request.content.decode('utf-8'))
             raise RuntimeError(request.status_code, "monitors failed")

pyPreservica/parAPI.py

@@ -23,43 +23,7 @@ def __get_contents__(document) -> AnyStr:
         return json.dumps(json.loads(document))
 
 
-class PreservationActionRegistry:
-
-    def __init__(self, server: str = None, username: str = None, password: str = None, protocol: str = 'https'):
-        self.protocol = protocol
-        self.session = requests.Session()
-        self.session.headers.update({'accept': 'application/json;charset=UTF-8'})
-        config = configparser.ConfigParser()
-        config.read('credentials.properties')
-        if not server:
-            server = os.environ.get('PRESERVICA_SERVER')
-            if server is None:
-                try:
-                    server = config['credentials']['server']
-                except KeyError:
-                    pass
-        if not server:
-            msg = "No valid server found in method arguments, environment variables or credentials.properties file"
-            logger.error(msg)
-            raise RuntimeError(msg)
-        else:
-            self.server = server
-        if not username:
-            username = os.environ.get('PRESERVICA_USERNAME')
-            if username is None:
-                try:
-                    username = config['credentials']['username']
-                except KeyError:
-                    pass
-        self.username = username
-        if not password:
-            password = os.environ.get('PRESERVICA_PASSWORD')
-            if password is None:
-                try:
-                    password = config['credentials']['password']
-                except KeyError:
-                    pass
-        self.password = password
+class PreservationActionRegistry(AuthenticatedAPI):
 
     def format_family(self, guid: str) -> str:
         return self.__guid__(guid, "format-families")

pyPreservica/retentionAPI.py

@@ -58,9 +58,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", request_hook: Callable = None):
+                 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)
+                         protocol, request_hook, credentials_path)
+
         if self.major_version < 7 and self.minor_version < 2:
             raise RuntimeError("Retention API is only available when connected to a v6.2 System")
 
@@ -95,7 +96,7 @@ class RetentionAPI(AuthenticatedAPI):
             if start_date_field is not None:
                 rp.start_date_field = start_date_field.text
             else:
-                start_date_field = None
+                rp.start_date_field = None
             period = entity_response.find(f'.//{{{self.rm_ns}}}RetentionPolicy/{{{self.rm_ns}}}Period')
             if period is not None:
                 rp.period = period.text
@@ -403,7 +404,7 @@ class RetentionAPI(AuthenticatedAPI):
     def policies(self, maximum: int = 250, next_page: str = None) -> PagedSet:
         """
         Return a list of all retention policies
-        Returns a maxmium of 250 policies by default
+        Returns a maximum of 250 policies by default
 
 
         :return: Set of retention policies

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")