sapiopycommons 2025.5.2a504__py3-none-any.whl → 2025.5.6a511__py3-none-any.whl

sapiopycommons/eln/experiment_handler.py

@@ -5,58 +5,46 @@ from collections.abc import Mapping, Iterable
 from typing import TypeAlias
 from weakref import WeakValueDictionary
 
+from sapiopycommons.eln.experiment_cache import ExperimentCacheManager
+from sapiopycommons.eln.experiment_report_util import ExperimentReportUtil
+from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, UserIdentifier, \
+    DataTypeIdentifier, RecordModel, ExperimentEntryIdentifier
+from sapiopycommons.general.exceptions import SapioException
+from sapiopycommons.general.time_util import TimeUtil
+from sapiopycommons.recordmodel.record_handler import RecordHandler
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
-from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.ELNService import ElnManager
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.TableColumn import TableColumn
-from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition
 from sapiopylib.rest.pojo.eln.ElnEntryPosition import ElnEntryPosition
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, TemplateExperimentQueryPojo, ElnTemplate, \
     InitializeNotebookExperimentPojo, ElnExperimentUpdateCriteria
 from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry, ExperimentTableEntry, ExperimentFormEntry, \
     ExperimentAttachmentEntry, ExperimentPluginEntry, ExperimentDashboardEntry, ExperimentTextEntry, \
-    ExperimentTempDataEntry, EntryAttachment, EntryRecordAttachment
+    ExperimentTempDataEntry
 from sapiopylib.rest.pojo.eln.ExperimentEntryCriteria import AbstractElnEntryUpdateCriteria, \
     ElnTableEntryUpdateCriteria, ElnFormEntryUpdateCriteria, ElnAttachmentEntryUpdateCriteria, \
     ElnPluginEntryUpdateCriteria, ElnDashboardEntryUpdateCriteria, ElnTextEntryUpdateCriteria, \
-    ElnTempDataEntryUpdateCriteria, ElnEntryCriteria
+    ElnTempDataEntryUpdateCriteria
 from sapiopylib.rest.pojo.eln.SapioELNEnums import ExperimentEntryStatus, ElnExperimentStatus, ElnEntryType, \
     ElnBaseDataType
 from sapiopylib.rest.pojo.eln.eln_headings import ElnExperimentTab, ElnExperimentTabAddCriteria
-from sapiopylib.rest.pojo.eln.field_set import ElnFieldSetInfo
+from sapiopylib.rest.pojo.eln.protocol_template import ProtocolTemplateInfo
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.pojo.webhook.WebhookDirective import ElnExperimentDirective
 from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
 from sapiopylib.rest.utils.Protocols import ElnEntryStep, ElnExperimentProtocol
-from sapiopylib.rest.utils.plates.MultiLayerPlating import MultiLayerPlateConfig, MultiLayerPlateLayer, \
-    MultiLayerDataTypeConfig, MultiLayerReplicateConfig, MultiLayerDilutionConfig
-from sapiopylib.rest.utils.plates.MultiLayerPlatingUtils import MultiLayerPlatingManager
-from sapiopylib.rest.utils.plates.PlatingUtils import PlatingOrder
 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.datatype.data_fields import SystemFields
-from sapiopycommons.eln.experiment_report_util import ExperimentReportUtil
-from sapiopycommons.eln.experiment_tags import PLATE_DESIGNER_PLUGIN
-from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, UserIdentifier, \
-    DataTypeIdentifier, RecordModel, FieldMap, FieldIdentifier
-from sapiopycommons.general.exceptions import SapioException
-from sapiopycommons.general.time_util import TimeUtil
-from sapiopycommons.recordmodel.record_handler import RecordHandler
-
-Step: TypeAlias = str | ElnEntryStep
-"""An object representing an identifier to an ElnEntryStep. May be either the name of the step or the ElnEntryStep
-itself."""
-Tab: TypeAlias = str | ElnExperimentTab
-"""An object representing an identifier to an ElnExperimentTab. May be either the name of the tab or the
-ElnExperimentTab itself."""
-ElnDataTypeFields: TypeAlias = AbstractVeloxFieldDefinition | ElnFieldSetInfo | str | int
-"""An object representing an identifier to an ElnDataType field. These can be field definitions for ad hoc fields,
-predefined field set info objects, predefined field names, or integers for predefined field set IDs."""
+Step: TypeAlias = str | ExperimentEntryIdentifier
+"""An object representing an identifier to an entry in a particular experiment. This may be the name of the experiment,
+or a typical experiment entry identifier."""
+Tab: TypeAlias = int | str | ElnExperimentTab
+"""An object representing an identifier to a tab in a particular experiment. This may be the tab's order, its name,
+or the tab object itself."""
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -77,6 +65,8 @@ class ExperimentHandler:
     # Managers.
     _eln_man: ElnManager
     """The ELN manager. Used for updating the experiment and its steps."""
+    _exp_cache: ExperimentCacheManager
+    """The experiment cache manager. Used for caching experiment-related information."""
     _inst_man: RecordModelInstanceManager
     """The record model instance manager. Used for wrapping the data records of a step as record models."""
     _rec_handler: RecordHandler
@@ -95,7 +85,9 @@ class ExperimentHandler:
 
     _queried_all_steps: bool
     """Whether this ExperimentHandler has queried the system for all steps in the experiment."""
-    _steps: dict[str, ElnEntryStep]
+    _steps: list[ElnEntryStep]
+    """The sorted list of steps for this experiment. All steps are cached the first time any individual step is accessed."""
+    _steps_by_name: dict[str, ElnEntryStep]
     """Steps from this experiment by their name. All steps are cached the first time any individual step is accessed."""
     _steps_by_id: dict[int, ElnEntryStep]
     """Steps from this experiment by their ID. All steps are cached the first time any individual step is accessed."""
@@ -109,13 +101,12 @@ class ExperimentHandler:
     _queried_all_tabs: bool
     """Whether this ExperimentHandler has queried the system for all tabs in the experiment."""
     _tabs: list[ElnExperimentTab]
-    """The tabs for this experiment. Only cached when first accessed."""
+    """The sorted tabs for this experiment. Only cached when first accessed."""
+    _tabs_by_id: dict[int, ElnExperimentTab]
+    """The tabs for this experiment by their ID. Only cached when first accessed."""
     _tabs_by_name: dict[str, ElnExperimentTab]
     """The tabs for this experiment by their name. Only cached when first accessed."""
 
-    _predefined_fields: dict[str, dict[str, AbstractVeloxFieldDefinition]]
-    """A dictionary of predefined fields for each ELN data type. Only cached when first accessed."""
-
     # Constants
     _ENTRY_COMPLETE_STATUSES = [ExperimentEntryStatus.Completed, ExperimentEntryStatus.CompletedApproved]
     """The set of statuses that an ELN entry could have and be considered completed/submitted."""
@@ -173,17 +164,20 @@ class ExperimentHandler:
 
         # Grab various managers that may be used.
         self._eln_man = DataMgmtServer.get_eln_manager(self.user)
+        self._exp_cache = ExperimentCacheManager(self.user)
         self._inst_man = RecordModelManager(self.user).instance_manager
         self._rec_handler = RecordHandler(self.user)
 
         # Create empty caches to fill when necessary.
         self._queried_all_steps = False
-        self._steps = {}
+        self._steps_by_name = {}
         self._steps_by_id = {}
+        self._steps = []
         self._step_options = {}
         self._step_updates = {}
 
         self._tabs = []
+        self._tabs_by_id = {}
         self._tabs_by_name = {}
 
         self._queried_all_tabs = False
@@ -199,7 +193,8 @@ class ExperimentHandler:
                 for entry in self.context.experiment_entry_list:
                     cache_steps.append(ElnEntryStep(self._protocol, entry))
             for step in cache_steps:
-                self._steps.update({step.get_name(): step})
+                self._steps.append(step)
+                self._steps_by_name.update({step.get_name(): step})
                 self._steps_by_id.update({step.get_id(): step})
 
     @staticmethod
@@ -264,6 +259,7 @@ class ExperimentHandler:
         """
         self._queried_all_steps = False
         self._steps.clear()
+        self._steps_by_name.clear()
         self._steps_by_id.clear()
         self._step_options.clear()
         self._step_updates.clear()
@@ -282,32 +278,39 @@ class ExperimentHandler:
         """
         self._queried_all_tabs = False
         self._tabs.clear()
+        self._tabs_by_id.clear()
         self._tabs_by_name.clear()
 
-    def add_entry_to_caches(self, entry: ExperimentEntry | ElnEntryStep) -> None:
+    def add_entry_to_caches(self, entry: ExperimentEntry | ElnEntryStep) -> ElnEntryStep:
         """
         Add the given entry to the cache of steps for this experiment. This is necessary in order for certain methods to
         work. You should only need to do this if you have created a new entry in your code using a method outside
         of this ExperimentHandler.
 
         :param entry: The entry to add to the cache.
+        :return: The entry that was added to the cache as an ElnEntryStep.
         """
         if isinstance(entry, ExperimentEntry):
             entry = ElnEntryStep(self._protocol, entry)
-        self._steps.update({entry.get_name(): entry})
+        self._steps.append(entry)
+        self._steps_by_name.update({entry.get_name(): entry})
         self._steps_by_id.update({entry.get_id(): entry})
         # Skipping the options cache. The get_step_options method will update the cache when necessary.
+        return entry
 
-    def add_entries_to_caches(self, entries: list[ExperimentEntry | ElnEntryStep]) -> None:
+    def add_entries_to_caches(self, entries: list[ExperimentEntry | ElnEntryStep]) -> list[ElnEntryStep]:
         """
         Add the given entries to the cache of steps for this experiment. This is necessary in order for certain methods
         to work. You should only need to do this if you have created a new entry in your code using a method outside
         of this ExperimentHandler.
 
         :param entries: The entries to add to the cache.
+        :return: The entries that were added to the cache as ElnEntrySteps.
         """
+        new_entries: list[ElnEntryStep] = []
         for entry in entries:
-            self.add_entry_to_caches(entry)
+            new_entries.append(self.add_entry_to_caches(entry))
+        return new_entries
 
     def add_tab_to_cache(self, tab: ElnExperimentTab) -> None:
         """
@@ -319,6 +322,7 @@ class ExperimentHandler:
         """
         self._tabs.append(tab)
         self._tabs.sort(key=lambda t: t.tab_order)
+        self._tabs_by_id[tab.tab_id] = tab
         self._tabs_by_name[tab.tab_name] = tab
 
     # FR-46495: Split the creation of the experiment in launch_experiment into a create_experiment function.
@@ -348,22 +352,10 @@ class ExperimentHandler:
         :param active_templates_only: Whether only active templates should be queried for.
         :return: The newly created experiment.
         """
-        template_query = TemplateExperimentQueryPojo(latest_version_only=(template_version is None),
-                                                     active_templates_only=active_templates_only)
-        templates: list[ElnTemplate] = context.eln_manager.get_template_experiment_list(template_query)
-        launch_template: ElnTemplate | None = None
-        for template in templates:
-            if template.template_name != template_name:
-                continue
-            if template_version is not None and template.template_version != template_version:
-                continue
-            launch_template = template
-            break
-        if launch_template is None:
-            raise SapioException(f"No template with the name \"{template_name}\"" +
-                                 ("" if template_version is None else f" and the version {template_version}") +
-                                 f" found.")
-
+        launch_template: ElnTemplate = ExperimentCacheManager(context).get_experiment_template(template_name,
+                                                                                               active_templates_only,
+                                                                                               template_version,
+                                                                                               first_match=True)
         if experiment_name is None:
             experiment_name: str = launch_template.display_name
         if parent_record is not None:
@@ -590,6 +582,9 @@ class ExperimentHandler:
         """
         Set the experiment's status to Completed. Makes a webservice call to update the experiment. Checks if the
         experiment is already completed, and does nothing if so.
+
+        NOTE: This will cause the usual process tracking logic to run as if you'd clicked the "Complete Experiment"
+        toolbar button. This includes moving the in process samples forward to the next step in the process.
         """
         if not self.experiment_is_complete():
             self._protocol.complete_protocol()
@@ -600,9 +595,11 @@ class ExperimentHandler:
         Set the experiment's status to Canceled. Makes a webservice call to update the experiment. Checks if the
         experiment is already canceled, and does nothing if so.
 
-        NOTE: This will not run the usual logic around canceling an experiment that you'd see if canceling the
-        experiment using the "Cancel Experiment" toolbar button, such as moving in process samples back to the queue,
-        as those changes are tied to the button instead of being on the experiment status change.
+        NOTE: This will cause the usual process tracking logic to run as if you'd clicked the "Cancel Experiment"
+        toolbar button. This includes moving the in process samples back into the process queue for the current step.
+
+        On version 24.12 and earlier, this was not the case, as the process tracking logic was tied to the button
+        instead of being on the experiment status change.
         """
         if not self.experiment_is_canceled():
             self._protocol.cancel_protocol()
@@ -632,14 +629,14 @@ class ExperimentHandler:
         """
         return all([x is not None for x in self.get_steps(step_names, False)])
 
-    def get_step(self, step_name: str, exception_on_none: bool = True) -> ElnEntryStep | None:
+    def get_step(self, step_name: str | int, exception_on_none: bool = True) -> ElnEntryStep | None:
         """
         Get the step of the given name from the experiment.
 
         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_name: The name for the step to return.
+        :param step_name: The name or ID for the step to return.
         :param exception_on_none: If false, returns None if the entry can't be found. If true, raises an exception
             when the named entry doesn't exist in the experiment.
         :return: An ElnEntrySteps matching the provided name. If there is no match and no exception is to be thrown,
@@ -647,31 +644,32 @@ class ExperimentHandler:
         """
         return self.get_steps([step_name], exception_on_none)[0]
 
-    def get_steps(self, step_names: Iterable[str], exception_on_none: bool = True) -> list[ElnEntryStep | None]:
+    def get_steps(self, step_names: Iterable[str | int], exception_on_none: bool = True) -> list[ElnEntryStep | None]:
         """
         Get a list of steps of the given names from the experiment, sorted in the same order as the names are provided.
 
         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_names: A list of names for the entries to return and the order to return them in.
+        :param step_names: A list of names or IDs for the entries to return and the order to return them in.
         :param exception_on_none: If false, returns None for entries that can't be found. If true, raises an exception
             when the named entry doesn't exist in the experiment.
         :return: A list of ElnEntrySteps matching the provided names in the order they were provided in. If there is no
             match for a given step and no exception is to be thrown, returns None for that step.
         """
         ret_list: list[ElnEntryStep | None] = []
-        for name in step_names:
+        for step_id in step_names:
             # If we haven't queried the system for all steps in the experiment yet, then the reason that a step is
             # missing may be because it wasn't in the webhook context. Therefore, query all steps and then check
             # if the step name is still missing from the experiment before potentially throwing an exception.
-            if self._queried_all_steps is False and name not in self._steps:
-                self._queried_all_steps = True
-                self._steps.update({step.get_name(): step for step in self._protocol.get_sorted_step_list()})
-
-            step: ElnEntryStep = self._steps.get(name)
+            if self._queried_all_steps is False and step_id not in self._steps_by_name and step_id not in self._steps_by_id:
+                self._query_all_steps()
+            if isinstance(step_id, str):
+                step: ElnEntryStep = self._steps_by_name.get(step_id)
+            else:
+                step: ElnEntryStep = self._steps_by_id.get(step_id)
             if step is None and exception_on_none is True:
-                raise SapioException(f"ElnEntryStep of name \"{name}\" not found in experiment with ID {self._exp_id}.")
+                raise SapioException(f"ElnEntryStep of name \"{step_id}\" not found in experiment with ID {self._exp_id}.")
             ret_list.append(step)
         return ret_list
 
@@ -686,14 +684,34 @@ class ExperimentHandler:
         :return: Every entry in the experiment in order of appearance that match the provided data type, if any.
         """
         if self._queried_all_steps is False:
-            self._queried_all_steps = True
-            self._steps.update({step.get_name(): step for step in self._protocol.get_sorted_step_list()})
-        all_steps: list[ElnEntryStep] = self._protocol.get_sorted_step_list()
+            self._query_all_steps()
+        else:
+            # Re-sort the steps in case any new steps were added before the last time that this was called.
+            def sort_steps(step: ElnEntryStep) -> tuple:
+                entry = step.eln_entry
+                tab_order: int = self.get_tab_for_step(step).tab_order
+                entry_order: int = entry.order
+                column_order: int = entry.column_order
+                return tab_order, entry_order, column_order
+
+            self._steps.sort(key=sort_steps)
+        all_steps: list[ElnEntryStep] = self._steps
         if data_type is None:
             return all_steps
         data_type: str = AliasUtil.to_data_type_name(data_type)
         return [x for x in all_steps if data_type in x.get_data_type_names()]
 
+    def _query_all_steps(self) -> None:
+        """
+        Query the system for every step in the experiment and cache them.
+        """
+        self._queried_all_steps = True
+        self._protocol.invalidate()
+        self._steps = self._protocol.get_sorted_step_list()
+        for step in self._steps:
+            self._steps_by_name[step.get_name()] = step
+            self._steps_by_id[step.get_id()] = step
+
     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.
@@ -782,8 +800,9 @@ class ExperimentHandler:
             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.")
+            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. ELN "
+                                 f"records that are committed to the system will automatically appear in the ELN entry "
+                                 f"with the matching data type name.")
         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]}.")
@@ -809,8 +828,9 @@ class ExperimentHandler:
             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.")
+            # CR-47532: Add remove_step_records support for Experiment Detail and Sample Detail entries.
+            self.remove_eln_rows(step, records)
+            return
         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]}.")
@@ -839,9 +859,14 @@ class ExperimentHandler:
         step = self.__to_eln_step(step)
         if records:
             dt: str = AliasUtil.to_singular_data_type_name(records)
+            # CR-47532: Add set_step_records support for Experiment Detail and Sample Detail entries.
             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.")
+                remove_rows: list[PyRecordModel] = []
+                for record in self.get_step_models(step):
+                    if record not in records:
+                        remove_rows.append(record)
+                self.remove_eln_rows(step, remove_rows)
+                return
             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]}.")
@@ -868,6 +893,23 @@ class ExperimentHandler:
             step.eln_entry.record_id = AliasUtil.to_data_record(record).record_id
 
     # FR-46496 - Provide functions for adding and removing rows from an ELN data type entry.
+    def add_eln_row(self, step: Step, wrapper_type: type[WrappedType] | None = None) -> WrappedType | PyRecordModel:
+        """
+        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]
+
     def add_eln_rows(self, step: Step, count: int, wrapper_type: type[WrappedType] | None = None) \
             -> list[WrappedType] | list[PyRecordModel]:
         """
@@ -896,10 +938,64 @@ class ExperimentHandler:
             return self._inst_man.wrap_list(records, wrapper_type)
         return records
 
-    def add_eln_row(self, step: Step, wrapper_type: type[WrappedType] | None = None) -> WrappedType | PyRecordModel:
+    def add_sample_detail(self, step: Step, sample: RecordModel,
+                           wrapper_type: type[WrappedType] | None = None) \
+            -> WrappedType | PyRecordModel:
         """
-        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.
+        Add a sample detail to a sample detail entry while relating it to the input sample record.
+
+        :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 sample: The sample record to add the sample detail to.
+        :param wrapper_type: Optionally wrap the sample detail in a record model wrapper. If not provided, returns
+            an unwrapped PyRecordModel.
+        :return: The newly created sample detail.
+        """
+        return self.add_sample_details(step, [sample], wrapper_type)[0]
+
+    def add_sample_details(self, step: Step, samples: Iterable[RecordModel],
+                           wrapper_type: type[WrappedType] | None = None) \
+            -> list[WrappedType] | list[PyRecordModel]:
+        """
+        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
+
+    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.
@@ -907,13 +1003,13 @@ class ExperimentHandler:
         :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.
+        :param record:
+            The record to remove from the given step.
+            The record may be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel.
         """
-        return self.add_eln_rows(step, 1, wrapper_type)[0]
+        self.remove_eln_rows(step, [record])
 
-    def remove_eln_rows(self, step: Step, records: list[SapioRecord]) -> None:
+    def remove_eln_rows(self, step: Step, records: Iterable[SapioRecord]) -> None:
         """
         Remove rows 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
@@ -954,61 +1050,6 @@ 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_rows(step, [record])
-
-    def add_sample_details(self, step: Step, samples: list[RecordModel],
-                           wrapper_type: type[WrappedType] | None = None) \
-            -> list[WrappedType] | list[PyRecordModel]:
-        """
-        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
-
     # noinspection PyPep8Naming
     def update_step(self, step: Step,
                     entry_name: str | None = None,
@@ -1076,128 +1117,45 @@ class ExperimentHandler:
             If you wish to add options to the existing map of options that an entry has, use the
             add_step_options method.
         """
-        # FR-47468: Deprecating this since the parameters are ordered. The new method requires keyword parameters, so
-        # that we can add new parameters wherever we want without breaking existing code.
-        warnings.warn("Update step is deprecated. Use force_entry_update_params instead.",
+        # FR-47468: Deprecating this since the entry-specific update criteria should be used instead.
+        warnings.warn("Update step is deprecated. Use force_entry_update instead.",
                       DeprecationWarning)
-        self.force_step_update_params(step,
-                                      entry_name=entry_name,
-                                      related_entry_set=related_entry_set,
-                                      dependency_set=dependency_set,
-                                      entry_status=entry_status,
-                                      order=order,
-                                      description=description,
-                                      requires_grabber_plugin=requires_grabber_plugin,
-                                      is_initialization_required=is_initialization_required,
-                                      notebook_experiment_tab_id=notebook_experiment_tab_id,
-                                      entry_height=entry_height,
-                                      column_order=column_order,
-                                      column_span=column_span,
-                                      is_removable=is_removable,
-                                      is_renamable=is_renamable,
-                                      source_entry_id=source_entry_id,
-                                      clear_source_entry_id=clear_source_entry_id,
-                                      is_hidden=is_hidden,
-                                      is_static_view=is_static_View,
-                                      is_shown_in_template=is_shown_in_template,
-                                      template_item_fulfilled_timestamp=template_item_fulfilled_timestamp,
-                                      clear_template_item_fulfilled_timestamp=clear_template_item_fulfilled_timestamp,
-                                      entry_options_map=entry_options_map)
-
-    # FR-47468: Some functions that can help with entry updates.
-    def force_step_update_params(self, step: Step, *,
-                                 entry_name: str | None = None,
-                                 related_entry_set: Iterable[int] | None = None,
-                                 dependency_set: Iterable[int] | None = None,
-                                 entry_status: ExperimentEntryStatus | None = None,
-                                 order: int | None = None,
-                                 description: str | None = None,
-                                 requires_grabber_plugin: bool | None = None,
-                                 is_initialization_required: bool | None = None,
-                                 notebook_experiment_tab_id: int | None = None,
-                                 entry_height: int | None = None,
-                                 column_order: int | None = None,
-                                 column_span: int | None = None,
-                                 is_removable: bool | None = None,
-                                 is_renamable: bool | None = None,
-                                 source_entry_id: int | None = None,
-                                 clear_source_entry_id: bool | None = None,
-                                 is_hidden: bool | None = None,
-                                 is_static_view: bool | None = None,
-                                 is_shown_in_template: bool | None = None,
-                                 template_item_fulfilled_timestamp: int | None = None,
-                                 clear_template_item_fulfilled_timestamp: bool | None = None,
-                                 entry_options_map: dict[str, str] | None = None) -> None:
-        """
-        Immediately sent an update to an entry in this experiment. All changes will be reflected by the ExperimentEntry
-        of the Step that is being updated.
+        step: ElnEntryStep = self.__to_eln_step(step)
+        update = AbstractElnEntryUpdateCriteria(step.eln_entry.entry_type)
 
-        Consider using store_step_update and commit_step_updates instead if the update does not need to be immediate.
+        # These two variables could be iterables that aren't lists. Convert them to plain
+        # lists, since that's what the update criteria is expecting.
+        if related_entry_set is not None:
+            related_entry_set = list(related_entry_set)
+        if dependency_set is not None:
+            dependency_set = list(dependency_set)
 
-        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.
+        update.entry_name = entry_name
+        update.related_entry_set = related_entry_set
+        update.dependency_set = dependency_set
+        update.entry_status = entry_status
+        update.order = order
+        update.description = description
+        update.requires_grabber_plugin = requires_grabber_plugin
+        update.is_initialization_required = is_initialization_required
+        update.notebook_experiment_tab_id = notebook_experiment_tab_id
+        update.entry_height = entry_height
+        update.column_order = column_order
+        update.column_span = column_span
+        update.is_removable = is_removable
+        update.is_renamable = is_renamable
+        update.source_entry_id = source_entry_id
+        update.clear_source_entry_id = clear_source_entry_id
+        update.is_hidden = is_hidden
+        update.is_static_View = is_static_View
+        update.is_shown_in_template = is_shown_in_template
+        update.template_item_fulfilled_timestamp = template_item_fulfilled_timestamp
+        update.clear_template_item_fulfilled_timestamp = clear_template_item_fulfilled_timestamp
+        update.entry_options_map = entry_options_map
 
-        :param step:
-            The entry step to update.
-            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 entry_name: The new name of this entry.
-        :param related_entry_set: The new set of entry IDs for the entries that are related (implicitly dependent) to
-            this entry. Completely overwrites the existing related entries.
-        :param dependency_set: The new set of entry IDs for the entries that are dependent (explicitly dependent) on
-            this entry. Completely overwrites the existing dependent entries.
-        :param entry_status: The new status of this entry.
-        :param order: The row order of this entry in its tab.
-        :param description: The new description of this entry.
-        :param requires_grabber_plugin: Whether this entry's initialization is handled by a grabber plugin. If true,
-            then is_initialization_required is forced to true by the server.
-        :param is_initialization_required: Whether the user is required to manually initialize this entry.
-        :param notebook_experiment_tab_id: The ID of the tab that this entry should appear on.
-        :param entry_height: The height of this entry.
-        :param column_order: The column order of this entry.
-        :param column_span: How many columns this entry spans.
-        :param is_removable: Whether this entry can be removed by the user.
-        :param is_renamable: Whether this entry can be renamed by the user.
-        :param source_entry_id: The ID of this entry from its template.
-        :param clear_source_entry_id: True if the source entry ID should be cleared.
-        :param is_hidden: Whether this entry is hidden from the user.
-        :param is_static_view: Whether this entry is static. Static entries are uneditable and shared across all
-            experiments of the same template.
-        :param is_shown_in_template: Whether this entry is saved to and shown in the experiment's template.
-        :param template_item_fulfilled_timestamp: A timestamp in milliseconds for when this entry was initialized.
-        :param clear_template_item_fulfilled_timestamp: True if the template item fulfilled timestamp should be cleared,
-            uninitializing the entry.
-        :param entry_options_map:
-            The new map of options for this entry. Completely overwrites the existing options map.
-            Any changes to the entry options will update this ExperimentHandler's cache of entry options.
-            If you wish to add options to the existing map of options that an entry has, use the
-            add_step_options method.
-        """
-        update = self._criteria_from_params(step,
-                                            entry_name=entry_name,
-                                            related_entry_set=related_entry_set,
-                                            dependency_set=dependency_set,
-                                            entry_status=entry_status,
-                                            order=order,
-                                            description=description,
-                                            requires_grabber_plugin=requires_grabber_plugin,
-                                            is_initialization_required=is_initialization_required,
-                                            notebook_experiment_tab_id=notebook_experiment_tab_id,
-                                            entry_height=entry_height,
-                                            column_order=column_order,
-                                            column_span=column_span,
-                                            is_removable=is_removable,
-                                            is_renamable=is_renamable,
-                                            source_entry_id=source_entry_id,
-                                            clear_source_entry_id=clear_source_entry_id,
-                                            is_hidden=is_hidden,
-                                            is_static_view=is_static_view,
-                                            is_shown_in_template=is_shown_in_template,
-                                            template_item_fulfilled_timestamp=template_item_fulfilled_timestamp,
-                                            clear_template_item_fulfilled_timestamp=clear_template_item_fulfilled_timestamp,
-                                            entry_options_map=entry_options_map)
         self.force_step_update(step, update)
 
+    # FR-47468: Some functions that can help with entry updates.
     def force_step_update(self, step: Step, update: AbstractElnEntryUpdateCriteria) -> None:
         """
         Immediately sent an update to an entry in this experiment. All changes will be reflected by the ExperimentEntry
@@ -1269,67 +1227,6 @@ class ExperimentHandler:
             self._update_entry_details(self._steps_by_id[step_id], criteria)
         self._step_updates.clear()
 
-    def _criteria_from_params(self, step: Step, *,
-                              entry_name: str | None = None,
-                              related_entry_set: Iterable[int] | None = None,
-                              dependency_set: Iterable[int] | None = None,
-                              entry_status: ExperimentEntryStatus | None = None,
-                              order: int | None = None,
-                              description: str | None = None,
-                              requires_grabber_plugin: bool | None = None,
-                              is_initialization_required: bool | None = None,
-                              notebook_experiment_tab_id: int | None = None,
-                              entry_height: int | None = None,
-                              column_order: int | None = None,
-                              column_span: int | None = None,
-                              is_removable: bool | None = None,
-                              is_renamable: bool | None = None,
-                              source_entry_id: int | None = None,
-                              clear_source_entry_id: bool | None = None,
-                              is_hidden: bool | None = None,
-                              is_static_view: bool | None = None,
-                              is_shown_in_template: bool | None = None,
-                              template_item_fulfilled_timestamp: int | None = None,
-                              clear_template_item_fulfilled_timestamp: bool | None = None,
-                              entry_options_map: dict[str, str] | None = None) -> AbstractElnEntryUpdateCriteria:
-        """
-        Create an abstract update criteria object from the provided parameters for the given step.
-        """
-        step: ElnEntryStep = self.__to_eln_step(step)
-        update = AbstractElnEntryUpdateCriteria(step.eln_entry.entry_type)
-
-        # These two variables could be iterables that aren't lists. Convert them to plain
-        # lists, since that's what the update criteria is expecting.
-        if related_entry_set is not None:
-            related_entry_set = list(related_entry_set)
-        if dependency_set is not None:
-            dependency_set = list(dependency_set)
-
-        update.entry_name = entry_name
-        update.related_entry_set = related_entry_set
-        update.dependency_set = dependency_set
-        update.entry_status = entry_status
-        update.order = order
-        update.description = description
-        update.requires_grabber_plugin = requires_grabber_plugin
-        update.is_initialization_required = is_initialization_required
-        update.notebook_experiment_tab_id = notebook_experiment_tab_id
-        update.entry_height = entry_height
-        update.column_order = column_order
-        update.column_span = column_span
-        update.is_removable = is_removable
-        update.is_renamable = is_renamable
-        update.source_entry_id = source_entry_id
-        update.clear_source_entry_id = clear_source_entry_id
-        update.is_hidden = is_hidden
-        update.is_static_View = is_static_view
-        update.is_shown_in_template = is_shown_in_template
-        update.template_item_fulfilled_timestamp = template_item_fulfilled_timestamp
-        update.clear_template_item_fulfilled_timestamp = clear_template_item_fulfilled_timestamp
-        update.entry_options_map = entry_options_map
-
-        return update
-
     @staticmethod
     def _merge_updates(new_update: AbstractElnEntryUpdateCriteria, old_update: AbstractElnEntryUpdateCriteria) -> None:
         """
@@ -1347,10 +1244,10 @@ class ExperimentHandler:
         entry: ExperimentEntry = step.eln_entry
         if update.entry_name is not None:
             # PR-46477 - Ensure that the previous name of the updated entry already existed in the cache.
-            if entry.entry_name in self._steps:
-                self._steps.pop(entry.entry_name)
+            if entry.entry_name in self._steps_by_name:
+                self._steps_by_name.pop(entry.entry_name)
             entry.entry_name = update.entry_name
-            self._steps.update({update.entry_name: step})
+            self._steps_by_name.update({update.entry_name: step})
         if update.related_entry_set is not None:
             entry.related_entry_id_set = update.related_entry_set
         if update.dependency_set is not None:
@@ -1514,12 +1411,14 @@ 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 mapping: The new options and values to add to the existing step options, provided as some Mapping
-            (e.g. a Dict). If an option key already exists and is provided in the mapping, overwrites the existing value
-            for that key.
+            (e.g. a dictionary). If an option key already exists and is provided in the mapping, overwrites the existing
+            value for that key.
         """
         options: dict[str, str] = self.get_step_options(step)
         options.update(mapping)
-        self.force_step_update_params(step, entry_options_map=options)
+        update = AbstractElnEntryUpdateCriteria(step.eln_entry.entry_type)
+        update.entry_options_map = options
+        self.force_step_update(step, update)
 
     def initialize_step(self, step: Step) -> None:
         """
@@ -1537,7 +1436,9 @@ class ExperimentHandler:
         # Avoid unnecessary calls if the step is already initialized.
         step: ElnEntryStep = self.__to_eln_step(step)
         if step.eln_entry.template_item_fulfilled_timestamp is None:
-            self.force_step_update_params(step, template_item_fulfilled_timestamp=TimeUtil.now_in_millis())
+            update = AbstractElnEntryUpdateCriteria(step.eln_entry.entry_type)
+            update.template_item_fulfilled_timestamp = TimeUtil.now_in_millis()
+            self.force_step_update(step, update)
 
     def uninitialize_step(self, step: Step) -> None:
         """
@@ -1555,7 +1456,9 @@ class ExperimentHandler:
         # Avoid unnecessary calls if the step is already uninitialized.
         step: ElnEntryStep = self.__to_eln_step(step)
         if step.eln_entry.template_item_fulfilled_timestamp is not None:
-            self.force_step_update_params(step, clear_template_item_fulfilled_timestamp=True)
+            update = AbstractElnEntryUpdateCriteria(step.eln_entry.entry_type)
+            update.clear_template_item_fulfilled_timestamp = True
+            self.force_step_update(step, update)
 
     def complete_step(self, step: Step) -> None:
         """
@@ -1612,7 +1515,9 @@ class ExperimentHandler:
         """
         step = self.__to_eln_step(step)
         if step.eln_entry.entry_status in self._ENTRY_LOCKED_STATUSES:
-            self.force_step_update_params(step, entry_status=ExperimentEntryStatus.Disabled)
+            update = AbstractElnEntryUpdateCriteria(step.eln_entry.entry_type)
+            update.entry_status = ExperimentEntryStatus.Disabled
+            self.force_step_update(step, update)
 
     def step_is_submitted(self, step: Step) -> bool:
         """
@@ -1656,6 +1561,7 @@ class ExperimentHandler:
         if not self._queried_all_tabs:
             self._tabs = self._eln_man.get_tabs_for_experiment(self._exp_id)
             self._tabs.sort(key=lambda t: t.tab_order)
+            self._tabs_by_id = {tab.tab_id: tab for tab in self._tabs}
             self._tabs_by_name = {tab.tab_name: tab for tab in self._tabs}
         return self._tabs
 
@@ -1689,21 +1595,34 @@ class ExperimentHandler:
         self.add_tab_to_cache(tab)
         return tab
 
-    def get_tab(self, tab_name: str) -> ElnExperimentTab:
+    def get_tab(self, tab: str | int, exception_on_none: bool = True) -> ElnExperimentTab:
         """
         Return the tab with the input name.
 
         If no tab functions have been called before and a tab is being searched for by name, queries for the
         list of tabs in the experiment and caches them.
 
-        :param tab_name: The name of the tab to get.
-        :return: The tab with the input name.
-        """
-        if tab_name not in self._tabs_by_name:
-            self.get_all_tabs()
-        return self._tabs_by_name[tab_name]
+        :param tab: The name or order of the tab to get. The order is 1-indexed.
+        :param exception_on_none: If True, raises an exception if no tab with the given name exists.
+        :return: The tab with the input name, or None if no such tab exists.
+        """
+        if isinstance(tab, str):
+            if tab not in self._tabs_by_name:
+                self.get_all_tabs()
+            eln_tab = self._tabs_by_name.get(tab)
+        elif isinstance(tab, int):
+            # The given integer is expected to be 1-indexed, but we read from the list with a 0-index.
+            tab -= 1
+            tabs = self.get_all_tabs()
+            eln_tab = tabs[tab] if len(tabs) > tab else None
+        else:
+            raise SapioException(f"Tab must be a string or an integer, not {type(tab)}.")
+        if eln_tab is None and exception_on_none:
+            raise SapioException(f"No tab with the name\\order \"{tab}\" exists in this experiment.")
+        return eln_tab
 
-    def get_steps_in_tab(self, tab: Tab, data_type: DataTypeIdentifier | None = None) -> list[ElnEntryStep]:
+    def get_steps_in_tab(self, tab: Tab, data_type: DataTypeIdentifier | None = None) \
+            -> list[ElnEntryStep]:
         """
         Get all the steps in the input tab sorted in order of appearance.
 
@@ -1713,7 +1632,8 @@ class ExperimentHandler:
         If the steps in the experiment have not been queried before, queries for the list of steps in the experiment
         and caches them.
 
-        :param tab: The tab or tab name to get the steps of.
+        :param tab: The tab to get the steps of. This can be the tab's order, name, or the tab object itself.
+            The order is 1-indexed.
         :param data_type: The data type to filter the steps by. If None, all steps are returned.
         :return: A list of all the steps in the input tab sorted in order of appearance.
         """
@@ -1722,9 +1642,30 @@ class ExperimentHandler:
         for step in self.get_all_steps(data_type):
             if step.eln_entry.notebook_experiment_tab_id == tab.tab_id:
                 steps.append(step)
-        steps.sort(key=lambda s: (s.eln_entry.order, s.eln_entry.column_order))
         return steps
 
+    def get_tab_for_step(self, step: Step) -> ElnExperimentTab:
+        """
+        Get the tab that a particular step is located in.
+
+        If no tab functions have been called before and a tab is being searched for by name, queries for the
+        list of tabs in the experiment and caches them.
+
+        If the steps in the experiment have not been queried before, queries for the list of steps in the experiment
+        and caches them.
+
+        :param step:
+            The step to get the position of.
+            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.
+        :return: The tab that the input step is located in.
+        """
+        step = self.__to_eln_step(step)
+        tab_id = step.eln_entry.notebook_experiment_tab_id
+        if tab_id not in self._tabs_by_id:
+            self.get_all_tabs()
+        return self._tabs_by_id.get(tab_id)
+
     def get_next_entry_order_in_tab(self, tab: Tab) -> int:
         """
         Get the next available order for a new entry in the input tab.
@@ -1735,402 +1676,70 @@ class ExperimentHandler:
         If the steps in the experiment have not been queried before, queries for the list of steps in the experiment
         and caches them.
 
-        :param tab: The tab or tab name to get the steps of.
+        :param tab: The tab to get the steps of. This can be the tab's order, name, or the tab object itself.
+            The order is 1-indexed.
         :return: The next available order for a new entry in the input tab.
         """
         steps = self.get_steps_in_tab(tab)
         return steps[-1].eln_entry.order + 1 if steps else 0
 
-    # FR-47468: Add functions for creating new entries in the experiment.
-    def create_attachment_step(self, entry_name: str, data_type: DataTypeIdentifier,
-                               *,
-                               position: ElnEntryPosition | None = None,
-                               attachments: list[EntryAttachment] | list[SapioRecord] | None = None) -> ElnEntryStep:
-        """
-        Create a new attachment entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param position: Information about where to place the entry in the experiment.
-        :param attachments: The list of attachments to initially populate the entry with.
-        :return: The newly created attachment entry.
-        """
-        step = self._create_step(ElnEntryType.Attachment, entry_name, data_type, position)
-        if attachments:
-            entry_attachments: list[EntryAttachment] = []
-            for entry in attachments:
-                if isinstance(entry, EntryAttachment):
-                    entry_attachments.append(entry)
-                elif isinstance(entry, SapioRecord):
-                    entry: SapioRecord
-                    file_name: str = entry.get_field_value("FilePath")
-                    if not file_name:
-                        file_name = entry.get_field_value(SystemFields.DATA_RECORD_NAME__FIELD.field_name)
-                    rec_id: int = AliasUtil.to_record_id(entry)
-                    entry_attachments.append(EntryRecordAttachment(file_name, rec_id))
-                else:
-                    raise SapioException("Attachments must be of type EntryAttachment or SapioRecord.")
-            update = ElnAttachmentEntryUpdateCriteria()
-            update.entry_attachment_list = attachments
-            self.force_step_update(step, update)
-        return step
-
-    def create_form_step(self, entry_name: str,
-                         data_type: DataTypeIdentifier,
-                         fields: list[FieldIdentifier] | None = None,
-                         layout_name: str | None = None,
-                         form_names: list[str] | None = None,
-                         *,
-                         position: ElnEntryPosition | None = None,
-                         record: SapioRecord | None = None) -> ElnEntryStep:
-        """
-        Create a new form entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param fields: The list of data field names for the given data type that should appear on the
-            form. Fields will appear in the order they are provided. If not provided and a layout name is not provided,
-            the entry will be created with the data type's default layout.
-        :param layout_name: The name of the layout to use for the entry. If not provided and field names are not
-            provided, the entry will be created with the data type's default layout.
-        :param form_names: The list of layout component form names to use from the specified layout name. If not
-            provided, then all available forms from the specified layout will be used.
-        :param position: Information about where to place the entry in the experiment.
-        :param record: The record to initially populate the entry with.
-        :return: The newly created form entry.
-        """
-        if record:
-            rdt: str = AliasUtil.to_data_type_name(record)
-            sdt: str = AliasUtil.to_data_type_name(data_type)
-            if rdt != sdt:
-                raise SapioException(f"Cannot set {rdt} records for entry {entry_name} of type "
-                                     f"{sdt}.")
-
-        step = self._create_step(ElnEntryType.Form, entry_name, data_type, position)
-        if fields or layout_name or form_names or record:
-            update = ElnFormEntryUpdateCriteria()
-            if fields:
-                update.data_field_name_list = AliasUtil.to_data_field_names(fields)
-            update.data_type_layout_name = layout_name
-            update.form_name_list = form_names
-            if record:
-                update.record_id = AliasUtil.to_record_id(record)
-            self.force_step_update(step, update)
-        return step
-
-    def create_experiment_detail_form_step(self, entry_name: str,
-                                           fields: list[ElnDataTypeFields] | None = None,
-                                           field_map: FieldMap | None = None,
-                                           *,
-                                           position: ElnEntryPosition | None = None,
-                                           is_field_addable: bool | None = None,
-                                           is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN experiment details form entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_map: A field map that will be used to populate the entry. The data field names in
-            the map must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created form entry.
-        """
-        return self._create_eln_dt_form_step(entry_name, ElnBaseDataType.EXPERIMENT_DETAIL, fields, field_map,
-                                             position=position,
-                                             is_field_addable=is_field_addable,
-                                             is_existing_field_removable=is_existing_field_removable)
-
-    def create_sample_detail_form_step(self, entry_name: str,
-                                       fields: list[ElnDataTypeFields] | None = None,
-                                       field_map: FieldMap | None = None,
-                                       *,
-                                       position: ElnEntryPosition | None = None,
-                                       is_field_addable: bool | None = None,
-                                       is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN sample details form entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_map: A field map that will be used to populate the entry. The data field names in
-            the map must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created form entry.
-        """
-        return self._create_eln_dt_form_step(entry_name, ElnBaseDataType.SAMPLE_DETAIL, fields, field_map,
-                                             position=position,
-                                             is_field_addable=is_field_addable,
-                                             is_existing_field_removable=is_existing_field_removable)
-
-    def _create_eln_dt_form_step(self, entry_name: str,
-                                 dt: ElnBaseDataType,
-                                 fields: list[ElnDataTypeFields] | None = None,
-                                 field_map: FieldMap | None = None,
-                                 *,
-                                 position: ElnEntryPosition | None = None,
-                                 is_field_addable: bool | None = None,
-                                 is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        fields: list[AbstractVeloxFieldDefinition] | None = self._to_field_defs(fields, dt)
-        step = self._create_step(ElnEntryType.Form, entry_name, dt.data_type_name,
-                                 position,
-                                 field_definition_list=fields,
-                                 field_map_list=[field_map] if field_map else None)
-        if is_field_addable is not None or is_existing_field_removable is not None:
-            update = ElnFormEntryUpdateCriteria()
-            update.is_field_addable = is_field_addable
-            update.is_existing_field_removable = is_existing_field_removable
-            self.force_step_update(step, update)
-        return step
-
-    def create_plugin_step(self, entry_name: str, data_type: DataTypeIdentifier, plugin_path: str, *,
-                           position: ElnEntryPosition | None = None) -> ElnEntryStep:
-        """
-        Create a new plugin entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param plugin_path: The plugin path to the CSP that determines this entry's functionality.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created plugin entry.
-        """
-        return self._create_step(ElnEntryType.Plugin, entry_name, data_type, position,
-                                 csp_plugin_name=plugin_path)
-
-    def create_table_step(self, entry_name: str, data_type: DataTypeIdentifier,
-                          fields: list[FieldIdentifier] | list[TableColumn] | None = None,
-                          layout_name: str | None = None,
-                          show_key_fields: bool | None = None,
-                          *,
-                          position: ElnEntryPosition | None = None,
-                          records: list[SapioRecord] | None = None) -> ElnEntryStep:
-        """
-        Create a new table entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param fields: The list of data field names for the given data type that should appear on the
-            table. You may also provide a list of TableColumns instead of a list of field names for when you want to
-            set the sort order and direction of the columns in the table. Fields will appear in the order they are
-            provided. If not provided and a layout name is not provided, the entry will be created with the data type's
-            default layout.
-        :param layout_name: The name of the layout to use for the entry. If not provided and field names are not
-            provided, the entry will be created with the data type's default layout.
-        :param show_key_fields: Whether the table should only show key fields of the data type.
-        :param position: Information about where to place the entry in the experiment.
-        :param records: The list of records to initially populate the entry with.
-        :return: The newly created table entry.
-        """
-        step = self._create_step(ElnEntryType.Table, entry_name, data_type, position)
-        if fields or layout_name:
-            update = ElnTableEntryUpdateCriteria()
-            if fields:
-                dt: str = AliasUtil.to_data_type_name(data_type)
-                columns: list[TableColumn] = []
-                for field in fields:
-                    if isinstance(field, TableColumn):
-                        columns.append(field)
-                    else:
-                        columns.append(TableColumn(dt, AliasUtil.to_data_field_name(field)))
-                update.table_column_list = columns
-            update.data_type_layout_name = layout_name
-            update.show_key_fields = show_key_fields
-            self.force_step_update(step, update)
-        if records:
-            self.set_step_records(step, records)
-        return step
-
-    def create_experiment_detail_table_step(self, entry_name: str,
-                                            fields: list[ElnDataTypeFields] | None = None,
-                                            field_maps: list[FieldMap] | None = None, *,
-                                            position: ElnEntryPosition | None = None,
-                                            is_field_addable: bool | None = None,
-                                            is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN experiment details table entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_maps: A field maps list that will be used to populate the entry. The data field names in
-            the maps must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created table entry.
-        """
-        return self._create_eln_dt_table_step(entry_name, ElnBaseDataType.EXPERIMENT_DETAIL, fields, field_maps,
-                                              position=position,
-                                              is_field_addable=is_field_addable,
-                                              is_existing_field_removable=is_existing_field_removable)
-
-    def create_sample_detail_table_step(self, entry_name: str,
-                                        fields: list[ElnDataTypeFields] | None = None,
-                                        field_maps: list[FieldMap] | None = None, *,
-                                        position: ElnEntryPosition | None = None,
-                                        is_field_addable: bool | None = None,
-                                        is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN sample details table entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_maps: A field maps list that will be used to populate the entry. The data field names in
-            the maps must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created table entry.
-        """
-        return self._create_eln_dt_table_step(entry_name, ElnBaseDataType.SAMPLE_DETAIL, fields, field_maps,
-                                              position=position,
-                                              is_field_addable=is_field_addable,
-                                              is_existing_field_removable=is_existing_field_removable)
-
-    def _create_eln_dt_table_step(self, entry_name: str,
-                                  dt: ElnBaseDataType,
-                                  fields: list[ElnDataTypeFields] | None = None,
-                                  field_maps: list[FieldMap] | None = None, *,
-                                  position: ElnEntryPosition | None = None,
-                                  is_field_addable: bool | None = None,
-                                  is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        fields: list[AbstractVeloxFieldDefinition] | None = self._to_field_defs(fields, dt)
-        step = self._create_step(ElnEntryType.Table, entry_name, dt.data_type_name,
-                                 position,
-                                 field_definition_list=fields,
-                                 field_map_list=field_maps)
-        if is_field_addable is not None or is_existing_field_removable is not None:
-            update = ElnTableEntryUpdateCriteria()
-            update.is_field_addable = is_field_addable
-            update.is_existing_field_removable = is_existing_field_removable
-            self.force_step_update(step, update)
-        return step
-
-    def create_temp_data_step(self, entry_name: str, data_type: DataTypeIdentifier, plugin_path: str, *,
-                              position: ElnEntryPosition | None = None) -> ElnEntryStep:
+    # FR-47530: Add functions for dealing with entry positioning.
+    def step_to_position(self, step: Step) -> ElnEntryPosition:
         """
-        Create a new temp data entry in the experiment.
+        Get the position of the input step in the experiment.
 
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param plugin_path: The plugin path to the plugin that populates the entry.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created temp data entry.
-        """
-        return self._create_step(ElnEntryType.TempData, entry_name, data_type, position,
-                                 temp_data_plugin_path=plugin_path)
+        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.
 
-    def create_text_step(self, entry_name: str, text: str | None = None, *,
-                         position: ElnEntryPosition | None = None) -> ElnEntryStep:
+        :param step:
+            The step to get the position of.
+            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.
+        :return: The position of the input step in the experiment.
         """
-        Create a new text entry in the experiment.
+        step: ElnEntryStep = self.__to_eln_step(step)
+        entry: ExperimentEntry = step.eln_entry
+        return ElnEntryPosition(entry.notebook_experiment_tab_id,
+                                entry.order,
+                                entry.column_span,
+                                entry.column_order)
 
-        :param entry_name: The name of the entry.
-        :param text: The text to populate the entry with.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created text entry.
+    def step_at_position(self, position: ElnEntryPosition) -> Step | None:
         """
-        step: ElnEntryStep = self._create_step(ElnEntryType.Text, entry_name,
-                                               ElnBaseDataType.TEXT_ENTRY_DETAIL.data_type_name, position)
-        if text:
-            text_record: DataRecord = self.get_step_records(entry_name)[0]
-            text_record.set_field_value(ElnBaseDataType.get_text_entry_data_field_name(), text)
-            DataRecordManager(self.user).commit_data_records([text_record])
-        return step
+        Get the step at the input position in the experiment.
 
-    def create_plate_designer_step(self, entry_name: str, source_entry: Step, *,
-                                   position: ElnEntryPosition | None = None) -> ElnEntryStep:
-        """
-        Create a new 3D plate designer entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param source_entry: The entry that the plate designer will source its samples from.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created plate designer entry.
-        """
-        step = self.create_plugin_step(entry_name, "Sample", PLATE_DESIGNER_PLUGIN, position=position)
-        default_layer = MultiLayerPlateLayer(
-            MultiLayerDataTypeConfig("Sample"),
-            PlatingOrder.FillBy.BY_COLUMN,
-            MultiLayerReplicateConfig(),
-            MultiLayerDilutionConfig()
-        )
-        initial_step_options: dict[str, str] = {
-            "MultiLayerPlating_Plate_RecordIdList": "",
-            "MultiLayerPlating_Entry_Prefs": MultiLayerPlatingManager.get_entry_prefs_json([default_layer]),
-            "MultiLayerPlating_Entry_PrePlating_Prefs": MultiLayerPlatingManager.get_plate_configs_json(MultiLayerPlateConfig())
-        }
-        source_entry = self.__to_eln_step(source_entry)
-        self.force_step_update_params(step, entry_height=600, entry_options_map=initial_step_options,
-                                      related_entry_set=[source_entry.get_id()])
-        return step
+        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.
 
-    # TODO: Update these functions to use entry type-specific creation criteria once Sapiopylib supports that.
-    #  This should take in an entry creation criteria object that handles all the abstract attributes that
-    #  every entry type shares.
-    def _create_step(self, entry_type: ElnEntryType, entry_name: str, data_type: DataTypeIdentifier,
-                     position: ElnEntryPosition | None = None, **kwargs) \
-            -> ElnEntryStep:
+        :param position: The position to get the step at.
+        :return: The step at the input position in the experiment, or None if no step exists at that position.
         """
-        Create a new entry in the experiment of the given type.
-        """
-        if position is not None:
-            order: int = position.order
-            tab_id: int = position.tab_id
-            column_order: int = position.column_order
-            column_span: int = position.column_span
-        else:
-            last_tab: ElnExperimentTab = self.get_last_tab()
-            order: int = self.get_next_entry_order_in_tab(last_tab)
-            tab_id: int = last_tab.tab_id
-            column_order: int = 0
-            column_span: int = last_tab.max_number_of_columns
-
-        data_type: str = AliasUtil.to_data_type_name(data_type)
-        crit = ElnEntryCriteria(entry_type, entry_name, data_type, order,
-                                notebook_experiment_tab_id=tab_id,
-                                column_order=column_order,
-                                column_span=column_span,
-                                **kwargs)
-        entry: ExperimentEntry = self._eln_man.add_experiment_entry(self._exp_id, crit)
-
-        self.add_entry_to_caches(entry)
-        return ElnEntryStep(self._protocol, entry)
+        if position.tab_id is None or position.order is None:
+            raise SapioException("The provided position must at least have a tab ID and order.")
+        for step in self.get_steps_in_tab(position.tab_id):
+            entry: ExperimentEntry = step.eln_entry
+            if entry.order != position.order:
+                continue
+            if position.column_span is not None and entry.column_span != position.column_span:
+                continue
+            if position.column_order is not None and entry.column_order != position.column_order:
+                continue
+            return step
+        return None
 
-    def _to_field_defs(self, fields: list[ElnDataTypeFields], dt: ElnBaseDataType) \
-            -> list[AbstractVeloxFieldDefinition] | None:
+    # FR-47530: Create a function for adding protocol templates to the experiment.
+    def add_protocol(self, protocol: ProtocolTemplateInfo | int, position: ElnEntryPosition) -> list[ElnEntryStep]:
         """
-        Convert a list of ElnDataTypeField aliases to field definitions.
+        Add a protocol to the experiment. Updates the handler cache with the newly created entries.
+
+        :param protocol: The protocol to add. This can be either a ProtocolTemplateInfo object or the ID of the
+            protocol template.
+        :param position: The position that the protocol's first entry will be placed at.
+        :return: The newly created protocol entries.
         """
-        if not fields:
-            return None
-        field_defs: list[AbstractVeloxFieldDefinition] = []
-        for field in fields:
-            if isinstance(field, AbstractVeloxFieldDefinition):
-                field_defs.append(field)
-            elif isinstance(field, ElnFieldSetInfo):
-                field_defs.extend(self._eln_man.get_predefined_fields_from_field_set_id(field.field_set_id))
-            elif isinstance(field, str):
-                field_defs.append(self._predefined_field(field, dt))
-            elif isinstance(field, int):
-                field_defs.extend(self._eln_man.get_predefined_fields_from_field_set_id(field))
-        return field_defs
-
-    def _predefined_field(self, field_name: str, data_type: ElnBaseDataType) -> AbstractVeloxFieldDefinition:
-        """
-        Get the predefined field of the given name for the given ELN data type.
-        """
-        # TODO: Should this be in some sort of DataTypeCacheManager?
-        if data_type not in self._predefined_fields:
-            fields: list[AbstractVeloxFieldDefinition] = self._eln_man.get_predefined_fields(data_type)
-            self._predefined_fields[data_type.data_type_name] = {x.data_field_name: x for x in fields}
-        return self._predefined_fields[data_type.data_type_name][field_name]
+        protocol = protocol if isinstance(protocol, int) else protocol.template_id
+        new_entries: list[ExperimentEntry] = self._eln_man.add_protocol_template(self._exp_id, protocol, position)
+        return self.add_entries_to_caches(new_entries)
 
     def __to_eln_step(self, step: Step) -> ElnEntryStep:
         """
@@ -2140,14 +1749,22 @@ class ExperimentHandler:
 
         :return: The input step as an ElnEntryStep.
         """
-        return self.get_step(step) if isinstance(step, str) else step
+        if isinstance(step, str):
+            return self.get_step(step)
+        if isinstance(step, int):
+            return self._steps_by_id.get(step)
+        if isinstance(step, ExperimentEntry):
+            return self.add_entry_to_caches(step)
+        return step
 
     def __to_eln_tab(self, tab: Tab) -> ElnExperimentTab:
         """
-        Convert a variable that could be either a string or an ElnExperimentTab to just an ElnExperimentTab.
+        Convert a variable that could be either a tab name, tab order, or ElnExperimentTab to just a tab object.
         This will query and cache the tabs for the experiment if the input tab is a name and the tabs have not been
         cached before.
 
         :return: The input tab as an ElnExperimentTab.
         """
-        return self.get_tab(tab) if isinstance(tab, str) else tab
+        if not isinstance(tab, ElnExperimentTab):
+            return self.get_tab(tab)
+        return tab