sapiopycommons 2025.1.21a408__tar.gz → 2025.2.3a410__tar.gz

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.1.21a408
+Version: 2025.2.3a410
 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-2025.1.21a408 → sapiopycommons-2025.2.3a410}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2025.01.21a408'
+version='2025.02.03a410'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/chem/Molecules.py

@@ -1,6 +1,5 @@
 # Author Yechen Qiao
 # Common Molecule Utilities for Molecule Transfers with Sapio
-from typing import cast
 
 from rdkit import Chem
 from rdkit.Chem import Crippen, MolToInchi
@@ -9,7 +8,6 @@ from rdkit.Chem import rdMolDescriptors
 from rdkit.Chem.EnumerateStereoisomers import StereoEnumerationOptions, EnumerateStereoisomers
 from rdkit.Chem.MolStandardize import rdMolStandardize
 from rdkit.Chem.SaltRemover import SaltRemover
-from rdkit.Chem.rdChemReactions import ChemicalReaction
 from rdkit.Chem.rdchem import Mol, RWMol, Bond
 
 from sapiopycommons.chem.IndigoMolecules import indigo, renderer, indigo_inchi

sapiopycommons-2025.2.3a410/src/sapiopycommons/customreport/auto_pagers.py

@@ -0,0 +1,270 @@
+from abc import ABC
+from copy import copy
+from queue import Queue
+
+from sapiopylib.rest.CustomReportService import CustomReportManager
+from sapiopylib.rest.DataMgmtService import DataMgmtServer
+from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, CustomReport, RawReportTerm, ReportColumn
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+from sapiopylib.rest.utils.autopaging import SapioPyAutoPager, PagerResultCriteriaType, _default_report_page_size, \
+    _default_record_page_size
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
+
+from sapiopycommons.general.aliases import FieldValue, UserIdentifier, AliasUtil, RecordModel
+from sapiopycommons.general.custom_report_util import CustomReportUtil
+from sapiopycommons.general.exceptions import SapioException
+from sapiopycommons.recordmodel.record_handler import RecordHandler
+
+
+# FR-47389: Create auto pagers for running custom/system/quick reports that return dictionaries or records for each row.
+class _DictReportPagerBase(SapioPyAutoPager[CustomReportCriteria, dict[str, FieldValue]], ABC):
+    """
+    A base class for automatically paging through a report and returning the results as a list of dictionaries.
+    """
+    _columns: list[ReportColumn]
+    _report_man: CustomReportManager
+
+    def __init__(self, user: UserIdentifier, first_page_criteria: CustomReportCriteria):
+        self._columns = first_page_criteria.column_list
+        super().__init__(AliasUtil.to_sapio_user(user), first_page_criteria)
+        self._report_man = DataMgmtServer.get_custom_report_manager(self.user)
+
+    def get_all_at_once(self) -> list[dict[str, FieldValue]]:
+        """
+        Get the results of all pages. Be cautious of client memory usage.
+        """
+        if self.has_iterated:
+            raise BrokenPipeError("Cannot use this method if the iterator has already been used.")
+        return [x for x in self]
+
+    def default_first_page_criteria(self) -> PagerResultCriteriaType:
+        raise ValueError("Cannot generate a default first page criteria for custom reports.")
+
+    def get_next_page_result(self) -> tuple[CustomReportCriteria | None, Queue[dict[str, FieldValue]]]:
+        report: CustomReport = self._report_man.run_custom_report(self.next_page_criteria)
+        queue: Queue[dict[str, FieldValue]] = Queue()
+        for row in _process_results(report.result_table, self._columns):
+            queue.put(row)
+        if report.has_next_page:
+            next_page_criteria = copy(self.next_page_criteria)
+            next_page_criteria.page_number += 1
+            return next_page_criteria, queue
+        else:
+            return None, queue
+
+
+class CustomReportDictAutoPager(_DictReportPagerBase):
+    """
+    A class that automatically pages through a custom report and returns the results as a list of dictionaries.
+    """
+    def __init__(self, user: UserIdentifier, report_criteria: CustomReportCriteria,
+                 page_number: int = 0, page_size: int = _default_report_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_criteria: The custom report criteria to run.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = copy(report_criteria)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria)
+
+
+class SystemReportDictAutoPager(_DictReportPagerBase):
+    """
+    A class that automatically pages through a system report and returns the results as a list of dictionaries.
+
+    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.
+    """
+    def __init__(self, user: UserIdentifier, report_name: str,
+                 page_number: int = 0, page_size: int = _default_report_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_name: The name of the system report to run.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_system_report_criteria(user, report_name)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria)
+
+
+class QuickReportDictAutoPager(_DictReportPagerBase):
+    """
+    A class that automatically pages through a quick report and returns the results as a list of dictionaries.
+    """
+    def __init__(self, user: UserIdentifier, report_term: RawReportTerm,
+                 page_number: int = 0, page_size: int = _default_report_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_term: The raw report term to use for the quick report.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_quick_report_criteria(user, report_term)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria)
+
+
+class _RecordReportPagerBase(SapioPyAutoPager[CustomReportCriteria, WrappedType], ABC):
+    """
+    A base class for automatically paging through a report and returning the results as a list of records.
+    """
+    _columns: list[ReportColumn]
+    _wrapper: type[WrappedType]
+    _data_type: str
+    _rec_handler: RecordHandler
+    _report_man: CustomReportManager
+
+    def __init__(self, user: UserIdentifier, first_page_criteria: CustomReportCriteria, wrapper_type: type[WrappedType]):
+        self._columns = first_page_criteria.column_list
+        self._wrapper = wrapper_type
+        self._data_type = wrapper_type.get_wrapper_data_type_name()
+        self._rec_handler = RecordHandler(user)
+        super().__init__(AliasUtil.to_sapio_user(user), first_page_criteria)
+        self._report_man = DataMgmtServer.get_custom_report_manager(self.user)
+
+    def get_all_at_once(self) -> list[RecordModel]:
+        """
+        Get the results of all pages. Be cautious of client memory usage.
+        """
+        if self.has_iterated:
+            raise BrokenPipeError("Cannot use this method if the iterator has already been used.")
+        return [x for x in self]
+
+    def default_first_page_criteria(self) -> PagerResultCriteriaType:
+        raise ValueError("Cannot generate a default first page criteria for custom reports.")
+
+    def get_next_page_result(self) -> tuple[CustomReportCriteria | None, Queue[WrappedType]]:
+        report: CustomReport = self._report_man.run_custom_report(self.next_page_criteria)
+        queue: Queue[WrappedType] = Queue()
+        id_index: int = -1
+        for i, column in enumerate(self._columns):
+            if column.data_type_name == self._data_type and column.data_field_name == "RecordId":
+                id_index = i
+                break
+        if id_index == -1:
+            raise SapioException(f"This report does not contain a Record ID column for the given record model type "
+                                 f"{self._data_type}.")
+        ids: list[int] = [row[id_index] for row in report.result_table]
+        for row in self._rec_handler.query_models_by_id(self._wrapper, ids, page_size=report.page_size):
+            queue.put(row)
+        if report.has_next_page:
+            next_page_criteria = copy(self.next_page_criteria)
+            next_page_criteria.page_number += 1
+            return next_page_criteria, queue
+        else:
+            return None, queue
+
+
+class CustomReportRecordAutoPager(_RecordReportPagerBase):
+    """
+    A class that automatically pages through a custom report and returns the results as a list of records.
+    """
+    def __init__(self, user: UserIdentifier, report_criteria: CustomReportCriteria, wrapper_type: type[WrappedType],
+                 page_number: int = 0, page_size: int = _default_record_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_criteria: The custom report criteria to run.
+        :param wrapper_type: The record model wrapper type to use for the records.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = copy(report_criteria)
+        _add_record_id_column(first_page_criteria, wrapper_type)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria, wrapper_type)
+
+
+class SystemReportRecordAutoPager(_RecordReportPagerBase):
+    """
+    A class that automatically pages through a system report and returns the results as a list of records.
+
+    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.
+    """
+    def __init__(self, user: UserIdentifier, report_name: str, wrapper_type: type[WrappedType],
+                 page_number: int = 0, page_size: int = _default_record_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_name: The name of the system report to run.
+        :param wrapper_type: The record model wrapper type to use for the records.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_system_report_criteria(user, report_name)
+        _add_record_id_column(first_page_criteria, wrapper_type)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria, wrapper_type)
+
+
+class QuickReportRecordAutoPager(_RecordReportPagerBase):
+    """
+    A class that automatically pages through a quick report and returns the results as a list of records.
+    """
+    def __init__(self, user: UserIdentifier, report_term: RawReportTerm, wrapper_type: type[WrappedType],
+                 page_number: int = 0, page_size: int = _default_record_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_term: The raw report term to use for the quick report.
+        :param wrapper_type: The record model wrapper type to use for the records.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        if report_term.data_type_name != wrapper_type.get_wrapper_data_type_name():
+            raise SapioException("The data type name of the report term must match the data type name of the wrapper type.")
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_quick_report_criteria(user, report_term)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria, wrapper_type)
+
+
+def _add_record_id_column(report: CustomReportCriteria, wrapper_type: type[WrappedType]) -> None:
+    """
+    Given a custom report criteria, ensure that the report contains a Record ID column for the given record model's
+    data type. Add one if it is missing.
+    """
+    dt: str = wrapper_type.get_wrapper_data_type_name()
+    # Ensure that the root data type is the one we're looking for.
+    report.root_data_type = dt
+    # Enforce that the given custom report has a record ID column.
+    if not any([x.data_type_name == dt and x.data_field_name == "RecordId" for x in report.column_list]):
+        report.column_list.append(ReportColumn(dt, "RecordId", FieldType.LONG))
+
+
+def _process_results(rows: list[list[FieldValue]], columns: list[ReportColumn]) -> list[dict[str, FieldValue]]:
+    """
+    Given the results of a report as a list of row values and the report's columns, combine these lists to
+    result in a singular list of dictionaries for each row in the results.
+    """
+    # It may be the case that two columns have the same data field name but differing data type names.
+    # If this occurs, then we need to be able to differentiate these columns in the resulting dictionary.
+    prepend_dt: set[str] = set()
+    encountered_names: list[str] = []
+    for column in columns:
+        field_name: str = column.data_field_name
+        if field_name in encountered_names:
+            prepend_dt.add(field_name)
+        else:
+            encountered_names.append(field_name)
+
+    ret: list[dict[str, FieldValue]] = []
+    for row in rows:
+        row_data: dict[str, FieldValue] = {}
+        filter_row: bool = False
+        for value, column in zip(row, columns):
+            header: str = column.data_field_name
+            # If two columns share the same data field name, prepend the data type name of the column to the
+            # data field name.
+            if header in prepend_dt:
+                header = column.data_type_name + "." + header
+            row_data.update({header: value})
+        if filter_row is False:
+            ret.append(row_data)
+    return ret

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/datatype/data_fields.py

@@ -58,4 +58,4 @@ class ProcessWorkflowTrackingFields:
     WORKFLOW_PROCESS_TAT__FIELD = WrapperField("WorkflowProcessTAT", FieldType.DOUBLE)
     WORKFLOW_START_USER_ID__FIELD = WrapperField("WorkflowStartUserId", FieldType.STRING)
     WORKFLOW_TAT__FIELD = WrapperField("WorkflowTAT", FieldType.DOUBLE)
-    WORKFLOW_VERSION__FIELD = WrapperField("WorkflowVersion", FieldType.LONG)
+    WORKFLOW_VERSION__FIELD = WrapperField("WorkflowVersion", FieldType.LONG)

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/eln/experiment_report_util.py

@@ -6,13 +6,13 @@ from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, ElnExperimentQ
 from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnExperimentStatus, ElnBaseDataType
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
+from sapiopycommons.customreport.auto_pagers import CustomReportDictAutoPager
 from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
 from sapiopycommons.customreport.term_builder import TermBuilder
 from sapiopycommons.datatype.pseudo_data_types import EnbEntryOptionsPseudoDef, NotebookExperimentOptionPseudoDef, \
     NotebookExperimentPseudoDef, ExperimentEntryRecordPseudoDef, EnbEntryPseudoDef
 from sapiopycommons.general.aliases import SapioRecord, UserIdentifier, AliasUtil, FieldValue, \
     ExperimentEntryIdentifier, ExperimentIdentifier
-from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
@@ -201,7 +201,7 @@ class ExperimentReportUtil:
         criteria = report_builder.build_report_criteria()
 
         ret_val: dict[SapioRecord, int] = {}
-        rows: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, criteria)
+        rows: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, criteria).get_all_at_once()
         for row in rows:
             dt: str = row[EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME.field_name]
             exp_id: int = row[EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
@@ -268,7 +268,7 @@ class ExperimentReportUtil:
 
         # Ensure that each experiment appears in the dictionary, even if it has no experiment options.
         options: dict[int, dict[str, str]] = {x: {} for x in exp_ids}
-        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
+        results: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, report).get_all_at_once()
         for row in results:
             exp_id: int = row[NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
             key: str = row[NotebookExperimentOptionPseudoDef.OPTION_KEY__FIELD_NAME.field_name]
@@ -299,7 +299,7 @@ class ExperimentReportUtil:
 
         # Ensure that each entry appears in the dictionary, even if it has no entry options.
         options: dict[int, dict[str, str]] = {x: {} for x in entries}
-        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
+        results: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, report).get_all_at_once()
         for row in results:
             entry_id: int = row[EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME.field_name]
             key: str = row[EnbEntryOptionsPseudoDef.ENTRY_OPTION_KEY__FIELD_NAME.field_name]
@@ -332,7 +332,7 @@ class ExperimentReportUtil:
         report = report_builder.build_report_criteria()
 
         ret_val: dict[int, str] = {}
-        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
+        results: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, report).get_all_at_once()
         for row in results:
             exp_id: int = row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
             name: str = row["TemplateExperimentName"]
@@ -581,7 +581,7 @@ class ExperimentReportUtil:
         """
         user = AliasUtil.to_sapio_user(context)
         exp_ids: list[int] = []
-        for row in CustomReportUtil.run_custom_report(user, report):
+        for row in CustomReportDictAutoPager(user, report):
             exp_ids.append(row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name])
         if not exp_ids:
             return []
@@ -646,4 +646,4 @@ class ExperimentReportUtil:
         report_builder.add_join(records_entry_join, ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME)
         report_builder.add_join(experiment_entry_enb_entry_join, EnbEntryPseudoDef.DATA_TYPE_NAME)
         report_builder.add_join(enb_entry_experiment_join, NotebookExperimentPseudoDef.DATA_TYPE_NAME)
-        return CustomReportUtil.run_custom_report(user, report_builder.build_report_criteria())
+        return CustomReportDictAutoPager(user, report_builder.build_report_criteria()).get_all_at_once()

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/files/file_validator.py

@@ -10,9 +10,9 @@ from sapiopylib.rest.pojo.datatype.FieldDefinition import VeloxIntegerFieldDefin
     AbstractVeloxFieldDefinition
 
 from sapiopycommons.callbacks.callback_util import CallbackUtil
+from sapiopycommons.customreport.auto_pagers import QuickReportDictAutoPager
 from sapiopycommons.files.file_data_handler import FileDataHandler, FilterList
 from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
-from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.general.exceptions import SapioUserCancelledException
 from sapiopycommons.general.time_util import TimeUtil
 
@@ -530,7 +530,7 @@ class UniqueSystemValueRule(ColumnRule):
         # Run a quick report for all records of this type that match these field values.
         term = RawReportTerm(self.data_type_name, self.data_field_name, RawTermOperation.EQUAL_TO_OPERATOR,
                              "{" + ",".join(values) + "}")
-        results: list[dict[str, Any]] = CustomReportUtil.run_quick_report(self.user, term)
+        results: list[dict[str, Any]] = QuickReportDictAutoPager(self.user, term).get_all_at_once()
         existing_values: list[Any] = [x.get(self.data_field_name) for x in results]
         return file_handler.get_in_list(self.header, existing_values)
 
@@ -564,6 +564,6 @@ class ExistingSystemValueRule(ColumnRule):
         # Run a quick report for all records of this type that match these field values.
         term = RawReportTerm(self.data_type_name, self.data_field_name, RawTermOperation.EQUAL_TO_OPERATOR,
                              "{" + ",".join(values) + "}")
-        results: list[dict[str, Any]] = CustomReportUtil.run_quick_report(self.user, term)
+        results: list[dict[str, Any]] = QuickReportDictAutoPager(self.user, term).get_all_at_once()
         existing_values: list[Any] = [x.get(self.data_field_name) for x in results]
         return file_handler.get_not_in_list(self.header, existing_values)

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/general/accession_service.py

@@ -95,7 +95,7 @@ class AccessionWithPrefixSuffix(AbstractAccessionServiceOperator):
 
     @property
     def default_accessor_name(self):
-        return "PREFIX_AND_SUFFIX" + "(" + self.prefix + "," + self.suffix + ")";
+        return "PREFIX_AND_SUFFIX" + "(" + self.prefix + "," + self.suffix + ")"
 
 
 class AccessionGlobalPrefixSuffix(AbstractAccessionServiceOperator):

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/general/audit_log.py

@@ -3,11 +3,11 @@ from enum import Enum
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria
 
+from sapiopycommons.customreport.auto_pagers import CustomReportDictAutoPager
 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.custom_report_util import CustomReportUtil
 
 
 class EventType(Enum):
@@ -164,7 +164,7 @@ class AuditLogUtil:
         criteria = AuditLogUtil.create_data_record_audit_log_report(records, fields)
 
         # Then we must run the custom report using that criteria.
-        raw_report_data: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(self.user, criteria)
+        raw_report_data: list[dict[str, FieldValue]] = CustomReportDictAutoPager(self.user, criteria).get_all_at_once()
 
         # This section will prepare a map matching the original RecordIdentifier by record id.
         # This is because the audit log entries will have record ids, but we want the keys in our result map

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/general/custom_report_util.py

@@ -1,3 +1,4 @@
+import warnings
 from collections.abc import Iterable
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
@@ -40,6 +41,7 @@ class CustomReportUtil:
             had a Sample column with a data field name of Identifier and a Request column with the same data field name,
             then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
         """
+        warnings.warn("Deprecated in favor of the SystemReportDictAutoPager class.", DeprecationWarning)
         results: tuple = CustomReportUtil._exhaust_system_report(context, report_name, page_limit,
                                                                  page_size, page_number)
         columns: list[ReportColumn] = results[0]
@@ -82,6 +84,7 @@ class CustomReportUtil:
             had a Sample column with a data field name of Identifier and a Request column with the same data field name,
             then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
         """
+        warnings.warn("Deprecated in favor of the CustomReportDictAutoPager class.", DeprecationWarning)
         results: tuple = CustomReportUtil._exhaust_custom_report(context, report_criteria, page_limit,
                                                                  page_size, page_number)
         columns: list[ReportColumn] = results[0]
@@ -117,6 +120,7 @@ class CustomReportUtil:
         :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
             values in the dicts are the data field names of the columns.
         """
+        warnings.warn("Deprecated in favor of the QuickReportDictAutoPager class.", DeprecationWarning)
         results: tuple = CustomReportUtil._exhaust_quick_report(context, report_term, page_limit,
                                                                 page_size, page_number)
         columns: list[ReportColumn] = results[0]
@@ -127,7 +131,8 @@ class CustomReportUtil:
     def get_system_report_criteria(context: UserIdentifier, report_name: str) -> CustomReport:
         """
         Retrieve a custom report from the system given the name of the report. This works by querying the system report
-        with a page number and size of 1 to minimize the amount of data transfer needed to retrieve the report's config.
+        with a page number of 0 and page size of 1 to minimize the amount of data transfer needed to retrieve the
+        report's config.
 
         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.
@@ -143,6 +148,24 @@ class CustomReportUtil:
         report_man = DataMgmtServer.get_custom_report_manager(user)
         return report_man.run_system_report_by_name(report_name, 1, 0)
 
+    @staticmethod
+    def get_quick_report_criteria(context: UserIdentifier, report_term: RawReportTerm) -> CustomReport:
+        """
+        Retrieve a quick report from the system given a report term. This works by making a quick report query
+        with a page number of 0 and page size of 1 to minimize the amount of data transfer needed to retrieve the
+        report's config.
+
+        Using this, you can add to the root term of the search to then run a new search, or provide it to client
+        callbacks or directives that take CustomReports.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param report_term: The raw report term to use for the quick report.
+        :return: The CustomReport object for the given report term.
+        """
+        user: SapioUser = AliasUtil.to_sapio_user(context)
+        report_man = DataMgmtServer.get_custom_report_manager(user)
+        return report_man.run_quick_report(report_term, 1, 0)
+
     @staticmethod
     def _exhaust_system_report(context: UserIdentifier,
                                report_name: str,

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/multimodal/multimodal.py

@@ -6,6 +6,7 @@ from weakref import WeakValueDictionary
 
 from databind.json import dumps, loads
 from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.DataRecord import DataRecord
 
 from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.multimodal.multimodal_data import *

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/processtracking/custom_workflow_handler.py

@@ -5,10 +5,10 @@ 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.auto_pagers import CustomReportDictAutoPager, CustomReportRecordAutoPager
 from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
 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
@@ -185,7 +185,7 @@ class QueueItemHandler:
         :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)
+        return CustomReportRecordAutoPager(self.user, report, wrapper).get_all_at_once()
 
     def get_records_from_item_report(self, wrapper: type[WrappedType],
                                      criteria: QueueItemReportCriteria = QueueItemReportCriteria()) -> list[WrappedType]:
@@ -203,7 +203,7 @@ class QueueItemHandler:
         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)]
+                                 for x in CustomReportDictAutoPager(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],

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/recordmodel/record_handler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from collections.abc import Iterable
 from weakref import WeakValueDictionary
 
@@ -232,7 +233,7 @@ class RecordHandler:
         :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records mapped in a dictionary by their record ID.
         """
-        return {x.record_id: x for x in self.query_models_by_id(wrapper_type, ids, page_limit, page_size)}
+        return {AliasUtil.to_record_id(x): x for x in self.query_models_by_id(wrapper_type, ids, page_limit, page_size)}
 
     def query_all_models(self, wrapper_type: type[WrappedType], page_limit: int | None = None,
                          page_size: int | None = None) -> list[WrappedType]:
@@ -300,6 +301,7 @@ class RecordHandler:
             not None, in which case it overwrites the given report's value. Note that the number of the first page is 0.
         :return: The record models for the queried records that matched the given report.
         """
+        warnings.warn("Deprecated in favor of the [System/Custom/Quick]ReportRecordAutoPager classes.", DeprecationWarning)
         if isinstance(report_name, str):
             results: list[dict[str, FieldValue]] = CustomReportUtil.run_system_report(self.user, report_name, filters,
                                                                                       page_limit, page_size, page_number)
@@ -893,14 +895,14 @@ class RecordHandler:
 
     @staticmethod
     def values_to_field_maps(field_name: FieldIdentifier, values: Iterable[FieldValue],
-                             existing_fields: list[FieldIdentifier] | None = None) -> list[FieldMap]:
+                             existing_fields: list[FieldMap] | None = None) -> list[FieldMap]:
         """
         Add a list of values for a specific field to a list of dictionaries pairing each value to that field name.
 
         :param field_name: The name of the field that the values are from.
         :param values: A list of field values.
         :param existing_fields: An optional existing fields map list to add the new values to. Values are added in the
-          list in the same order that they appear. If no existing fields are provided, returns a new fields map list.
+            list in the same order that they appear. If no existing fields are provided, returns a new fields map list.
         :return: A fields map list that contains the given values mapped by the given field name.
         """
         # Update the existing fields map list if one is given.

{sapiopycommons-2025.1.21a408 → sapiopycommons-2025.2.3a410}/src/sapiopycommons/flowcyto/flow_cyto.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from weakref import WeakValueDictionary
 
-from sapiopylib.rest.User import SapioUser
 from databind.json import dumps
+from sapiopylib.rest.User import SapioUser
 
 from sapiopycommons.flowcyto.flowcyto_data import FlowJoWorkspaceInputJson, UploadFCSInputJson, \
     ComputeFlowStatisticsInputJson