sapiopycommons 2024.8.26a309__py3-none-any.whl → 2024.8.27a312__py3-none-any.whl

sapiopycommons/eln/experiment_handler.py

@@ -1,12 +1,7 @@
-from __future__ import annotations
-
 import time
 from collections.abc import Mapping, Iterable
-from weakref import WeakValueDictionary
 
-from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.ELNService import ElnManager
-from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, TemplateExperimentQueryPojo, ElnTemplate, \
     InitializeNotebookExperimentPojo, ElnExperimentUpdateCriteria
@@ -21,10 +16,8 @@ from sapiopylib.rest.utils.Protocols import ElnEntryStep, ElnExperimentProtocol
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelInstanceManager, RecordModelManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
-from sapiopylib.rest.utils.recordmodel.properties import Child
 
-from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, UserIdentifier, \
-    DataTypeIdentifier, RecordModel
+from sapiopycommons.general.aliases import AliasUtil, SapioRecord
 from sapiopycommons.general.exceptions import SapioException
 
 Step = str | ElnEntryStep
@@ -34,8 +27,7 @@ itself."""
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class ExperimentHandler:
-    user: SapioUser
-    context: SapioWebhookContext | None
+    context: SapioWebhookContext
     """The context that this handler is working from."""
 
     # Basic experiment info from the context.
@@ -85,103 +77,44 @@ class ExperimentHandler:
                                     ElnExperimentStatus.Canceled]
     """The set of statuses that an ELN experiment could have and be considered locked."""
 
-    __instances: WeakValueDictionary[str, ExperimentHandler] = WeakValueDictionary()
-    __initialized: bool
-
-    def __new__(cls, context: UserIdentifier, experiment: ExperimentIdentifier | SapioRecord | None = None):
-        """
-        :param context: The current webhook context or a user object to send requests from.
-        :param experiment: If an experiment is provided that is separate from the experiment that is in the context,
-            that experiment will be used by this ExperimentHandler instead. An experiment can be provided in various
-            forms, including an ElnExperiment, ElnExperimentProtocol, an experiment record, or a notebook experiment ID.
-        """
-        param_results = cls.__parse_params(context, experiment)
-        user = param_results[0]
-        experiment = param_results[2]
-        key = f"{user.__hash__()}:{experiment.notebook_experiment_id}"
-        obj = cls.__instances.get(key)
-        if not obj:
-            obj = object.__new__(cls)
-            obj.__initialized = False
-            cls.__instances[key] = obj
-        return obj
-
-    def __init__(self, context: UserIdentifier, experiment: ExperimentIdentifier | SapioRecord | None = None):
+    def __init__(self, context: SapioWebhookContext, experiment: ElnExperiment | None = None):
         """
         Initialization will throw an exception if there is no ELN Experiment in the provided context and no experiment
         is provided.
 
-        :param context: The current webhook context or a user object to send requests from.
+        :param context: The current webhook context.
         :param experiment: If an experiment is provided that is separate from the experiment that is in the context,
-            that experiment will be used by this ExperimentHandler instead. An experiment can be provided in various
-            forms, including an ElnExperiment, ElnExperimentProtocol, an experiment record, or a notebook experiment ID.
+            that experiment will be used by this ExperimentHandler instead.
         """
-        param_results = self.__parse_params(context, experiment)
-        self.user = param_results[0]
-        self.context = param_results[1]
-        experiment = param_results[2]
+        # FR-46495 - Allow the init function of ExperimentHandler to take in an ElnExperiment that is separate from the
+        # context.
+        if context.eln_experiment is None and experiment is None:
+            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment in the context.")
+        if context.eln_experiment == experiment:
+            experiment = None
+        self.context = context
 
         # Get the basic information about this experiment that already exists in the context and is often used.
-        self.__eln_exp = experiment
-        self.__protocol = ElnExperimentProtocol(experiment, self.user)
+        self.__eln_exp = experiment if experiment else context.eln_experiment
+        self.__protocol = ElnExperimentProtocol(experiment, context.user) if experiment else context.active_protocol
         self.__exp_id = self.__protocol.get_id()
 
         # Grab various managers that may be used.
-        self.__eln_man = DataMgmtServer.get_eln_manager(self.user)
-        self.__inst_man = RecordModelManager(self.user).instance_manager
+        self.__eln_man = context.eln_manager
+        self.__inst_man = RecordModelManager(context.user).instance_manager
 
         # Create empty caches to fill when necessary.
         self.__steps = {}
         self.__step_options = {}
         # CR-46330: Cache any experiment entry information that might already exist in the context.
         self.__queried_all_steps = False
-        # We can only trust the entries in the context if the experiment that this handler is for is the same as the
-        # one from the context.
-        if self.context is not None and self.context.eln_experiment == experiment:
-            if self.context.experiment_entry is not None:
-                self.__steps.update({self.context.active_step.get_name(): self.context.active_step})
-            if self.context.experiment_entry_list is not None:
-                for entry in self.context.experiment_entry_list:
-                    self.__steps.update({entry.entry_name: ElnEntryStep(self.__protocol, entry)})
-
-    @staticmethod
-    def __parse_params(context: UserIdentifier, experiment: ExperimentIdentifier | SapioRecord | None = None) \
-            -> tuple[SapioUser, SapioWebhookContext | None, ElnExperiment]:
-        if isinstance(context, SapioWebhookContext):
-            user = context.user
-            context = context
-        else:
-            user = context
-            context = None
-        if context is not None and context.eln_experiment is not None and experiment is None:
-            experiment = context.eln_experiment
-        # FR-46495 - Allow the init function of ExperimentHandler to take in an ElnExperiment that is separate from the
-        # context.
-        # CR-37038 - Allow other experiment object types to be provided. Convert them all down to ElnExperiment.
-        if (context is None or context.eln_experiment is None) and experiment is not None:
-            eln_manager = DataMgmtServer.get_eln_manager(user)
-            # If this object is already an ElnExperiment, do nothing.
-            if isinstance(experiment, ElnExperiment):
-                pass
-            # If this object is an ElnExperimentProtocol, then we can get the ElnExperiment from the object.
-            elif isinstance(experiment, ElnExperimentProtocol):
-                experiment: ElnExperiment = experiment.eln_experiment
-            # If this object is an integer, assume it is a notebook ID that we can query the system with.
-            elif isinstance(experiment, int):
-                notebook_id: int = experiment
-                experiment: ElnExperiment = eln_manager.get_eln_experiment_by_id(notebook_id)
-                if not experiment:
-                    raise SapioException(f"No experiment with notebook ID {notebook_id} located in the system.")
-            # If this object is a record, assume it is an experiment record that we can query the system with.
-            else:
-                record_id: int = AliasUtil.to_record_ids([experiment])[0]
-                experiment: ElnExperiment = eln_manager.get_eln_experiment_by_record_id(record_id)
-                if not experiment:
-                    raise SapioException(f"No experiment with record ID {record_id} located in the system.")
+        # We can only trust the entries in the context if no experiment was given as an input parameter.
         if experiment is None:
-            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment found in the provided parameters.")
-
-        return user, context, experiment
+            if context.experiment_entry is not None:
+                self.__steps.update({context.active_step.get_name(): context.active_step})
+            if context.experiment_entry_list is not None:
+                for entry in context.experiment_entry_list:
+                    self.__steps.update({entry.entry_name: ElnEntryStep(self.__protocol, entry)})
 
     # FR-46495: Split the creation of the experiment in launch_experiment into a create_experiment function.
     @staticmethod
@@ -330,7 +263,11 @@ class ExperimentHandler:
         :return: The data record for this experiment. None if it has no record.
         """
         if not hasattr(self, "_ExperimentHandler__exp_record"):
-            self.__exp_record = self.__protocol.get_record()
+            drm = self.context.data_record_manager
+            dt = self.__eln_exp.experiment_data_type_name
+            results = drm.query_data_records_by_id(dt, [self.__eln_exp.experiment_record_id]).result_list
+            # PR-46504: Set the exp_record to None if there are no results.
+            self.__exp_record = results[0] if results else None
         if self.__exp_record is None and exception_on_none:
             raise SapioException(f"Experiment record not found for experiment with ID {self.__exp_id}.")
         return self.__exp_record
@@ -530,7 +467,7 @@ class ExperimentHandler:
             ret_list.append(step)
         return ret_list
 
-    def get_all_steps(self, data_type: DataTypeIdentifier | None = None) -> list[ElnEntryStep]:
+    def get_all_steps(self, data_type: str | type[WrappedType] | None = None) -> list[ElnEntryStep]:
         """
         Get a list of every entry in the experiment. Optionally filter the returned entries by a data type.
 
@@ -546,7 +483,8 @@ class ExperimentHandler:
         all_steps: list[ElnEntryStep] = self.__protocol.get_sorted_step_list()
         if data_type is None:
             return all_steps
-        data_type: str = AliasUtil.to_data_type_name(data_type)
+        if not isinstance(data_type, str):
+            data_type: str = data_type.get_wrapper_data_type_name()
         return [x for x in all_steps if data_type in x.get_data_type_names()]
 
     def get_step_records(self, step: Step) -> list[DataRecord]:
@@ -598,10 +536,6 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if dt != step.get_data_type_names()[0]:
-            raise SapioException(f"Cannot add {dt} records to entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
         step.add_records(AliasUtil.to_data_records(records))
 
     def remove_step_records(self, step: Step, records: Iterable[SapioRecord]) -> None:
@@ -620,10 +554,6 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if dt != step.get_data_type_names()[0]:
-            raise SapioException(f"Cannot remove {dt} records from entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
         step.remove_records(AliasUtil.to_data_records(records))
 
     def set_step_records(self, step: Step, records: Iterable[SapioRecord]) -> None:
@@ -647,13 +577,11 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if dt != step.get_data_type_names()[0]:
-            raise SapioException(f"Cannot set {dt} records for entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
         step.set_records(AliasUtil.to_data_records(records))
 
     # FR-46496 - Provide alias of set_step_records for use with form entries.
+    # TODO: Provide a similar aliased function for attachment entries once sapiopylib allows setting multiple
+    #  attachments to an attachment step.
     def set_form_record(self, step: Step, record: SapioRecord) -> None:
         """
         Sets the record for a form entry.
@@ -671,8 +599,7 @@ class ExperimentHandler:
         self.set_step_records(step, [record])
 
     # FR-46496 - Provide functions for adding and removing rows from an ELN data type entry.
-    def add_eln_rows(self, step: Step, count: int, wrapper_type: type[WrappedType] | None = None) \
-            -> list[PyRecordModel | WrappedType]:
+    def add_eln_rows(self, step: Step, count: int) -> list[PyRecordModel]:
         """
         Add rows to an ELNExperimentDetail or ELNSampleDetail table entry. The rows will not appear in the system
         until a record manager store and commit has occurred.
@@ -684,37 +611,15 @@ class ExperimentHandler:
             The step may be provided as either a string for the name of the step or an ElnEntryStep.
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :param count: The number of new rows to add to the entry.
-        :param wrapper_type: Optionally wrap the ELN data type in a record model wrapper. If not provided, returns
-            an unwrapped PyRecordModel.
         :return: A list of the newly created rows.
         """
         step = self.__to_eln_step(step)
         if step.eln_entry.entry_type != ElnEntryType.Table:
             raise SapioException("The provided step is not a table entry.")
         dt: str = step.get_data_type_names()[0]
-        if not ElnBaseDataType.is_eln_type(dt):
+        if not self.__is_eln_type(dt):
             raise SapioException("The provided step is not an ELN data type entry.")
-        records: list[PyRecordModel] = self.__inst_man.add_new_records(dt, count)
-        if wrapper_type:
-            return self.__inst_man.wrap_list(records, wrapper_type)
-        return records
-
-    def add_eln_row(self, step: Step, wrapper_type: type[WrappedType] | None = None) -> PyRecordModel | WrappedType:
-        """
-        Add a row to an ELNExperimentDetail or ELNSampleDetail table entry. The row will not appear in the system
-        until a record manager store and commit has occurred.
-
-        If no step functions have been called before and a step is being searched for by name, queries for the
-        list of steps in the experiment and caches them.
-
-        :param step:
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        :param wrapper_type: Optionally wrap the ELN data type in a record model wrapper. If not provided, returns
-            an unwrapped PyRecordModel.
-        :return: The newly created row.
-        """
-        return self.add_eln_rows(step, 1, wrapper_type)[0]
+        return self.__inst_man.add_new_records(dt, count)
 
     def remove_eln_rows(self, step: Step, records: list[SapioRecord]) -> None:
         """
@@ -736,12 +641,10 @@ class ExperimentHandler:
         """
         step = self.__to_eln_step(step)
         dt: str = step.get_data_type_names()[0]
-        if not ElnBaseDataType.is_eln_type(dt):
+        if not self.__is_eln_type(dt):
             raise SapioException("The provided step is not an ELN data type entry.")
-        record_dt: str = AliasUtil.to_singular_data_type_name(records)
-        if record_dt != dt:
-            raise SapioException(f"Cannot remove {dt} records from entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
+        if any([x.data_type_name != dt for x in records]):
+            raise SapioException("Not all of the provided records match the data type of the step.")
         # If any rows were provided as data records, turn them into record models before deleting them, as otherwise
         # this function would need to make a webservice call to do the deletion.
         data_records: list[DataRecord] = []
@@ -755,59 +658,16 @@ class ExperimentHandler:
             for record in record_models:
                 record.delete()
 
-    def remove_eln_row(self, step: Step, record: SapioRecord) -> None:
-        """
-        Remove a row from an ELNExperimentDetail or ELNSampleDetail table entry. ELN data type table entries display all
-        records in the system that match the entry's data type. This means that removing rows from an ELN data type
-        table entry is equivalent to deleting the records for the rows.
-
-        The row will not be deleted in the system until a record manager store and commit has occurred.
-
-        If no step functions have been called before and a step is being searched for by name, queries for the
-        list of steps in the experiment and caches them.
-
-        :param step:
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        :param record:
-            The record to remove from the given step.
-            The record may be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel.
-        """
-        self.remove_eln_row(step, [record])
-
-    def add_sample_details(self, step: Step, samples: list[RecordModel], wrapper_type: type[WrappedType]) \
-            -> list[PyRecordModel | WrappedType]:
-        """
-        Add sample details to a sample details entry while relating them to the input sample records.
-
-        :param step:
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        :param samples: The sample records to add the sample details to.
-        :param wrapper_type: Optionally wrap the sample details in a record model wrapper. If not provided, returns
-            an unwrapped PyRecordModel.
-        :return: The newly created sample details. The indices of the samples in the input list match the index of the
-            sample details in this list that they are related to.
-        """
-        step = self.__to_eln_step(step)
-        if step.eln_entry.entry_type != ElnEntryType.Table:
-            raise SapioException("The provided step is not a table entry.")
-        dt: str = step.get_data_type_names()[0]
-        if not ElnBaseDataType.is_eln_type(dt) or ElnBaseDataType.get_base_type(dt) != ElnBaseDataType.SAMPLE_DETAIL:
-            raise SapioException("The provided step is not an ELNSampleDetail entry.")
-        records: list[PyRecordModel] = []
-        for sample in samples:
-            if sample.data_type_name != "Sample":
-                raise SapioException(f"Received a {sample.data_type_name} record when Sample records were expected.")
-            detail: PyRecordModel = sample.add(Child.of_type_name(dt))
-            detail.set_field_values({
-                "SampleId": sample.get_field_value("SampleId"),
-                "OtherSampleId": sample.get_field_value("OtherSampleId")
-            })
-            records.append(detail)
-        if wrapper_type:
-            return self.__inst_man.wrap_list(records, wrapper_type)
-        return records
+    # TODO: Remove and use the function of the same name in ElnBaseDataType in the future. Currently this function is
+    #  bugged in sapiopylib and is comparing against base_type.name instead of base_type.value.
+    @staticmethod
+    def __is_eln_type(data_type: str):
+        if data_type is None or not data_type:
+            return False
+        for base_type in ElnBaseDataType:
+            if data_type.lower().startswith(base_type.value.lower()):
+                return True
+        return False
 
     def update_step(self, step: Step,
                     entry_name: str | None = None,
@@ -1096,27 +956,6 @@ class ExperimentHandler:
             step.unlock_step()
             step.eln_entry.entry_status = ExperimentEntryStatus.UnlockedChangesRequired
 
-    def disable_step(self, step: Step) -> None:
-        """
-        Set the status of the input step to Disabled. This is the state that entries are in when they are waiting for
-        entries that they are dependent upon to be submitted before they can be enabled. If you have unsubmitted an
-        entry and want its dependent entries to be locked again, then you would use this to set their status to
-        disabled.
-
-        Makes a webservice call to update the step. Checks if the step is already unlocked, and does nothing if so.
-
-        If no step functions have been called before and a step is being searched for by name, queries for the
-        list of steps in the experiment and caches them.
-
-        :param step:
-            The step to disable.
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        """
-        step = self.__to_eln_step(step)
-        if step.eln_entry.entry_status in self.__ENTRY_LOCKED_STATUSES:
-            self.update_step(step, entry_status=ExperimentEntryStatus.Disabled)
-
     def step_is_submitted(self, step: Step) -> bool:
         """
         Determine if the input step has already been submitted.

sapiopycommons/eln/experiment_report_util.py

@@ -1,10 +1,19 @@
 from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.CustomReport import (
+    CompositeReportTerm,
+    CompositeTermOperation,
+    CustomReportCriteria,
+    ExplicitJoinDefinition,
+    FieldCompareReportTerm,
+    RawReportTerm,
+    RawTermOperation,
+    ReportColumn,
+)
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+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.general.aliases import SapioRecord, UserIdentifier, AliasUtil
+from sapiopycommons.general.aliases import SapioRecord
 from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
@@ -16,8 +25,10 @@ _RECORD_ID = "RECORDID"
 # that given records were used in or getting all records of a datatype used in given experiments.
 class ExperimentReportUtil:
     @staticmethod
-    def map_records_to_experiment_ids(context: UserIdentifier, records: list[SapioRecord]) \
-            -> dict[SapioRecord, list[int]]:
+    def map_records_to_experiment_ids(
+        context: SapioWebhookContext | SapioUser,
+        records: list[SapioRecord],
+    ) -> dict[SapioRecord, list[int]]:
         """
         Return a dictionary mapping each record to a list of ids of experiments that they were used in.
         If a record wasn't used in any experiments then it will be mapped to an empty list.
@@ -29,25 +40,38 @@ class ExperimentReportUtil:
         if not records:
             return {}
 
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        data_type_name: str = AliasUtil.to_singular_data_type_name(records)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+
+        data_type_name = records[0].data_type_name
 
         record_ids = [record.record_id for record in records]
-        rows = ExperimentReportUtil.__get_record_experiment_relation_rows(user, data_type_name, record_ids=record_ids)
+
+        rows = ExperimentReportUtil.__get_record_experiment_relation_rows(
+            user, data_type_name, record_ids=record_ids
+        )
 
         id_to_record: dict[int, SapioRecord] = RecordHandler.map_by_id(records)
-        record_to_exps: dict[SapioRecord, set[int]] = {record: set() for record in records}
+
+        record_to_exps: dict[SapioRecord, set[int]] = {
+            record: set() for record in records
+        }
+
         for row in rows:
             record_id: int = row[_RECORD_ID]
             exp_id: int = row[_NOTEBOOK_ID]
+
             record = id_to_record[record_id]
+
             record_to_exps[record].add(exp_id)
 
         return {record: list(exps) for record, exps in record_to_exps.items()}
 
     @staticmethod
-    def map_experiments_to_records_of_type(context: UserIdentifier, exp_ids: list[int],
-                                           wrapper_type: type[WrappedType]) -> dict[int, list[WrappedType]]:
+    def map_experiments_to_records_of_type(
+        context: SapioWebhookContext | SapioUser,
+        exp_ids: list[int],
+        wrapper_type: type[WrappedType],
+    ) -> dict[int, list[WrappedType]]:
         """
         Return a dictionary mapping each experiment id to a list of records of the given type that were used in each experiment.
         If an experiment didn't use any records of the given type then it will be mapped to an empty list.
@@ -60,27 +84,41 @@ class ExperimentReportUtil:
         if not exp_ids:
             return {}
 
-        user = AliasUtil.to_sapio_user(context)
+        user = context if isinstance(context, SapioUser) else context.user
+
         record_handler = RecordHandler(user)
+
         data_type_name: str = wrapper_type.get_wrapper_data_type_name()
 
-        rows = ExperimentReportUtil.__get_record_experiment_relation_rows(user, data_type_name, exp_ids=exp_ids)
+        rows = ExperimentReportUtil.__get_record_experiment_relation_rows(
+            user, data_type_name, exp_ids=exp_ids
+        )
+
         record_ids: set[int] = {row[_RECORD_ID] for row in rows}
+
         records = record_handler.query_models_by_id(wrapper_type, record_ids)
 
         id_to_record: dict[int, WrappedType] = RecordHandler.map_by_id(records)
+
         exp_to_records: dict[int, set[SapioRecord]] = {exp: set() for exp in exp_ids}
+
         for row in rows:
             record_id: int = row[_RECORD_ID]
             exp_id: int = row[_NOTEBOOK_ID]
+
             record = id_to_record[record_id]
+
             exp_to_records[exp_id].add(record)
 
         return {exp: list(records) for exp, records in exp_to_records.items()}
 
     @staticmethod
-    def __get_record_experiment_relation_rows(user: SapioUser, data_type_name: str, record_ids: list[int] | None = None,
-                                              exp_ids: list[int] | None = None) -> list[dict[str, int]]:
+    def __get_record_experiment_relation_rows(
+        user: SapioUser,
+        data_type_name: str,
+        record_ids: list[int] | None = None,
+        exp_ids: list[int] | None = None,
+    ) -> list[dict[str, int]]:
         """
         Return a list of dicts mapping \"RECORDID\" to the record id and \"EXPERIMENTID\" to the experiment id.
         At least one of record_ids and exp_ids should be provided.
@@ -88,31 +126,89 @@ class ExperimentReportUtil:
         assert (record_ids or exp_ids)
 
         if record_ids:
-            records_term = TermBuilder.is_term(data_type_name, "RECORDID", record_ids)
+            rec_ids = [str(record_id) for record_id in record_ids]
+
+            ids_str = "{" + ", ".join(rec_ids) + "}"
+
+            records_term = RawReportTerm(
+                data_type_name, "RECORDID", RawTermOperation.EQUAL_TO_OPERATOR, ids_str
+            )
+
         else:
             # Get all records of the given type
-            records_term = TermBuilder.all_records_term(data_type_name)
+            records_term = RawReportTerm(
+                data_type_name,
+                "RECORDID",
+                RawTermOperation.GREATER_THAN_OR_EQUAL_OPERATOR,
+                "0",
+            )
 
         if exp_ids:
-            exp_term = TermBuilder.is_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", exp_ids)
+            exp_ids = [str(exp_id) for exp_id in exp_ids]
+
+            ids_str = "{" + ", ".join(exp_ids) + "}"
+
+            exp_term = RawReportTerm(
+                "NOTEBOOKEXPERIMENT",
+                "EXPERIMENTID",
+                RawTermOperation.EQUAL_TO_OPERATOR,
+                ids_str,
+            )
+
         else:
             # Get all experiments
-            exp_term = TermBuilder.gte_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", "0")
-
-        root_term = TermBuilder.and_terms(records_term, exp_term)
+            exp_term = RawReportTerm(
+                "NOTEBOOKEXPERIMENT",
+                "EXPERIMENTID",
+                RawTermOperation.GREATER_THAN_OR_EQUAL_OPERATOR,
+                "0",
+            )
+
+        root_term = CompositeReportTerm(
+            records_term, CompositeTermOperation.AND_OPERATOR, exp_term
+        )
+
+        # The columns the resulting dataframe will have
+        column_list = [
+            ReportColumn(data_type_name, "RECORDID", FieldType.LONG),
+            ReportColumn("NOTEBOOKEXPERIMENT", "EXPERIMENTID", FieldType.LONG),
+        ]
 
         # Join records on the experiment entry records that correspond to them.
-        records_entry_join = TermBuilder.compare_is_term("EXPERIMENTENTRYRECORD", "RECORDID", data_type_name, "RECORDID")
+        records_entry_join = FieldCompareReportTerm(
+            data_type_name,
+            "RECORDID",
+            RawTermOperation.EQUAL_TO_OPERATOR,
+            "EXPERIMENTENTRYRECORD",
+            "RECORDID",
+        )
+
         # Join entry records on the experiment entries they are in.
-        experiment_entry_enb_entry_join = TermBuilder.compare_is_term("ENBENTRY", "ENTRYID", "EXPERIMENTENTRYRECORD", "ENTRYID")
+        experiment_entry_enb_entry_join = FieldCompareReportTerm(
+            "EXPERIMENTENTRYRECORD",
+            "ENTRYID",
+            RawTermOperation.EQUAL_TO_OPERATOR,
+            "ENBENTRY",
+            "ENTRYID",
+        )
+
         # Join entries on the experiments they are in.
-        enb_entry_experiment_join = TermBuilder.compare_is_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", "ENBENTRY", "EXPERIMENTID")
-
-        report_builder = CustomReportBuilder(data_type_name)
-        report_builder.set_root_term(root_term)
-        report_builder.add_column("RECORDID", FieldType.LONG, data_type=data_type_name)
-        report_builder.add_column("EXPERIMENTID", FieldType.LONG, data_type="NOTEBOOKEXPERIMENT")
-        report_builder.add_join(records_entry_join)
-        report_builder.add_join(experiment_entry_enb_entry_join)
-        report_builder.add_join(enb_entry_experiment_join)
-        return CustomReportUtil.run_custom_report(user, report_builder.build_report_criteria())
+        enb_entry_experiment_join = FieldCompareReportTerm(
+            "ENBENTRY",
+            "EXPERIMENTID",
+            RawTermOperation.EQUAL_TO_OPERATOR,
+            "NOTEBOOKEXPERIMENT",
+            "EXPERIMENTID",
+        )
+
+        report_criteria = CustomReportCriteria(
+            column_list,
+            root_term,
+            join_list=[
+                ExplicitJoinDefinition("EXPERIMENTENTRYRECORD", records_entry_join),
+                ExplicitJoinDefinition("ENBENTRY", experiment_entry_enb_entry_join),
+                ExplicitJoinDefinition("NOTEBOOKEXPERIMENT", enb_entry_experiment_join),
+            ],
+        )
+
+        return CustomReportUtil.run_custom_report(user, report_criteria)

sapiopycommons/files/complex_data_loader.py

@@ -1,13 +1,12 @@
 import io
 
 from sapiopylib.rest.User import SapioUser
-
-from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
 
 class CDL:
     @staticmethod
-    def load_cdl(context: UserIdentifier, config_name: str, file_name: str, file_data: bytes | str) \
+    def load_cdl(context: SapioWebhookContext | SapioUser, config_name: str, file_name: str, file_data: bytes | str) \
             -> list[int]:
         """
         Create data records from a file using one of the complex data loader (CDL) configurations in the system.
@@ -23,8 +22,8 @@ class CDL:
             "configName": config_name,
             "fileName": file_name
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        with io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data) as data_stream:
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        with io.StringIO(file_data) if isinstance(file_data, str) else io.BytesIO(file_data) as data_stream:
             response = user.post_data_stream(sub_path, params=params, data_stream=data_stream)
         user.raise_for_status(response)
         # The response content is returned as bytes for a comma separated string of record IDs.