sapiopycommons 2024.11.8a355__py3-none-any.whl → 2024.11.9a360__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,11 +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.eln.experiment_report_util import ExperimentReportUtil
-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
@@ -35,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.
@@ -57,9 +48,9 @@ class ExperimentHandler:
     # additional queries to obtain, but may also be repeatedly accessed. In such cases, cache the information after it
     # has been requested so that the user doesn't need to worry about caching it themselves.
     # CR-46341: Replace class variables with instance variables.
-    __exp_record: DataRecord | None
+    __exp_record: DataRecord
     """The data record for this experiment. Only cached when first accessed."""
-    __exp_template: ElnTemplate | None
+    __exp_template: ElnTemplate
     """The template for this experiment. Only cached when first accessed."""
     __exp_options: dict[str, str]
     """Experiment options for this experiment. Only cached when first accessed."""
@@ -68,9 +59,9 @@ class ExperimentHandler:
     """Whether this ExperimentHandler has queried the system for all steps in the experiment."""
     __steps: dict[str, ElnEntryStep]
     """Steps from this experiment. All steps are cached the first time any individual step is accessed."""
-    __step_options: dict[int, dict[str, str]]
-    """Entry options for each step in this experiment. All entry options are cached the first time any individual step's
-    options are queried. The cache is updated whenever the entry options for a step are changed by this handler."""
+    __step_options: dict[ElnEntryStep, dict[str, str]]
+    """Entry options for each step in this experiment. Only cached for each individual step when they are first accessed.
+    The cache is updated whenever the entry options for a step are changed by this handler."""
 
     # Constants
     __ENTRY_COMPLETE_STATUSES = [ExperimentEntryStatus.Completed, ExperimentEntryStatus.CompletedApproved]
@@ -86,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
@@ -277,7 +209,6 @@ class ExperimentHandler:
         """
         template_id: int | None = self.__eln_exp.template_id
         if template_id is None:
-            self.__exp_template = None
             if exception_on_none:
                 raise SapioException(f"Experiment with ID {self.__exp_id} has no template ID.")
             return None
@@ -332,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
@@ -532,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.
 
@@ -548,42 +483,10 @@ 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_by_option(self, key: str, value: str | None = None) -> ElnEntryStep:
-        """
-        Retrieve the step in this experiment that contains an entry option with the provided key and value.
-        Throws an exception if no entries or multiple entries in the experiment match.
-
-        :param key: The key of the entry option to match on.
-        :param value: The value of the entry option to match on. If not provided, then only matches on key.
-        :return: The entry in this experiment that matches the provided entry option key and value.
-        """
-        steps: list[ElnEntryStep] = self.get_steps_by_option(key, value)
-        count: int = len(steps)
-        if count != 1:
-            option = key + ("::" + value if value is not None else "")
-            raise SapioException(f"{('No' if count == 0 else 'Multiple')} entries in this experiment match the "
-                                 f"provided option: {option}")
-        return steps[0]
-
-    def get_steps_by_option(self, key: str, value: str | None = None) -> list[ElnEntryStep]:
-        """
-        Retrieve every step in this experiment that contains an entry option with the provided key and value.
-
-        :param key: The key of the entry option to match on.
-        :param value: The value of the entry option to match on. If not provided, then only matches on key.
-        :return: The entries in this experiment that match the provided entry option key and value.
-        """
-        ret_list: list[ElnEntryStep] = []
-        for step in self.get_all_steps():
-            options: dict[str, str] = self.get_step_options(step)
-            if key in options:
-                if value is None or options[key] == value:
-                    ret_list.append(step)
-        return ret_list
-
     def get_step_records(self, step: Step) -> list[DataRecord]:
         """
         Query for the data records for the given step. The returned records are not cached by the ExperimentHandler.
@@ -633,15 +536,6 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        if not records:
-            return
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if ElnBaseDataType.is_base_data_type(dt):
-            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
-                                 f"Use add_eln_rows or add_sample_details instead.")
-        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:
@@ -660,15 +554,6 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        if not records:
-            return
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if ElnBaseDataType.is_base_data_type(dt):
-            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
-                                 f"Use remove_eln_rows or remove_sample_details instead.")
-        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:
@@ -692,17 +577,11 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        if records:
-            dt: str = AliasUtil.to_singular_data_type_name(records)
-            if ElnBaseDataType.is_base_data_type(dt):
-                raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
-                                     f"Use add_eln_rows or add_sample_details instead.")
-            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.
@@ -720,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.
@@ -733,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:
         """
@@ -785,14 +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.")
-        if not records:
-            return
-        record_dt: str = AliasUtil.to_singular_data_type_name(records, False)
-        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] = []
@@ -806,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.create_by_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,
@@ -1010,7 +819,7 @@ class ExperimentHandler:
         if clear_template_item_fulfilled_timestamp is True:
             entry.template_item_fulfilled_timestamp = None
         if entry_options_map is not None:
-            self.__step_options.update({step.get_id(): entry_options_map})
+            self.__step_options.update({step: entry_options_map})
 
     def get_step_option(self, step: Step, option: str) -> str:
         """
@@ -1040,8 +849,8 @@ class ExperimentHandler:
         list of steps in the experiment and caches them.
 
         Getting the step options requires a webservice query, which is made the first time any step option
-        method is called for any step in this experiment. The step options are cached so that subsequent calls of this
-        method don't make a webservice call.
+        method is called for a specific step. The step options are cached so that subsequent calls of this
+        method for that step don't make a webservice call.
 
         :param step:
             The step to get the options of.
@@ -1049,10 +858,7 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :return: The map of options for the input step.
         """
-        step = self.__to_eln_step(step)
-        if step not in self.__step_options:
-            self.__step_options.update(ExperimentReportUtil.get_experiment_entry_options(self.user, self.get_all_steps()))
-        return self.__step_options[step.get_id()]
+        return self.__get_step_options(step)
 
     def add_step_options(self, step: Step, mapping: Mapping[str, str]):
         """
@@ -1150,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.
@@ -1222,3 +1007,16 @@ class ExperimentHandler:
             return self.__exp_options
         self.__exp_options = self.__eln_man.get_notebook_experiment_options(self.__exp_id)
         return self.__exp_options
+
+    def __get_step_options(self, step: Step) -> dict[str, str]:
+        """
+        Cache the options for the input step if they haven't been cached yet.
+
+        :return: The entry options for the input step.
+        """
+        step = self.__to_eln_step(step)
+        if step in self.__step_options:
+            return self.__step_options.get(step)
+        options: dict[str, str] = step.get_options()
+        self.__step_options.update({step: options})
+        return options

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.