sapiopycommons 2025.7.9a582__py3-none-any.whl → 2025.7.9a583__py3-none-any.whl

sapiopycommons/eln/step_creation.py

@@ -0,0 +1,236 @@
+from typing import Iterable
+
+from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, ExperimentEntryIdentifier
+from sapiopylib.rest.pojo.TableColumn import TableColumn
+from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ExperimentEntryStatus, ElnEntryType
+from sapiopylib.rest.pojo.eln.field_set import ElnFieldSetInfo
+
+
+# CR-47564: Created these classes to streamline entry creation using the ExperimentEntryFactory.
+class StepCreation:
+    """
+    An object that contains the criteria for creating a new entry in the experiment.
+    """
+    _entry_type: ElnEntryType
+    """The type of the entry to be created."""
+    is_shown_in_template: bool | None
+    """Whether the entry will appear in the template if the experiment this entry is in is saved to a new template."""
+    is_removable: bool | None
+    """Whether the entry can be removed by users."""
+    is_renamable: bool | None
+    """Whether the entry can be renamed by users."""
+    is_static_view: bool | None
+    """Whether the entry's attachment is static. For attachment entries only. Static attachment entries will store
+    their attachment data in the template."""
+    related_entry_set: Iterable[ExperimentEntryIdentifier | str] | None
+    """The IDs of the entries this entry is implicitly dependent on. If any of the entries are deleted then this entry
+    is also deleted."""
+    dependency_set: Iterable[ExperimentEntryIdentifier | str] | None
+    """The IDs of the entries this entry is dependent on. Requires the entries to be completed before this entry will
+    be enabled."""
+    requires_grabber_plugin: bool
+    """Whether to run a grabber plugin when this entry is initialized."""
+    entry_singleton_id: str | None
+    """When this field is present (i.e. not null or blank) it will enforce that only one entry with this singleton
+    value is present in the experiment. If you attempt to create an entry with the singletonId of an entry already
+    present in the experiment it will return the existing entry instead of creating a new one. If an entry isn't
+    present in the Notebook Experiment with a matching singletonId it will create a new entry like normal."""
+    is_hidden: bool | None
+    """Whether the user is able to visibly see this entry within the experiment."""
+    entry_height: int | None
+    """The height of this entry in pixels. Setting the height to 0 will cause the entry to auto-size to its contents."""
+    description: str | None
+    """The description of the entry."""
+    is_initialization_required: bool | None
+    """Whether the user must manually initialize this entry by clicking on it."""
+    collapse_entry: bool | None
+    """Whether the entry should be collapsed by default."""
+    entry_status: ExperimentEntryStatus | None
+    """The current status of the entry."""
+    template_item_fulfilled_timestamp: int | None
+    """The time in milliseconds since the epoch that this entry became initialized."""
+    entry_options: dict[str, str] | None
+    """The entry options of the entry."""
+
+    def __init__(self, entry_type: ElnEntryType):
+        self._entry_type = entry_type
+        self.is_shown_in_template = None
+        self.is_removable = None
+        self.is_renamable = None
+        self.is_static_view = None
+        self.related_entry_set = None
+        self.dependency_set = None
+        self.requires_grabber_plugin = False
+        self.entry_singleton_id = None
+        self.is_hidden = None
+        self.entry_height = None
+        self.description = None
+        self.is_initialization_required = None
+        self.collapse_entry = None
+        self.entry_status = None
+        self.template_item_fulfilled_timestamp = None
+        self.entry_options = None
+
+    @property
+    def entry_type(self) -> ElnEntryType:
+        return self._entry_type
+
+class AttachmentStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new attachment entry in an experiment.
+    """
+    def __init__(self):
+        super().__init__(ElnEntryType.Attachment)
+
+
+class DashboardStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new dashboard entry in an experiment.
+    """
+    source_entry: ExperimentEntryIdentifier | str | None
+    """The entry that contains the source data for this entry's dashboard(s)."""
+    dashboard_guids: Iterable[str] | None
+    """The GUIDs of the dashboards to display in this entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Dashboard)
+        self.source_entry = None
+        self.dashboard_guids = None
+
+
+class GlobalDtFormStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new global data type form entry in an experiment.
+    """
+    layout_name: str | None
+    """The name of the data type layout to be displayed in this form. The layout must be for the data type for this
+    entry."""
+    form_names: Iterable[str] | None
+    """The names of the components in the chosen data type layout to display in this form."""
+    extension_types: Iterable[DataTypeIdentifier] | None
+    """The names of the extension data types to display fields from within the form."""
+    field_names: Iterable[FieldIdentifier] | None
+    """A list of data field names for the fields to be displayed in the form."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Form)
+        self.form_names = None
+        self.layout_name = None
+        self.extension_types = None
+        self.field_names = None
+
+
+class ELnDtFormStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new ELN data type form entry in an experiment.
+    """
+    is_field_addable: bool | None
+    """Whether new fields can be added to the entry by users."""
+    is_existing_field_removable: bool | None
+    """Whether existing fields on the entry can be removed by users."""
+    field_sets: Iterable[int | str | ElnFieldSetInfo] | None
+    """The predefined field sets to display in this form."""
+    field_definitions: Iterable[AbstractVeloxFieldDefinition] | None
+    """New field definitions to be created for this entry."""
+    predefined_field_names: Iterable[str] | None
+    """The names of the predefined fields to display in this form."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Form)
+        self.is_field_addable = None
+        self.is_existing_field_removable = None
+        self.field_sets = None
+        self.field_definitions = None
+        self.predefined_field_names = None
+        self.table_columns = None
+
+
+class PluginStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new plugin entry in an experiment.
+    """
+    plugin_name: str | None
+    """The client side plugin name to render this entry with."""
+    using_template_data: bool | None
+    """Whether this entry will use the data from the template."""
+    provides_template_data: bool | None
+    """Whether this entry can provide data to copy into a new template."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Plugin)
+        self.plugin_name = None
+        self.using_template_data = None
+        self.provides_template_data = None
+
+
+class GlobalDtTableStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new global data type table entry in an experiment.
+    """
+    layout_name: str | None
+    """The name of the data type layout to display in this table."""
+    extension_types: Iterable[str] | None
+    """The names of the extension data types to display fields from within the table."""
+    table_columns: Iterable[TableColumn] | None
+    """The columns to display in the table. This can be used to change the sort order and direction of columns."""
+    field_names: Iterable[FieldIdentifier] | None
+    """A list of data field names for the fields to be displayed in the table. These will be added as TableColumns and
+    placed after any of the existing columns specified in the table_columns parameter without any sorting."""
+    show_key_fields: bool | None
+    """Whether the key fields of the data type should be shown in the entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Table)
+        self.layout_name = None
+        self.extension_types = None
+        self.table_columns = None
+        self.field_names = None
+        self.show_key_fields = None
+
+
+class ELnDtTableStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new ELN data type table entry in an experiment.
+    """
+    is_field_addable: bool | None
+    """Whether new fields can be added to the entry by users."""
+    is_existing_field_removable: bool | None
+    """Whether existing fields on the entry can be removed by users."""
+    field_sets: Iterable[int | str | ElnFieldSetInfo] | None
+    """The predefined field sets to display in this form."""
+    field_definitions: Iterable[AbstractVeloxFieldDefinition] | None
+    """New field definitions to be created for this entry."""
+    predefined_field_names: Iterable[str] | None
+    """The names of the predefined fields to display in this form."""
+    table_columns: Iterable[TableColumn] | None
+    """The columns to display in the table."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Table)
+        self.is_field_addable = None
+        self.is_existing_field_removable = None
+        self.field_sets = None
+        self.field_definitions = None
+        self.predefined_field_names = None
+        self.table_columns = None
+
+
+class TempDataStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new temp data entry in an experiment.
+    """
+    plugin_path: str | None
+    """The temp data plugin path to run to populate the entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.TempData)
+        self.plugin_path = None
+
+
+class TextStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new text entry in an experiment.
+    """
+    def __init__(self):
+        super().__init__(ElnEntryType.Text)

sapiopycommons/files/file_util.py

@@ -327,11 +327,13 @@ class FileUtil:
         :param files: A dictionary of file name to file data as a string or bytes.
         :return: The bytes for a zip file containing the input files.
         """
-        zip_buffer: io.BytesIO = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-            for file_name, file_data in files.items():
-                zip_file.writestr(file_name, file_data)
-        return zip_buffer.getvalue()
+        with io.BytesIO() as zip_buffer:
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+                for file_name, file_data in files.items():
+                    zip_file.writestr(file_name, file_data)
+            # PR-47697: Indent the getvalue call into the outer with block. Making the call outside of the with block
+            # throws an I/O exception.
+            return zip_buffer.getvalue()
 
     # Deprecated functions:
 

sapiopycommons/general/accession_service.py

@@ -199,7 +199,7 @@ class AccessionRequestId(AbstractAccessionServiceOperator):
 
     Properties:
         numberOfCharacters: Number of characters maximum in the request ID.
-        accessorName: This is a legacy variable from drum.getNextIdListByMapName(), which allows setting different "accessorName" from old system. We need this for compability patch for converting these to the new preference format.
+        accessorName: This is a legacy variable from drum.getNextIdListByMapName(), which allows setting different "accessorName" from old system. We need this for compatibility patch for converting these to the new preference format.
     """
     _num_of_characters: int
     _accessor_name: str
@@ -341,7 +341,7 @@ class AccessionService:
     def get_affixed_id_in_batch(self, data_type_name: str, data_field_name: str, num_ids: int, prefix: str | None,
                                 suffix: str | None, num_digits: int | None, start_num: int = 1) -> list[str]:
         """
-        Get the batch affixed IDs that are maximal in cache and contiguious for a particular datatype.datafield under a given format.
+        Get the batch affixed IDs that are maximal in cache and contiguous for a particular datatype.datafield under a given format.
         :param data_type_name: The datatype name to look for max ID
         :param data_field_name: The datafield name to look for max ID
         :param num_ids: The number of IDs to accession.

sapiopycommons/general/aliases.py

@@ -219,7 +219,9 @@ class AliasUtil:
             # noinspection PyTypeChecker
             fields: FieldMap = record.get_fields()
         else:
-            fields: FieldMap = record.fields.copy_to_dict()
+            # TI-47593: Copy the record's fields by using the get() method instead of copy_to_dict() so that date
+            # macros get translated to valid field values.
+            fields: FieldMap = {f: record.fields.get(f) for f in record.fields}
         # PR-47457: Only include the record ID if the caller requests it, since including the record ID can break
         # callbacks in certain circumstances if the record ID is negative.
         if include_record_id:

sapiopycommons/general/audit_log.py

@@ -8,6 +8,7 @@ from sapiopycommons.customreport.column_builder import ColumnBuilder
 from sapiopycommons.customreport.term_builder import TermBuilder
 from sapiopycommons.datatype.pseudo_data_types import AuditLogPseudoDef
 from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, UserIdentifier, FieldIdentifier, FieldValue
+from sapiopycommons.general.exceptions import SapioException
 
 
 class EventType(Enum):
@@ -134,6 +135,9 @@ class AuditLogUtil:
         :param fields: The data field names to include changes for.
         :return: The constructed CustomReportCriteria object, which can be used to run a report on the audit log.
         """
+        # PR-47701: Throw an exception if no records are provided.
+        if not records:
+            raise SapioException("No records provided. Please provide at least one record to build a report for.")
         # Build the raw report term querying for any entry with a matching record ID value to the record ID's
         # passed in.
         record_ids = AliasUtil.to_record_ids(records)
@@ -160,6 +164,9 @@ class AuditLogUtil:
         :return: A dictionary where the keys are the record identifiers passed in, and the values are a list of
             AuditLogEntry objects which match the record id value of those records.
         """
+        # PR-47701: Return an empty dictionary if no records are provided.
+        if not records:
+            return {}
         # First, we must build our report criteria for running the Custom Report.
         criteria = AuditLogUtil.create_data_record_audit_log_report(records, fields)
 

sapiopycommons/general/custom_report_util.py

@@ -24,6 +24,12 @@ class CustomReportUtil:
         System reports are also known as predefined searches in the system and must be defined in the data designer for
         a specific data type. That is, saved searches created by users cannot be run using this function.
 
+        IMPORTANT NOTICE: Custom reports that are not single data type (i.e. they have terms or columns from multiple
+        data types) may not be 100% time accurate. Such reports use the system's ancestor table to retrieve the
+        relationships, and this table takes some time to update after relationships are updated, especially for more
+        populous data types. If you need 100% time accurate results to the current state of the records and
+        relationships in the database, you should query for the records directly instead of using a custom report.
+
         :param context: The current webhook context or a user object to send requests from.
         :param report_name: The name of the system report to run.
         :param filters: If provided, filter the results of the report using the given mapping of headers to values to
@@ -63,6 +69,12 @@ class CustomReportUtil:
         results. They are like advanced or predefined searches from the system, except they are constructed from
         within the webhook instead of from within the system.
 
+        IMPORTANT NOTICE: Custom reports that are not single data type (i.e. they have terms or columns from multiple
+        data types) may not be 100% time accurate. Such reports use the system's ancestor table to retrieve the
+        relationships, and this table takes some time to update after relationships are updated, especially for more
+        populous data types. If you need 100% time accurate results to the current state of the records and
+        relationships in the database, you should query for the records directly instead of using a custom report.
+
         :param context: The current webhook context or a user object to send requests from.
         :param report_criteria: The custom report criteria to run.
         :param filters: If provided, filter the results of the report using the given mapping of headers to values to

sapiopycommons/general/data_structure_util.py

@@ -0,0 +1,115 @@
+from enum import Enum
+from typing import Iterable, Any, Collection
+
+from sapiopycommons.general.exceptions import SapioException
+
+
+class ArrayTransformation(Enum):
+    """
+    An enumeration of the different transformations that can be applied to a 2D array.
+    """
+    ROTATE_CLOCKWISE = 0
+    ROTATE_COUNTER_CLOCKWISE = 1
+    ROTATE_180_DEGREES = 2
+    MIRROR_HORIZONTAL = 3
+    MIRROR_VERTICAL = 4
+
+
+# FR-47524: Create a DataStructureUtils class that implements various collection utility functions from our Java
+# libraries.
+class DataStructureUtil:
+    """
+    Utility class for working with data structures. Copies from ListUtil, SetUtil, and various other classes in
+    our Java library.
+    """
+    @staticmethod
+    def find_first_or_none(values: Iterable[Any]) -> Any | None:
+        """
+        Get the first value from an iterable, or None if the iterable is empty.
+
+        :param values: An iterable of values.
+        :return: The first value from the input, or None if the input is empty.
+        """
+        return next(iter(values), None)
+
+    @staticmethod
+    def remove_null_values(values: Iterable[Any]) -> list[Any]:
+        """
+        Remove null values from a list.
+
+        :param values: An iterable of values.
+        :return: A list containing all the non-null values from the input.
+        """
+        return [value for value in values if value is not None]
+
+    @staticmethod
+    def transform_2d_array(values: Collection[Collection[Any]], transformation: ArrayTransformation) \
+            -> Collection[Collection[Any]]:
+        """
+        Perform a transformation on a 2D list.
+
+        :param values: An iterable of iterables. The iterables should all be of the same size.
+        :param transformation: The transformation to apply to the input.
+        :return: A new 2D list containing the input transformed according to the specified transformation.
+        """
+        x: int = len(values)
+        for row in values:
+            y = len(row)
+            if y != x:
+                raise SapioException(f"Input must be a square 2D array. The provided array has a length of {x} but "
+                                     f"at least one row has a length of {y}.")
+
+        match transformation:
+            case ArrayTransformation.ROTATE_CLOCKWISE:
+                return [list(row) for row in zip(*values[::-1])]
+            case ArrayTransformation.ROTATE_COUNTER_CLOCKWISE:
+                return [list(row) for row in zip(*values)][::-1]
+            case ArrayTransformation.ROTATE_180_DEGREES:
+                return [row[::-1] for row in values[::-1]]
+            case ArrayTransformation.MIRROR_HORIZONTAL:
+                return [list(row[::-1]) for row in values]
+            case ArrayTransformation.MIRROR_VERTICAL:
+                return values[::-1]
+
+        raise SapioException(f"Invalid transformation: {transformation}")
+
+    @staticmethod
+    def flatten_to_list(values: Iterable[Iterable[Any]]) -> list[Any]:
+        """
+        Flatten a list of lists into a single list.
+
+        :param values: An iterable of iterables.
+        :return: A single list containing all the values from the input. Elements are in the order they appear in the
+            input.
+        """
+        return [item for sublist in values for item in sublist]
+
+    @staticmethod
+    def flatten_to_set(values: Iterable[Iterable[Any]]) -> set[Any]:
+        """
+        Flatten a list of lists into a single set.
+
+        :param values: An iterable of iterables.
+        :return: A single set containing all the values from the input. Elements are in the order they appear in the
+            input.
+        """
+        return {item for subset in values for item in subset}
+
+    @staticmethod
+    def invert_dictionary(dictionary: dict[Any, Any], list_values: bool = False) \
+            -> dict[Any, Any] | dict[Any, list[Any]]:
+        """
+        Invert a dictionary, swapping keys and values. Note that the values of the input dictionary must be hashable.
+
+        :param dictionary: A dictionary to invert.
+        :param list_values: If false, keys that share the same value in the input dictionary will be overwritten in
+            the output dictionary so that only the last key remains. If true, the values of the output dictionary will
+            be lists where input keys that share the same value will be stored together.
+        :return: A new dictionary with the keys and values swapped.
+        """
+        if list_values:
+            inverted = {}
+            for key, value in dictionary.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+        return {value: key for key, value in dictionary.items()}

sapiopycommons/processtracking/custom_workflow_handler.py

@@ -94,6 +94,9 @@ 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.
+
+    IMPORTANT NOTICE: This is only for custom processes that make use of ProcessQueueItem records. For experiment
+    processes that use AssignedProcess records, see the ProcessTracking class.
     """
     user: SapioUser
     context: ProcessQueueContext | None
@@ -105,7 +108,8 @@ class QueueItemHandler:
         """
         self.user = AliasUtil.to_sapio_user(context)
         self.rec_handler = RecordHandler(self.user)
-        if isinstance(context, SapioWebhookContext):
+        # PR-47565: Only initialize a ProcessQueueContext if the given context object has context_data.
+        if isinstance(context, SapioWebhookContext) and context.context_data:
             self.context = ProcessQueueContext(context)
         else:
             self.context = None
@@ -260,6 +264,9 @@ class QueueItemHandler:
         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.
 
+        IMPORTANT NOTICE: This is only for custom processes that make use of ProcessQueueItem records. For experiment
+        processes that use AssignedProcess records, see the ProcessTracking class.
+
         :param records: The records to create process queue items for.
         :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
@@ -292,6 +299,9 @@ class QueueItemHandler:
         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.
 
+        IMPORTANT NOTICE: This is only for custom processes that make use of ProcessQueueItem records. For experiment
+        processes that use AssignedProcess records, see the ProcessTracking class.
+
         :param records: The records to remove from the queue.
         :param wrapper: The record model wrapper for the process queue items being updated. If not provided, the
             returned records will be PyRecordModels instead of WrappedRecordModels.

sapiopycommons/processtracking/endpoints.py

@@ -5,6 +5,12 @@ from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, Experime
 
 
 class ProcessTracking:
+    """
+    A class for calling the Foundations process tracking endpoints.
+
+    IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+    processes that use ProcessQueueItem records, see the QueueItemHandler class.
+    """
     @staticmethod
     def assign_to_process(context: UserIdentifier, data_type: DataTypeIdentifier, records: list[RecordIdentifier],
                           process_name: str, step_number: int | None = None, branch_id: int | None = None,
@@ -14,6 +20,9 @@ class ProcessTracking:
         at that step.
         Synonymous with what occurs during request creation or when using the assign to process button.
 
+        IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+        processes that use ProcessQueueItem records, see the QueueItemHandler class.
+
         :param context: The current webhook context or a user object to send requests from.
         :param data_type: The data type of the tracked records.
         :param records: A list of the tracked records.
@@ -46,6 +55,9 @@ class ProcessTracking:
         tracked records from "Ready for -" to "In Process -" for their current step.
         Synonymous with what occurs when starting a process step in the system.
 
+        IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+        processes that use ProcessQueueItem records, see the QueueItemHandler class.
+
         :param context: The current webhook context or a user object to send requests from.
         :param data_type: The data type of the tracked records.
         :param records: A list of the tracked records.
@@ -73,6 +85,9 @@ class ProcessTracking:
         Moves the assigned process down to the descendant sample(s) if both samples are provided in the records list.
         Synonymous with what occurs when completing an experiment in the system.
 
+        IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+        processes that use ProcessQueueItem records, see the QueueItemHandler class.
+
         :param context: The current webhook context or a user object to send requests from.
         :param data_type: The data type of the tracked records.
         :param records: A list of the tracked records.
@@ -96,6 +111,9 @@ class ProcessTracking:
         records must be "In Process -" for the given step.
         Synonymous with what occurs when failing a sample due to a QC failure in a process in the system.
 
+        IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+        processes that use ProcessQueueItem records, see the QueueItemHandler class.
+
         :param context: The current webhook context or a user object to send requests from.
         :param data_type: The data type of the tracked records.
         :param records: A list of the tracked records.
@@ -122,6 +140,9 @@ class ProcessTracking:
         will move their status to "Ready for -" for the next step in the process, or "Completed -" if this was the
         last step.
 
+        IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+        processes that use ProcessQueueItem records, see the QueueItemHandler class.
+
         :param context: The current webhook context or a user object to send requests from.
         :param data_type: The data type of the tracked records.
         :param records: A list of the tracked records.
@@ -149,6 +170,9 @@ class ProcessTracking:
         step will move their status to "Ready for -" for the next step in the process, or "Completed -" if this was the
         last step.
 
+        IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+        processes that use ProcessQueueItem records, see the QueueItemHandler class.
+
         :param context: The current webhook context or a user object to send requests from.
         :param data_type: The data type of the tracked records.
         :param records: A list of the tracked records.
@@ -180,6 +204,9 @@ class ProcessTracking:
         Synonymous with what occurs when reprocessing records to a previous step due to QC failures in a process in the
         system.
 
+        IMPORTANT NOTICE: This is only for experiment processes that make use of AssignedProcess records. For custom
+        processes that use ProcessQueueItem records, see the QueueItemHandler class.
+
         :param context: The current webhook context or a user object to send requests from.
         :param records: A list of ReturnPoint records to reprocess to.
         """