sapiopycommons 2024.11.7a354__py3-none-any.whl → 2024.11.8a359__py3-none-any.whl

sapiopycommons/processtracking/custom_workflow_handler.py

@@ -1,406 +0,0 @@
-from typing import Iterable
-
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
-
-from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
-from sapiopycommons.customreport.term_builder import TermBuilder
-from sapiopycommons.datatype.data_fields import ProcessQueueItemFields, SystemFields, ProcessWorkflowTrackingFields
-from sapiopycommons.general.aliases import UserIdentifier, AliasUtil, SapioRecord
-from sapiopycommons.general.custom_report_util import CustomReportUtil
-from sapiopycommons.general.exceptions import SapioException
-from sapiopycommons.general.time_util import TimeUtil
-from sapiopycommons.recordmodel.record_handler import RecordHandler
-from sapiopycommons.webhook.webhook_context import ProcessQueueContext
-
-
-class QueueItemReportCriteria:
-    """
-    Queue item report criteria is used to restrict the results of searches for queue item records.
-    """
-    process_names: list[str] | None
-    not_process_names: list[str] | None
-    step_names: list[str] | None
-    not_step_names: list[str] | None
-    data_type_names: list[str] | None
-    not_data_type_names: list[str] | None
-    data_record_ids: list[int] | None
-    not_data_record_ids: list[int] | None
-    assigned_to: list[str] | None
-    not_assigned_to: list[str] | None
-    launched_after: int | None
-    launched_before: int | None
-    scheduled_after: int | None
-    scheduled_before: int | None
-    shown_in_queue: bool | None
-    has_experiment: bool | None
-
-    def __init__(self, *,
-                 process_names: list[str] | None = None,
-                 not_process_names: list[str] | None = None,
-                 step_names: list[str] | None = None,
-                 not_step_names: list[str] | None = None,
-                 data_type_names: list[str] | None = None,
-                 not_data_type_names: list[str] | None = None,
-                 data_record_ids: list[int] | None = None,
-                 not_data_record_ids: list[int] | None = None,
-                 assigned_to: list[str] | None = None,
-                 not_assigned_to: list[str] | None = None,
-                 launched_after: int | None = None,
-                 launched_before: int | None = None,
-                 scheduled_after: int | None = None,
-                 scheduled_before: int | None = None,
-                 shown_in_queue: bool | None = None,
-                 has_experiment: bool | None = None):
-        """
-        :param process_names: The allowed process name(s).
-        :param not_process_names: The disallowed process name(s).
-        :param step_names: The allowed step name(s).
-        :param not_step_names: The disallowed step name(s).
-        :param data_type_names: The allowed data type name(s).
-        :param not_data_type_names: The disallowed dta type name(s).
-        :param data_record_ids: The allowed record ID(s).
-        :param not_data_record_ids: The disallowed record ID(s).
-        :param assigned_to: The allowed username(s) of the user(s) that the queue items are assigned to.
-        :param not_assigned_to: The disallowed username(s) of the user(s) that the queue items are assigned to.
-        :param launched_after: A timestamp after which the queue item was launched.
-        :param launched_before: A timestamp before which the queue item was launched.
-        :param scheduled_after: A timestamp after which the queue item was scheduled.
-        :param scheduled_before: A timestamp before which the queue item was scheduled.
-        :param shown_in_queue: Whether the queue item is currently being shown in a queue.
-        :param has_experiment: Whether the queue item is linked to an experiment record.
-        """
-        self.process_names = process_names
-        self.not_process_names = not_process_names
-        self.step_names = step_names
-        self.not_step_names = not_step_names
-        self.data_type_names = data_type_names
-        self.not_data_type_names = not_data_type_names
-        self.data_record_ids = data_record_ids
-        self.not_data_record_ids = not_data_record_ids
-        self.assigned_to = assigned_to
-        self.not_assigned_to = not_assigned_to
-        self.launched_after = launched_after
-        self.launched_before = launched_before
-        self.scheduled_after = scheduled_after
-        self.scheduled_before = scheduled_before
-        self.shown_in_queue = shown_in_queue
-        self.has_experiment = has_experiment
-
-
-class QueueItemHandler:
-    """
-    A class used for handling the display of records in custom process queues, which are controlled in the system by
-    ProcessQueueItem data types.
-    """
-    user: SapioUser
-    context: ProcessQueueContext | None
-    rec_handler: RecordHandler
-
-    def __init__(self, context: UserIdentifier):
-        """
-        :param context: The current webhook context or a user object to send requests from.
-        """
-        self.user = AliasUtil.to_sapio_user(context)
-        self.rec_handler = RecordHandler(self.user)
-        if isinstance(context, SapioWebhookContext):
-            self.context = ProcessQueueContext(context)
-        else:
-            self.context = None
-
-    def get_process_queue_items_from_context(self, wrapper: type[WrappedType],
-                                             context: SapioWebhookContext | ProcessQueueContext | None = None) \
-            -> list[WrappedType]:
-        """
-        When you launch records from a custom process queue, the process queue items related to the selected records
-        are provided as record IDs to the process queue context. Using these record IDs, query for the queue item
-        records and wrap them as record models.
-
-        :param wrapper: The record model wrapper for the process queue items.
-        :param context: If this handler was not initialized with a context object, or you wish to retrieve
-            data from a different context object than the initializing context, then provide the context to retrieve the
-            record IDs from.
-        :return: The process queue items corresponding to the record IDs from the context wrapped as record models.
-        """
-        if context is None and self.context is not None:
-            record_ids: list[int] = self.context.process_queue_item_record_ids
-        elif context is not None:
-            if isinstance(context, SapioWebhookContext):
-                record_ids: list[int] = ProcessQueueContext(context).process_queue_item_record_ids
-            else:
-                record_ids: list[int] = context.process_queue_item_record_ids
-        else:
-            raise SapioException("A context object must be provided to this function call, as the handler "
-                                 "was not initialized with one.")
-        return self.rec_handler.query_models_by_id(wrapper, record_ids)
-
-    def map_records_to_queue_items(self, records: Iterable[SapioRecord], queue_items: Iterable[SapioRecord]) \
-            -> dict[SapioRecord, list[SapioRecord]]:
-        """
-        Given a list of records and a list of queue items, create a dictionary mapping the records to the queue items
-        that refer to them.
-
-        :param records: The records to map to the queue items.
-        :param queue_items: The queue items to map to the records.
-        :return: A dictionary of record to the queue items that refer to them. Input queue items that don't refer to
-            any provided records will not be in this dictionary.
-        """
-        ret_val: dict[SapioRecord, list[SapioRecord]] = {}
-        id_to_queue_items: dict[int, list[SapioRecord]] = self.rec_handler.map_by_field(queue_items,
-                                                                                        ProcessQueueItemFields.DATA_RECORD_ID__FIELD)
-        id_to_record: dict[int, SapioRecord] = self.rec_handler.map_by_id(records)
-        for record_id, record in id_to_record.items():
-            ret_val[record] = id_to_queue_items[record_id]
-        return ret_val
-
-    def map_queue_items_to_records(self, queue_items: Iterable[SapioRecord], records: Iterable[SapioRecord]) \
-            -> dict[SapioRecord, SapioRecord]:
-        """
-        Given a list of queue items and a list of records, create a dictionary mapping the queue items to the record
-        that they refer to.
-
-        :param queue_items: The queue items to map to the records.
-        :param records: The records to map to the queue items.
-        :return: A dictionary of queue items to the records that the refer to. Input record that aren't referred to by
-            any provided queue items will not be in this dictionary.
-        """
-        ret_val: dict[SapioRecord, SapioRecord] = {}
-        id_to_queue_items: dict[int, list[SapioRecord]] = self.rec_handler.map_by_field(queue_items,
-                                                                                        ProcessQueueItemFields.DATA_RECORD_ID__FIELD)
-        id_to_record: dict[int, SapioRecord] = self.rec_handler.map_by_id(records)
-        for record_id, queue_items in id_to_queue_items.items():
-            record: SapioRecord = id_to_record[record_id]
-            for queue_item in queue_items:
-                ret_val[queue_item] = record
-        return ret_val
-
-    def get_queue_items_from_report(self, wrapper: type[WrappedType], criteria: QueueItemReportCriteria) \
-            -> list[WrappedType]:
-        """
-        Run a custom report that retrieves every queue item in the system for the given search criteria.
-
-        :param wrapper: The record model wrapper for the process queue items.
-        :param criteria: The search criteria to query for queue items with.
-        :return: A list of every queue item in the system that matches the search criteria.
-        """
-        report = self.build_queue_item_report(criteria)
-        return self.rec_handler.query_models_by_report(wrapper, report)
-
-    def get_records_from_item_report(self, wrapper: type[WrappedType],
-                                     criteria: QueueItemReportCriteria = QueueItemReportCriteria()) -> list[WrappedType]:
-        """
-        Run a custom report that retrieves for queue items that match the given search criteria, then query for the
-        data records that those queue items refer to.
-
-        :param wrapper: The record model wrapper for the records being queried for.
-        :param criteria: Additional search criteria to filter the results. This function forces the data_type_names
-            parameter of the criteria to match the data type of the given record model wrapper.
-        :return: A list of all records related to the queue items in the system that match the search criteria.
-        """
-        # Don't try to query for process queue items that don't match the data type of this wrapper.
-        criteria.data_type_names = [wrapper.get_wrapper_data_type_name()]
-        criteria.not_data_type_names = None
-        report = self.build_queue_item_report(criteria)
-        record_ids: list[int] = [x[ProcessQueueItemFields.DATA_RECORD_ID__FIELD.field_name]
-                                 for x in CustomReportUtil.run_custom_report(self.user, report)]
-        return self.rec_handler.query_models_by_id(wrapper, record_ids)
-
-    def get_queue_items_for_records(self, records: Iterable[SapioRecord], wrapper: type[WrappedType],
-                                    criteria: QueueItemReportCriteria = QueueItemReportCriteria()) \
-            -> dict[SapioRecord, list[WrappedType]]:
-        """
-        Given a list of records, query the system for every process queue item that refers to those records and matches
-        the provided search criteria.
-
-        :param records: The queued records to query for the process queue items of.
-        :param wrapper: The record model wrapper for the returned process queue item records.
-        :param criteria: Additional search criteria to filter the results. This function forces the data_record_ids and
-            data_type_names parameters on the criteria to match the given records.
-        :return: A dictionary mapping the input records to a list of the process queue items that refer to them. If a
-            record does not have any queue items that refer to it that match the given search criteria, then it will
-            map to an empty list.
-        """
-        # Query for only those process queue items that have a record ID from the provided records.
-        criteria.data_record_ids = AliasUtil.to_record_ids(records)
-        criteria.not_data_record_ids = None
-        criteria.data_type_names = AliasUtil.to_data_type_names(records)
-        criteria.not_data_type_names = None
-        items: list[WrappedType] = self.get_queue_items_from_report(wrapper, criteria)
-        return self.map_records_to_queue_items(records, items)
-
-    def get_records_for_queue_items(self, queue_items: Iterable[SapioRecord], wrapper: type[WrappedType]) \
-            -> dict[SapioRecord, WrappedType]:
-        """
-        Given a list of process queue items, query the system for the records that those queue items refer to.
-
-        :param queue_items: The process queue items to query for the referenced records of.
-        :param wrapper: The record model wrapper for the records being queried.
-        :return: A dictionary mapping the input process queue items to the record tht they refer to.
-        """
-        record_ids: set[int] = {x.get_field_value(ProcessQueueItemFields.DATA_RECORD_ID__FIELD) for x in queue_items}
-        records: list[WrappedType] = self.rec_handler.query_models_by_id(wrapper, record_ids)
-        return self.map_queue_items_to_records(queue_items, records)
-
-    def queue_records_for_process(self, records: Iterable[SapioRecord], process: str, step: str,
-                                  wrapper: type[WrappedType]) -> dict[SapioRecord, WrappedType]:
-        """
-        Given a list of records, create process queue item records for them at the provided process and step names.
-        You must store and commit using the record model manager in order for these changes to take effect.
-
-        :param records: The records to create process queue items for.
-        :param wrapper: The record model wrapper for the process queue items being created.
-        :param process: The name of the process to queue for.
-        :param step: The name of the step in the above process to queue for. This is the "Workflow Name" field of the
-            Process Workflow record corresponding to the step you want to assign these records to. For steps that
-            launch an experiment, this is the name of the template that will be launched. For the other types of custom
-            process steps, this is the "Workflow Name" as defined in the process manager config.
-        :return: A dictionary mapping each input record to the newly created process queue item for that record.
-        """
-        ret_val: dict[SapioRecord, WrappedType] = {}
-        for record in records:
-            item = self.rec_handler.add_model(wrapper)
-            item.set_field_values({
-                ProcessQueueItemFields.PROCESS_HEADER_NAME__FIELD.field_name: process,
-                ProcessQueueItemFields.WORKFLOW_HEADER_NAME__FIELD.field_name: step,
-                ProcessQueueItemFields.SHOW_IN_QUEUE__FIELD.field_name: True,
-                ProcessQueueItemFields.SCHEDULED_DATE__FIELD.field_name: TimeUtil.now_in_millis(),
-                ProcessQueueItemFields.DATA_RECORD_ID__FIELD.field_name: AliasUtil.to_record_id(record),
-                ProcessQueueItemFields.DATA_TYPE_NAME__FIELD.field_name: AliasUtil.to_data_type_name(record)
-            })
-            ret_val[record] = item
-        return ret_val
-
-    def dequeue_records_for_process(self, records: Iterable[SapioRecord], wrapper: type[WrappedType],
-                                    criteria: QueueItemReportCriteria = QueueItemReportCriteria()) \
-            -> dict[SapioRecord, list[WrappedType]]:
-        """
-        Given a list of records, locate the process queue items that refer to them and that match the given search
-        criteria and remove them from the queue by setting the ShowInQueue field on the process queue items to false.
-        You must store and commit using the record model manager in order for these changes to take effect.
-
-        :param records: The records to remove from the queue.
-        :param wrapper: The record model wrapper for the process queue items being updated.
-        :param criteria: Additional search criteria to filter the results. This function forces the show_in_queue
-            parameter on the criteria to True.
-        :return: A dictionary mapping each input record to the queue item records that refer to that record and were
-            updated. If a record does not have any queue items that refer to it that match the given search criteria,
-            then it will map to an empty list.
-        """
-        # Only locate queue items that are currently visible in the queue.
-        criteria.shown_in_queue = True
-        dequeue: dict[SapioRecord, list[WrappedType]] = self.get_queue_items_for_records(records, wrapper, criteria)
-        for record, items in dequeue.items():
-            for item in items:
-                item.set_field_value(ProcessQueueItemFields.SHOW_IN_QUEUE__FIELD.field_name, False)
-        return dequeue
-
-    @staticmethod
-    def assigned_queue_items(queue_items: Iterable[SapioRecord], assign_to: list[str]) -> None:
-        """
-        Given a collection of queue items, assign them to a list of usernames or group names. Only those users in the
-        listed groups or those users with the matching username will be able to see these related records in the process
-        queue.
-        You must store and commit using the record model manager in order for these changes to take effect.
-
-        :param queue_items: The queue items to assign.
-        :param assign_to: A list of usernames and/or group names to assign these items to.
-        """
-        for item in queue_items:
-            item.set_field_value(ProcessQueueItemFields.ASSIGNED_TO__FIELD, ",".join(assign_to))
-
-    def get_queue_item_workflow_trackers(self, items: Iterable[SapioRecord], wrapper: type[WrappedType]) \
-            -> dict[SapioRecord, list[WrappedType]]:
-        """
-        When a queue item is launched into a process step, a ProcessWorkflowTracking record is created by the system
-        with a side link to the process queue item. This record records information about how long the record ws in
-        the queue, among other details.
-
-        Retrieve the workflow tracker records for the input queue items.
-
-        :param items: The queue items to load the workflow trackers of.
-        :param wrapper: The record model wrapper for the ProcessWorkflowTracking records.
-        :return: A dictionary mapping each queue item to the workflow trackers that side link to that item. If an input
-            queue item doesn't have any workflow trackers, then it will map to an empty list.
-        """
-        field: str = ProcessWorkflowTrackingFields.PROCESS_QUEUE_ITEM__FIELD.field_name
-        self.rec_handler.rel_man.load_reverse_side_links_of_type(list(items), wrapper, field)
-        return self.rec_handler.map_to_reverse_side_links(items, field, wrapper)
-
-    @staticmethod
-    def build_queue_item_report(criteria: QueueItemReportCriteria) -> CustomReportCriteria:
-        """
-        Construct a custom report using the provided QueueItemReportCriteria.
-
-        :param criteria: The criteria to construct a custom report from.
-        :return: A custom report that can be used to search for queue items that match the given criteria.
-        """
-        dt: str = ProcessQueueItemFields.DATA_TYPE_NAME
-        report_builder = CustomReportBuilder(dt)
-        report_builder.add_column(SystemFields.RECORD_ID__FIELD)
-        report_builder.add_column(ProcessQueueItemFields.DATA_RECORD_ID__FIELD)
-
-        root = TermBuilder.all_records_term(dt)
-
-        if criteria.process_names is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.PROCESS_HEADER_NAME__FIELD, criteria.process_names)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.not_process_names is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.PROCESS_HEADER_NAME__FIELD, criteria.not_process_names)
-            root = TermBuilder.and_terms(root, term)
-
-        if criteria.step_names is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.WORKFLOW_HEADER_NAME__FIELD, criteria.step_names)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.not_step_names is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.WORKFLOW_HEADER_NAME__FIELD, criteria.not_step_names)
-            root = TermBuilder.and_terms(root, term)
-
-        if criteria.data_type_names is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.DATA_TYPE_NAME__FIELD, criteria.data_type_names)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.not_data_type_names is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.DATA_TYPE_NAME__FIELD, criteria.not_data_type_names)
-            root = TermBuilder.and_terms(root, term)
-
-        if criteria.data_record_ids is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.DATA_RECORD_ID__FIELD, criteria.data_record_ids)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.not_data_record_ids is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.DATA_RECORD_ID__FIELD, criteria.not_data_record_ids)
-            root = TermBuilder.and_terms(root, term)
-
-        if criteria.assigned_to is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.ASSIGNED_TO__FIELD, criteria.assigned_to)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.not_assigned_to is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.ASSIGNED_TO__FIELD, criteria.not_assigned_to)
-            root = TermBuilder.and_terms(root, term)
-
-        if criteria.launched_after is not None:
-            term = TermBuilder.gte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.launched_after)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.launched_before is not None:
-            term = TermBuilder.lte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.launched_before)
-            root = TermBuilder.and_terms(root, term)
-
-        if criteria.scheduled_after is not None:
-            term = TermBuilder.gte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.scheduled_after)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.scheduled_before is not None:
-            term = TermBuilder.lte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.scheduled_before)
-            root = TermBuilder.and_terms(root, term)
-
-        if criteria.shown_in_queue is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.SHOW_IN_QUEUE__FIELD, criteria.shown_in_queue)
-            root = TermBuilder.and_terms(root, term)
-        if criteria.has_experiment is not None:
-            if criteria.has_experiment:
-                term = TermBuilder.not_term(dt, ProcessQueueItemFields.EXPERIMENT__FIELD, None)
-            else:
-                term = TermBuilder.is_term(dt, ProcessQueueItemFields.EXPERIMENT__FIELD, None)
-            root = TermBuilder.and_terms(root, term)
-
-        report_builder.set_root_term(root)
-        return report_builder.build_report_criteria()

sapiopycommons/sftpconnect/sftp_builder.py

@@ -1,69 +0,0 @@
-import io
-from enum import Enum
-
-import paramiko
-from paramiko import pkey
-from paramiko.sftp_client import SFTPClient
-from sapiopycommons.general.exceptions import SapioException
-
-
-class SFTPAuthMethod(Enum):
-    """
-    An enum being used to specify connection type to the target server.
-    """
-    PASSWORD = 0
-    """Connection is being done via Password."""
-    FILEPATH = 1
-    """Connection is being done using a private key file in the codebase."""
-    KEY_STRING = 2
-    """Connection is being done using a private key in string form."""
-
-
-class SFTPBuilder:
-    """
-    A class for making SFTP connections.
-    """
-
-    @staticmethod
-    def open_sftp(username: str, host: str, port: int, authentication: str,
-                  connection_type: SFTPAuthMethod = SFTPAuthMethod.PASSWORD) -> SFTPClient:
-        """
-        Builds a SFTP client from user input.
-
-        :param username: The username of the individual trying to connect to the target server.
-        :param host: The hostname/IP address of the target server.
-        :param port: The port number used to connect to the target server.
-        :param authentication: The string used to connect to the target server. This could hold a filepath, a password
-            or a private key in string form depending on the connection_type parameter.
-
-            If authentication is a private key string, they are generally formated like this:
-            -----BEGIN OPENSSH PRIVATE KEY-----\n
-            asdfh;hjadfh;jghajdg54646+5fasdfadlajklgajd'gj'ajg654564\n
-            asdkjfhj;kghj;ahj;wh41234hjadjkhhdsgadshjkdghjshdlsds468\n
-            ....
-
-        :param connection_type: This enum is used to specify how the connection to the target server is being made.
-            The options are:
-            (0) PASSWORD: This means that the authentication parameter contains a password that will be used to connect to the server
-            (1) FILEPATH: This means that the authentication parameter contains a filepath leading to a private key file stored in the codebase
-            (2) KEY_STRING: This means that the authentication parameter contains the private key in string form
-
-        """
-
-        client = paramiko.SSHClient()
-        client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
-
-        if connection_type == SFTPAuthMethod.FILEPATH:
-            client.connect(host, username=username, port=port, key_filename=authentication)
-            return client.open_sftp()
-
-        if connection_type == SFTPAuthMethod.KEY_STRING:
-            private_key: pkey = paramiko.RSAKey.from_private_key(io.StringIO(authentication))
-            client.connect(host, username=username, port=port, pkey=private_key)
-            return client.open_sftp()
-
-        if connection_type == SFTPAuthMethod.PASSWORD:
-            client.connect(host, username=username, password=authentication, port=port)
-            return client.open_sftp()
-
-        raise SapioException("The SFTPAuthMethod enumerator was not properly specified.")

sapiopycommons/webhook/webhook_context.py

@@ -1,39 +0,0 @@
-import json
-from typing import Any
-
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-
-
-class CustomWebhookContext(SapioWebhookContext):
-    """
-    CustomWebhookContext is a wrapper for the default SapioWebhookContext to be used by custom invocation types to
-    convert the context_data that the server sends from a JSON string to usable parameters. This class works as a
-    middleman to cleanly convert a SapioWebhookContext object into a CustomWebhookContext by copying all the parameters
-    of the given context into the custom context.
-    """
-    def __init__(self, context: SapioWebhookContext):
-        # Use __dict__ so that we don't need t maintain this class due to future changes to SapioWebhookContext.
-        self.__dict__ = context.__dict__
-        super().__init__(self.user, self.end_point_type)
-
-
-class ProcessQueueContext(CustomWebhookContext):
-    """
-    When a custom process queue endpoint is invoked, the context from the queue is sent in a context_data parameter
-    on the SapioWebhookContext object, stored as a JSON string. This class parses that JSON into fields for the
-    caller to make use of.
-    """
-    process_name: str
-    """The name of the process that the user invoked this webhook from."""
-    step_name: str
-    """The name of the step in the process that the user invoked this webhook from."""
-    process_queue_item_record_ids: list[int]
-    """The record IDs of the process queue items related to the records that were selected by the user when this
-    webhook was invoked."""
-
-    def __init__(self, context: SapioWebhookContext):
-        super().__init__(context)
-        context_data: dict[str, Any] = json.loads(self.context_data)
-        self.process_name = context_data["processName"]
-        self.step_name = context_data["workflowName"]
-        self.process_queue_item_record_ids = context_data["processQueueItemRecordIds"]

sapiopycommons/webhook/webservice_handlers.py

@@ -1,67 +0,0 @@
-import sys
-import traceback
-from abc import abstractmethod
-from typing import Any
-
-from flask import request
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.WebhookService import AbstractWebhookHandler
-from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
-
-
-class AbstractWebserviceHandler(AbstractWebhookHandler):
-    """
-    A base class for constructing "webservice" endpoints on your webhook server. These are endpoints that can be
-    communicated with by external sources without needing to format the payload JSON in the webhook context format that
-    webhook handlers expect.
-
-    The entire payload JSON is sent to the run method of this class. It is up to the run method to determine how
-    this JSON should be parsed. In order to communicate with a Sapio system, a SapioUser object must be able to be
-    defined using the payload. Functions have been provided for constructing users with various authentication methods.
-
-    Since this extends AbstractWebhookHandler, you can still register endpoints from this class in the same way you
-    would normal webhook endpoints.
-    """
-    def post(self) -> dict[str, Any]:
-        """
-        Internal method to be executed to translate incoming requests.
-        """
-        # noinspection PyBroadException
-        try:
-            return self.run(request.json).to_json()
-        except Exception:
-            print('Error occurred while running webservice custom logic. See traceback.', file=sys.stderr)
-            traceback.print_exc()
-            return SapioWebhookResult(False, display_text="Error occurred during webservice execution.").to_json()
-
-    @abstractmethod
-    def run(self, payload: dict[str, Any]) -> SapioWebhookResult:
-        pass
-
-    def basic_auth(self, url: str, username: str, password: str) -> SapioUser:
-        """
-        :param url: The URL of the Sapio system that requests from this user will be sent to.
-            Must end in /webservice/api
-        :param username: The username to authenticate requests with.
-        :param password: The password to authenticate requests with.
-        :return: A SapioUser that will authenticate requests using basic auth.
-        """
-        return SapioUser(url, self.verify_sapio_cert, self.client_timeout_seconds, username=username, password=password)
-
-    def api_token_auth(self, url: str, api_token: str) -> SapioUser:
-        """
-        :param url: The URL of the Sapio system that requests from this user will be sent to.
-            Must end in /webservice/api
-        :param api_token: The API token to authenticate requests with.
-        :return: A SapioUser that will authenticate requests using an API token.
-        """
-        return SapioUser(url, self.verify_sapio_cert, self.client_timeout_seconds, api_token=api_token)
-
-    def bearer_token_auth(self, url: str, bearer_token: str) -> SapioUser:
-        """
-        :param url: The URL of the Sapio system that requests from this user will be sent to.
-            Must end in /webservice/api
-        :param bearer_token: The bearer token to authenticate requests with.
-        :return: A SapioUser that will authenticate requests using a bearer token.
-        """
-        return SapioUser(url, self.verify_sapio_cert, self.client_timeout_seconds, bearer_token=bearer_token)

sapiopycommons-2024.11.7a354.dist-info/RECORD

@@ -1,59 +0,0 @@
-sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/callbacks/callback_util.py,sha256=nb6cXK8yFq96gtG0Z2NiK-qdNaRh88bavUH-ZoBjh18,67953
-sapiopycommons/callbacks/field_builder.py,sha256=8n0jcbMgtMUHjie4C1-IkpAuHz4zBxbZtWpr4y0kABU,36868
-sapiopycommons/chem/IndigoMolecules.py,sha256=3f-aig3AJkKJhRmhlQ0cI-5G8oeaQk_3foJTDZCvoko,2040
-sapiopycommons/chem/Molecules.py,sha256=SQKnqdZnhYj_6HGtEZmE_1DormonRR1-nBAQ__z4gms,11485
-sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/customreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/customreport/column_builder.py,sha256=0RO53e9rKPZ07C--KcepN6_tpRw_FxF3O9vdG0ilKG8,3014
-sapiopycommons/customreport/custom_report_builder.py,sha256=Lsy8DQryb7wC9RmEVVLQ6Q74JiNxU-ywFX-m5zL5CSk,6896
-sapiopycommons/customreport/term_builder.py,sha256=oVsr7iFPnug2TrZUCcAMhyps-b62kDodPcBxyQeneUY,16763
-sapiopycommons/datatype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/datatype/attachment_util.py,sha256=_l2swuP8noIGAl4bwzBUEhr6YlN_OVZl3-gi1XqFHYA,3364
-sapiopycommons/datatype/data_fields.py,sha256=g8Ib6LH8ikNu9AzeVJs8Z2qS8A-cplACeFU7vYguNEY,4063
-sapiopycommons/datatype/pseudo_data_types.py,sha256=Fe75Rnq5evyeJM1nC0sLkLGKAC74g2-GEeTdMeId80o,27649
-sapiopycommons/eln/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/eln/experiment_handler.py,sha256=VJPBQSP_4QmhSGDCRDOb5neOjGM6sZ9krvJEmDkpVV8,69282
-sapiopycommons/eln/experiment_report_util.py,sha256=9wWV6oEdKtfn2rI5V0BtmuW9OJlGFd9U07FIf889Gjw,37679
-sapiopycommons/eln/plate_designer.py,sha256=FYJfhhNq8hdfuXgDYOYHy6g0m2zNwQXZWF_MTPzElDg,7184
-sapiopycommons/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/files/complex_data_loader.py,sha256=T39veNhvYl6j_uZjIIJ8Mk5Aa7otR5RB-g8XlAdkksA,1421
-sapiopycommons/files/file_bridge.py,sha256=WwCVegk0OGA8eqho8chsOsLlqg1nXctO75zfh-rHF-g,5950
-sapiopycommons/files/file_bridge_handler.py,sha256=bt2IfIsxJ4lcJYo_NHvCQ17ZV6C4fSAEa8Zcgixh7B4,14263
-sapiopycommons/files/file_data_handler.py,sha256=SCsjODMJIPEBSsahzXUeOM7CfSCmYwPPoGAM6aOfelo,36743
-sapiopycommons/files/file_util.py,sha256=wbL3rxcFc-t2mXaPWWkoFWYGopvTcQts9Wf-L5GkhT8,29498
-sapiopycommons/files/file_validator.py,sha256=4OvY98ueJWPJdpndwnKv2nqVvLP9S2W7Il_dM0Y0ojo,28709
-sapiopycommons/files/file_writer.py,sha256=96Xl8TTT46Krxe_J8rmmlEMtel4nzZB961f5Yqtl1-I,17616
-sapiopycommons/flowcyto/flow_cyto.py,sha256=YlkKJR_zEHYRuNW0bnTqlTyZeXs0lOaeSCfG2fnfD7E,3227
-sapiopycommons/flowcyto/flowcyto_data.py,sha256=mYKFuLbtpJ-EsQxLGtu4tNHVlygTxKixgJxJqD68F58,2596
-sapiopycommons/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/general/accession_service.py,sha256=HYgyOsH_UaoRnoury-c2yTW8SeG4OtjLemdpCzoV4R8,13484
-sapiopycommons/general/aliases.py,sha256=tdDBNWSGx6s39eHJ3n2kscc4xxW3ZYaUfDftct6FmJE,12910
-sapiopycommons/general/audit_log.py,sha256=KQI0AGgN9WLwKqnHE4Tm0xeBCfpVBf8rIQ2HFmnyFGI,8956
-sapiopycommons/general/custom_report_util.py,sha256=BGu9Ki0wn3m4Nk-LKM6inDSfe8ULUSG9d-HJJNOTtGc,15653
-sapiopycommons/general/exceptions.py,sha256=GY7fe0qOgoy4kQVn_Pn3tdzHsJZyNIpa6VCChg6tzuM,1813
-sapiopycommons/general/popup_util.py,sha256=L-4qpTemSZdlD6_6oEsDYIzLOCiZgDK6wC6DqUwzOYA,31925
-sapiopycommons/general/sapio_links.py,sha256=o9Z-8y2rz6AI0Cy6tq58ElPge9RBnisGc9NyccbaJxs,2610
-sapiopycommons/general/storage_util.py,sha256=ovmK_jN7v09BoX07XxwShpBUC5WYQOM7dbKV_VeLXJU,8892
-sapiopycommons/general/time_util.py,sha256=jUAWmQLNcLHZa4UYB4ht_I3d6uoi63VxYdo7T80Ydw0,7458
-sapiopycommons/multimodal/multimodal.py,sha256=A1QsC8QTPmgZyPr7KtMbPRedn2Ie4WIErodUvQ9otgU,6724
-sapiopycommons/multimodal/multimodal_data.py,sha256=t-0uY4cVgm88uXaSOL4ZeB6zmdHufowXuLFlMk61wFg,15087
-sapiopycommons/processtracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/processtracking/custom_workflow_handler.py,sha256=0Si5RQ1YFmqmcZWV8jNDKTffix2iZnQJ6b97fn31pbc,23859
-sapiopycommons/processtracking/endpoints.py,sha256=w5bziI2xC7450M95rCF8JpRwkoni1kEDibyAux9B12Q,10848
-sapiopycommons/recordmodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/recordmodel/record_handler.py,sha256=Uxjrq6f_cWFbqi7KRLySdOvmQGtbIBrCNyStRewqzx8,64751
-sapiopycommons/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/rules/eln_rule_handler.py,sha256=JYzDA_14D2nLnlqwbpIxVOrfKWzbOS27AYf4TQfGr4Q,10469
-sapiopycommons/rules/on_save_rule_handler.py,sha256=Rkqvph20RbNq6m-RF4fbvCP-YfD2CZYBM2iTr3nl0eY,10236
-sapiopycommons/sftpconnect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/sftpconnect/sftp_builder.py,sha256=eKYMiyBc10DNTfbeidQUcfZgFTwhu5ZU-nNJMCK_eos,3014
-sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/webhook/webhook_context.py,sha256=D793uLsb1691SalaPnBUk3rOSxn_hYLhdvkaIxjNXss,1909
-sapiopycommons/webhook/webhook_handlers.py,sha256=JTquLBln49L1pJ9txJ4oc4Hpzy9kYtMKs0m4SLaFx78,18363
-sapiopycommons/webhook/webservice_handlers.py,sha256=1J56zFI0pWl5MHoNTznvcZumITXgAHJMluj8-2BqYEw,3315
-sapiopycommons-2024.11.7a354.dist-info/METADATA,sha256=n4E46KTnsKNHfAy2cPXalibDb5jALEdZVfaveMktPfc,3176
-sapiopycommons-2024.11.7a354.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sapiopycommons-2024.11.7a354.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2024.11.7a354.dist-info/RECORD,,