sapiopycommons 2024.10.25a345__py3-none-any.whl → 2024.10.30a348__py3-none-any.whl

sapiopycommons/general/aliases.py

@@ -6,6 +6,7 @@ from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
 from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol, ElnEntryStep
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
@@ -89,44 +90,50 @@ class AliasUtil:
         return record if isinstance(record, int) else record.record_id
 
     @staticmethod
-    def to_data_type_name(value: DataTypeIdentifier) -> str:
+    def to_data_type_name(value: DataTypeIdentifier, convert_eln_dts: bool = True) -> str:
         """
         Convert a given value to a data type name.
 
         :param value: A value which is a string, record, or record model type.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
         :return: A string of the data type name of the input value.
         """
-        if isinstance(value, str):
-            return value
         if isinstance(value, SapioRecord):
-            return value.data_type_name
-        return value.get_wrapper_data_type_name()
+            value = value.data_type_name
+        elif not isinstance(value, str):
+            value = value.get_wrapper_data_type_name()
+        if convert_eln_dts and ElnBaseDataType.is_eln_type(value):
+            return ElnBaseDataType.get_base_type(value).data_type_name
+        return value
 
     @staticmethod
-    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False) -> list[str] | set[str]:
+    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False,
+                           convert_eln_dts: bool = True) -> list[str] | set[str]:
         """
         Convert a given iterable of values to a list or set of data type names.
 
         :param values: An iterable of values which are strings, records, or record model types.
         :param return_set: If true, return a set instead of a list.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
         :return: A list or set of strings of the data type name of the input value.
         """
-        values = [AliasUtil.to_data_type_name(x) for x in values]
+        values = [AliasUtil.to_data_type_name(x, convert_eln_dts) for x in values]
         return set(values) if return_set else values
 
     @staticmethod
-    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier]) -> str:
+    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier], convert_eln_dts: bool = True) -> str:
         """
         Convert a given iterable of values to a singular data type name that they share. Throws an exception if more
         than one data type name exists in the provided list of identifiers.
 
         :param values: An iterable of values which are strings, records, or record model types.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
         :return: The single data type name that the input vales share. Returns an empty string if an empty iterable
             was provided.
         """
         if not values:
             return ""
-        data_types: set[str] = AliasUtil.to_data_type_names(values, True)
+        data_types: set[str] = AliasUtil.to_data_type_names(values, True, convert_eln_dts)
         if len(data_types) > 1:
             raise SapioException(f"Provided values contain multiple data types: {data_types}. "
                                  f"Only expecting a single data type.")

sapiopycommons/processtracking/custom_workflow_handler.py

@@ -0,0 +1,406 @@
+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/webhook/webhook_context.py

@@ -0,0 +1,39 @@
+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-2024.10.25a345.dist-info → sapiopycommons-2024.10.30a348.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.10.25a345
+Version: 2024.10.30a348
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

{sapiopycommons-2024.10.25a345.dist-info → sapiopycommons-2024.10.30a348.dist-info}/RECORD

@@ -1,19 +1,21 @@
 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=o2O89OrWPm0OYS8Ux6EKZTg6hcUzfz3ZxAgnzJg1wEw,6601
+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=jtJC-ZU8fDud5UD8IVLJZVOqgm8QMkyA1kZZujf3fcg,68454
-sapiopycommons/eln/experiment_report_util.py,sha256=nt-zs6ag1oBAN3NSHcdLBtY1EWxsiI10NfW15xTnn4g,14522
+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
@@ -27,7 +29,7 @@ sapiopycommons/flowcyto/flow_cyto.py,sha256=YlkKJR_zEHYRuNW0bnTqlTyZeXs0lOaeSCfG
 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=eyW5VSK8q5xCjWv9fwd3gKEmK_7pboVLa4DPQpJXpe4,12264
+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
@@ -38,6 +40,7 @@ sapiopycommons/general/time_util.py,sha256=jUAWmQLNcLHZa4UYB4ht_I3d6uoi63VxYdo7T
 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
@@ -47,9 +50,10 @@ sapiopycommons/rules/on_save_rule_handler.py,sha256=Rkqvph20RbNq6m-RF4fbvCP-YfD2
 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.10.25a345.dist-info/METADATA,sha256=SSy4mFChmb1yl1geoOfc81CC9PW0uxqulO8eHqyRDZA,3177
-sapiopycommons-2024.10.25a345.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sapiopycommons-2024.10.25a345.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2024.10.25a345.dist-info/RECORD,,
+sapiopycommons-2024.10.30a348.dist-info/METADATA,sha256=U8UVQE9LmFPyIDkAZka9MQcyFTd7QGBqH7TSlyx2MKE,3177
+sapiopycommons-2024.10.30a348.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+sapiopycommons-2024.10.30a348.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2024.10.30a348.dist-info/RECORD,,