pyPreservica 0.9.9__py3-none-any.whl → 3.3.4__py3-none-any.whl

pyPreservica/monitorAPI.py

@@ -0,0 +1,153 @@
+"""
+pyPreservica MonitorAPI module definition
+
+A client library for the Preservica Repository Monitor API
+https://us.preservica.com/api/processmonitor/documentation.html
+
+author:     James Carr
+licence:    Apache License 2.0
+
+"""
+
+from typing import Generator
+
+from pyPreservica.common import *
+
+
+class MonitorCategory(Enum):
+    INGEST = 'Ingest'
+    EXPORT = 'Export'
+    DATA_MANAGEMENT = 'DataManagement'
+    AUTOMATED = 'Automated'
+
+
+class MonitorStatus(Enum):
+    PENDING = 'Pending'
+    RUNNING = 'Running'
+    SUCCEEDED = 'Succeeded'
+    FAILED = 'Failed'
+    SUSPENDED = 'Suspended'
+    RECOVERABLE = 'Recoverable'
+
+
+class MessageStatus(Enum):
+    INFO = 'Info'
+    WARNING = 'Warning'
+    ERROR = 'Error'
+
+
+class MonitorAPI(AuthenticatedAPI):
+    """
+               A class for the Preservica Repository Process Monitor API
+
+               https://us.preservica.com/api/processmonitor/documentation.html
+
+                API for retrieving and updating monitoring information about processes.
+
+       """
+
+    def _messages_page_(self, monitor_id, maximum: int = 50, next_page: str = None, status: MessageStatus = None) -> PagedSet:
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+
+        if next_page is None:
+            params = {'monitor': monitor_id, 'start': int(0), 'max': maximum}
+            if status:
+                params['status'] = status.value
+            request = self.session.get(f'{self.protocol}://{self.server}/api/processmonitor/messages', headers=headers,
+                                       params=params)
+        else:
+            params = {'monitor': monitor_id}
+            if status:
+                params['status'] = status.value
+            request = self.session.get(next_page, headers=headers, params=params)
+        if request.status_code == requests.codes.ok:
+            response = json.loads(str(request.content.decode('utf-8')))
+            value = response['value']
+            if 'next' in value['paging']:
+                url = value['paging']['next']
+            else:
+                url = None
+            total_hits = int(value['paging']['totalResults'])
+            has_more = False
+            if url:
+                has_more = True
+            messages = value['messages']
+            for m in messages:
+                m['MonitorId'] = m.pop('mappedMonitorId')
+                m['MessageId'] = m.pop('mappedId')
+            return PagedSet(messages, has_more, int(total_hits), url)
+        elif request.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            return self._messages_page_(monitor_id, maximum, next_page, status)
+        else:
+            logger.error(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, "messages failed")
+
+    def messages(self, monitor_id, status: MessageStatus = None) -> Generator:
+        """
+        List of messages for a process
+
+        :param monitor_id:  The Process ID
+        :type monitor_id:   str
+        :param status:      The message status, info, warning, error etc.
+        :type status:   MessageStatus
+        :return:            Generator for each message, each message is a dict object
+        """
+        page_size = 25
+        paged_set = self._messages_page_(monitor_id, maximum=page_size, next_page=None, status=status)
+        for e in paged_set.results:
+            yield e
+        while paged_set.has_more:
+            paged_set = self._messages_page_(monitor_id, maximum=page_size, next_page=paged_set.next_page, status=status)
+            for e in paged_set.results:
+                yield e
+
+    def timeseries(self, monitor_id):
+        """
+        Get the historical record of progress for a single monitor
+
+        :param monitor_id:  The Process ID
+        :type monitor_id:   str
+        :return:            List of timeseries information
+        """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        request = self.session.get(f'{self.protocol}://{self.server}/api/processmonitor/monitors/{monitor_id}/timeseries',
+                                   headers=headers)
+        if request.status_code == requests.codes.ok:
+            response = json.loads(str(request.content.decode('utf-8')))
+            return response['value']['timeseries']
+        elif request.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            return self.timeseries(monitor_id)
+        else:
+            logger.error(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, "timeseries failed")
+
+    def monitors(self, status: MonitorStatus = None, category: MonitorCategory = None) -> Generator:
+        """
+        Get a filtered list of non-abandoned process monitors
+
+        :param status:  process status values (Pending, Running, Succeeded, Failed, Suspended, Recoverable)
+        :type status:   MonitorStatus
+        :param category: process categories (Ingest, Export, DataManagement, Automated)
+        :type category:   MonitorCategory
+        :return: Generator for each monitor
+        """
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        params = {}
+        if status:
+            params['status'] = status.value
+        if category:
+            params['category'] = category.value
+        request = self.session.get(f'{self.protocol}://{self.server}/api/processmonitor/monitors', headers=headers, params=params)
+        if request.status_code == requests.codes.ok:
+            monitors = json.loads(str(request.content.decode('utf-8')))
+            for monitor in monitors['value']['monitors']:
+                monitor['MonitorId'] = monitor.pop('mappedId')
+                yield monitor
+        elif request.status_code == requests.codes.unauthorized:
+            self.token = self.__token__()
+            yield from self.monitors(status, category)
+        else:
+            logger.error(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, "monitors failed")

pyPreservica/opex.py

@@ -0,0 +1,98 @@
+"""
+pyPreservica OpexAPI module definition
+
+A Utility class to work with Opex Objects
+
+author:     James Carr
+licence:    Apache License 2.0
+
+"""
+import xml.etree.ElementTree
+from typing import Generator
+from zipfile import ZipFile
+
+
+class OpexAPI(object):
+    class OPEXMetadata(object):
+        def __init__(self, source: str, title: str, description: str, SecurityDescriptor: str):
+            self.pax_file = None
+            self.source = source
+            self.title = title
+            self.description = description
+            self.SecurityDescriptor = SecurityDescriptor
+
+        def __str__(self):
+            return self.__repr__()
+
+        def __repr__(self):
+            return {"SourceID": self.source, "Title": self.title, "Description": self.description,
+                    "SecurityDescriptor": self.SecurityDescriptor}.__str__()
+
+    def __init__(self, opex_file: str):
+        self.opex = opex_file
+
+    def bitstream_bytes(self, opex_metadata: OPEXMetadata, bitstream_name: dict):
+        with ZipFile(self.opex) as zip_opex_file:
+            for o in zip_opex_file.namelist():
+                if o == opex_metadata.pax_file:
+                    with zip_opex_file.open(opex_metadata.pax_file) as zip_pax_file:
+                        with ZipFile(zip_pax_file) as pax_file:
+                            name = "/".join(bitstream_name.values())
+                            with pax_file.open(name, mode="r") as myfile:
+                                return myfile.read()
+
+    def xip_metadata(self, opex_metadata: OPEXMetadata):
+        with ZipFile(self.opex) as zip_opex_file:
+            for o in zip_opex_file.namelist():
+                if o == opex_metadata.pax_file:
+                    with zip_opex_file.open(opex_metadata.pax_file) as zip_pax_file:
+                        with ZipFile(zip_pax_file) as pax_file:
+                            for name in pax_file.namelist():
+                                if name.endswith(".xip") is True:
+                                    return name
+
+    def xip_metadata(self, opex_metadata: OPEXMetadata):
+        with ZipFile(self.opex) as zip_opex_file:
+            for o in zip_opex_file.namelist():
+                if o == opex_metadata.pax_file:
+                    with zip_opex_file.open(opex_metadata.pax_file) as zip_pax_file:
+                        with ZipFile(zip_pax_file) as pax_file:
+                            for name in pax_file.namelist():
+                                if (name.endswith("/") is False) and (name.endswith(".xip") is True):
+                                    with pax_file.open(name, mode="r") as myfile:
+                                        return myfile.read()
+
+    def bitstream(self, opex_metadata: OPEXMetadata) -> Generator:
+        with ZipFile(self.opex) as zip_opex_file:
+            for o in zip_opex_file.namelist():
+                if o == opex_metadata.pax_file:
+                    with zip_opex_file.open(opex_metadata.pax_file) as zip_pax_file:
+                        with ZipFile(zip_pax_file) as pax_file:
+                            for name in pax_file.namelist():
+                                if (name.endswith("/") is False) and (name.endswith(".xip") is False):
+                                    parts = name.split("/")
+                                    assert len(parts) == 4
+                                    yield {"Representation": parts[0], "Content Object": parts[1],
+                                           "Generation": parts[2], "Bitstream": parts[3]}
+
+    def properties(self) -> Generator:
+        with ZipFile(self.opex) as myzip:
+            for o in myzip.namelist():
+                if o.endswith(".pax.zip.opex"):
+                    pax_file = o.replace(".pax.zip.opex", ".pax.zip")
+                    with myzip.open(o) as myfile:
+                        xml_response = str(myfile.read().decode('utf-8'))
+                        entity_response = xml.etree.ElementTree.fromstring(xml_response)
+                        source_id = entity_response.find(f'.//{{*}}SourceID')
+                        title_node = entity_response.find(f'.//{{*}}Title')
+                        description_node = entity_response.find(f'.//{{*}}Description')
+                        tag_node = entity_response.find(f'.//{{*}}SecurityDescriptor')
+
+                        title = title_node.text if hasattr(title_node, 'text') else None
+                        description = description_node.text if hasattr(description_node, 'text') else None
+                        tag = tag_node.text if hasattr(tag_node, 'text') else None
+
+                        opex_metadata = self.OPEXMetadata(source_id.text, title, description, tag)
+                        opex_metadata.pax_file = pax_file
+
+                        yield opex_metadata

pyPreservica/parAPI.py

@@ -0,0 +1,226 @@
+"""
+pyPreservica Preservation Action Registry module definition
+
+A client library for the Preservica PAR API
+https://us.preservica.com/Registry/par/documentation.html
+
+author:     James Carr
+licence:    Apache License 2.0
+
+"""
+from typing import AnyStr
+
+from requests.auth import HTTPBasicAuth
+
+from pyPreservica.common import *
+
+
+def __get_contents__(document) -> AnyStr:
+    try:
+        with open(document, "rb") as f:
+            return f.read()
+    except (OSError, TypeError):
+        return json.dumps(json.loads(document))
+
+
+class PreservationActionRegistry(AuthenticatedAPI):
+
+    def format_family(self, guid: str) -> str:
+        return self.__guid__(guid, "format-families")
+
+    def format_families(self) -> str:
+        return self.__all_("format-families")
+
+    def add_format_family(self, document) -> str:
+        return self.__add__("format-families", document)
+
+    def update_format_family(self, guid: str, document) -> str:
+        return self.__update__(guid, "format-families", document)
+
+    def delete_format_family(self, guid) -> str:
+        return self.__delete__(guid, "format-families")
+
+    def preservation_action_type(self, guid: str) -> str:
+        return self.__guid__(guid, "preservation-action-types")
+
+    def preservation_action_types(self) -> str:
+        return self.__all_("preservation-action-types")
+
+    def add_preservation_action_type(self, document) -> str:
+        return self.__add__("preservation-action-types", document)
+
+    def update_preservation_action_type(self, guid: str, document) -> str:
+        return self.__update__(guid, "preservation-action-types", document)
+
+    def delete_preservation_action_type(self, guid) -> str:
+        return self.__delete__(guid, "preservation-action-types")
+
+    def property(self, guid: str) -> str:
+        return self.__guid__(guid, "properties")
+
+    def properties(self) -> str:
+        return self.__all_("properties")
+
+    def add_property(self, document) -> str:
+        return self.__add__("properties", document)
+
+    def update_property(self, guid: str, document) -> str:
+        return self.__update__(guid, "properties", document)
+
+    def delete_property(self, guid) -> str:
+        return self.__delete__(guid, "properties")
+
+    def representation_format(self, guid: str) -> str:
+        return self.__guid__(guid, "representation-formats")
+
+    def representation_formats(self) -> str:
+        return self.__all_("representation-formats")
+
+    def add_representation_format(self, document) -> str:
+        return self.__add__("representation-formats", document)
+
+    def update_representation_format(self, guid: str, document) -> str:
+        return self.__update__(guid, "representation-formats", document)
+
+    def delete_representation_format(self, guid) -> str:
+        return self.__delete__(guid, "representation-formats")
+
+    def file_format(self, puid: str) -> str:
+        return self.__guid__(puid, "file-formats")
+
+    def file_formats(self) -> str:
+        return self.__all_("file-formats")
+
+    def add_file_format(self, document) -> str:
+        return self.__add__("file-formats", document)
+
+    def update_file_format(self, guid: str, document) -> str:
+        return self.__update__(guid, "file-formats", document)
+
+    def delete_file_format(self, guid) -> str:
+        return self.__delete__(guid, "file-formats")
+
+    def tool(self, guid: str) -> str:
+        return self.__guid__(guid, "tools")
+
+    def tools(self) -> str:
+        return self.__all_("tools")
+
+    def add_tool(self, document) -> str:
+        return self.__add__("tools", document)
+
+    def update_tool(self, guid: str, document) -> str:
+        return self.__update__(guid, "tools", document)
+
+    def delete_tool(self, guid) -> str:
+        return self.__delete__(guid, "tools")
+
+    def preservation_action(self, guid: str) -> str:
+        return self.__guid__(guid, "preservation-actions")
+
+    def preservation_actions(self) -> str:
+        return self.__all_("preservation-actions")
+
+    def add_preservation_action(self, document) -> str:
+        return self.__add__("preservation-actions", document)
+
+    def update_preservation_action(self, guid: str, document) -> str:
+        return self.__update__(guid, "preservation-actions", document)
+
+    def delete_preservation_action(self, guid) -> str:
+        return self.__delete__(guid, "preservation-actions")
+
+    def business_rule(self, guid: str) -> str:
+        return self.__guid__(guid, "business-rules")
+
+    def business_rules(self, action_type: str = None) -> str:
+        return self.__all_("business-rules", action_type)
+
+    def add_business_rule(self, document) -> str:
+        return self.__add__("business-rules", document)
+
+    def update_business_rule(self, guid: str, document) -> str:
+        return self.__update__(guid, "business-rules", document)
+
+    def delete_business_rule(self, guid) -> str:
+        return self.__delete__(guid, "business-rules")
+
+    def rule_set(self, guid: str) -> str:
+        return self.__guid__(guid, "rulesets")
+
+    def rule_sets(self) -> str:
+        return self.__all_("rulesets")
+
+    def add_rule_set(self, document) -> str:
+        return self.__add__("rulesets", document)
+
+    def update_rule_set(self, guid: str, document) -> str:
+        return self.__update__(guid, "rulesets", document)
+
+    def delete_rule_set(self, guid) -> str:
+        return self.__delete__(guid, "rulesets")
+
+    def __guid__(self, guid: str, endpoint: str) -> str:
+        request = self.session.get(f'{self.protocol}://{self.server}/Registry/par/{endpoint}/{guid}')
+        if request.status_code == requests.codes.ok:
+            return request.content.decode('utf-8')
+        else:
+            logger.debug(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, f"{endpoint} failed")
+
+    def __all_(self, endpoint: str, action_type: str = None) -> str:
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json'}
+        if action_type is not None:
+            headers['preservation-action-type'] = action_type
+        request = self.session.get(f'{self.protocol}://{self.server}/Registry/par/{endpoint}')
+        if request.status_code == requests.codes.ok:
+            return request.content.decode('utf-8')
+        else:
+            logger.debug(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, f"{endpoint} failed")
+
+    def __add__(self, endpoint: str, document) -> str:
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json'}
+        if self.username is None or self.password is None:
+            logger.error(f"add {endpoint} is an authenticated call, please provide credentials")
+            raise RuntimeError(f"add {endpoint}  is an authenticated call, please provide credentials")
+
+        contents = __get_contents__(document)
+        request = self.session.post(f'{self.protocol}://{self.server}/Registry/par/{endpoint}',
+                                    auth=HTTPBasicAuth(self.username, self.password), headers=headers, data=contents)
+
+        if request.status_code == requests.codes.created:
+            return request.content.decode('utf-8')
+        else:
+            logger.debug(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, f"add {endpoint} failed")
+
+    def __update__(self, guid: str, endpoint: str, document) -> str:
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json'}
+        if self.username is None or self.password is None:
+            logger.error(f"update {endpoint} is an authenticated call, please provide credentials")
+            raise RuntimeError(f"update {endpoint}  is an authenticated call, please provide credentials")
+
+        contents = __get_contents__(document)
+
+        request = self.session.put(f'{self.protocol}://{self.server}/Registry/par/{endpoint}/{guid}',
+                                   auth=HTTPBasicAuth(self.username, self.password), headers=headers, data=contents)
+
+        if request.status_code == requests.codes.created:
+            return request.content.decode('utf-8')
+        else:
+            logger.debug(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, f"update {endpoint} failed")
+
+    def __delete__(self, guid: str, endpoint: str) -> str:
+        if self.username is None or self.password is None:
+            logger.error(f"delete {endpoint} is an authenticated call, please provide credentials")
+            raise RuntimeError(f"delete {endpoint}  is an authenticated call, please provide credentials")
+
+        request = self.session.delete(f'{self.protocol}://{self.server}/Registry/par/{endpoint}/{guid}',
+                                      auth=HTTPBasicAuth(self.username, self.password))
+        if request.status_code == requests.codes.no_content:
+            return request.content.decode('utf-8')
+        else:
+            logger.debug(request.content.decode('utf-8'))
+            raise RuntimeError(request.status_code, f"delete {endpoint} failed")