sapiopycommons 2025.7.18a620__py3-none-any.whl → 2025.7.21a630__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,46 @@ 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.
         """
+        # ExperimentEntries are stored as ElnEntrySteps in the cache.
         if isinstance(entry, ExperimentEntry):
             entry = ElnEntryStep(self._protocol, entry)
-        self._steps.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.
-
-    def add_entries_to_caches(self, entries: list[ExperimentEntry | ElnEntryStep]) -> None:
+        # PR-47699: Confirm that this entry is part of the experiment that this handler is for.
+        if entry.eln_entry.parent_experiment_id != self._exp_id:
+            raise SapioException(f"Entry with ID {entry.get_id()} is not part of the experiment with ID "
+                                 f"{self._exp_id}.")
+        # PR-47699: Don't add the entry if it is already in the cache.
+        if entry.get_id() not in self._steps_by_id:
+            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 that cache when necessary.
+        return entry
+
+    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,12 +329,15 @@ 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.
+    # CR-47703: Allow create_experiment and launch_experiment to accept None as a template_name to create a blank
+    # experiment. Also allow a SapioUser object to be provided as context instead of a full SapioWebhookContext object.
     @staticmethod
-    def create_experiment(context: SapioWebhookContext,
-                          template_name: str,
+    def create_experiment(context: UserIdentifier,
+                          template_name: str | None = None,
                           experiment_name: str | None = None,
                           parent_record: SapioRecord | None = None, *,
                           template_version: int | None = None, active_templates_only: bool = True) -> ElnExperiment:
@@ -335,8 +348,9 @@ class ExperimentHandler:
         templates match the same criteria, the first template that is encountered in the query is used. Throws an
         exception if no template is found. Also makes a webservice request to create the experiment.
 
-        :param context: The current webhook context.
-        :param template_name: The name of the template to create the experiment from.
+        :param context: The current webhook context or a user object to send requests from.
+        :param template_name: The name of the template to create the experiment from. If None, a blank experiment
+            is created.
         :param experiment_name: The name to give to the experiment after it is created. If not provided, defaults to the
             display name of the template.
         :param parent_record: The parent record to attach this experiment under. This record must be an eligible
@@ -348,32 +362,27 @@ 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.")
-
-        if experiment_name is None:
-            experiment_name: str = launch_template.display_name
+        user = AliasUtil.to_sapio_user(context)
+        cache = ExperimentCacheManager(user)
+        eln_manager: ElnManager = DataMgmtServer.get_eln_manager(user)
+
+        template_id: int | None = None
+        if template_name:
+            launch_template: ElnTemplate = cache.get_experiment_template(template_name, active_templates_only,
+                                                                         template_version, first_match=True)
+            template_id = launch_template.template_id
+            if experiment_name is None:
+                experiment_name: str = launch_template.display_name
+        elif experiment_name is None:
+            experiment_name = f"{user.username}'s Experiment"
         if parent_record is not None:
             parent_record: DataRecord = AliasUtil.to_data_record(parent_record)
-        notebook_init = InitializeNotebookExperimentPojo(experiment_name, launch_template.template_id, parent_record)
-        return context.eln_manager.create_notebook_experiment(notebook_init)
+        notebook_init = InitializeNotebookExperimentPojo(experiment_name, template_id, parent_record)
+        return eln_manager.create_notebook_experiment(notebook_init)
 
     @staticmethod
-    def launch_experiment(context: SapioWebhookContext,
-                          template_name: str,
+    def launch_experiment(context: UserIdentifier,
+                          template_name: str | None = None,
                           experiment_name: str | None = None,
                           parent_record: SapioRecord | None = None, *,
                           template_version: int | None = None,
@@ -386,8 +395,9 @@ class ExperimentHandler:
         templates match the same criteria, the first template that is encountered in the query is used. Throws an
         exception if no template is found. Also makes a webservice request to create the experiment.
 
-        :param context: The current webhook context.
-        :param template_name: The name of the template to create the experiment from.
+        :param context: The current webhook context or a user object to send requests from.
+        :param template_name: The name of the template to create the experiment from. If None, a blank experiment
+            is created.
         :param experiment_name: The name to give to the experiment after it is created. If not provided, defaults to the
             display name of the template.
         :param parent_record: The parent record to attach this experiment under. This record must be an eligible
@@ -590,6 +600,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 +613,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 +647,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: Step, 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 identifier 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 +662,49 @@ 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[Step], 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 identifiers 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.
         """
+        # CR-47700: Support getting steps from entry objects.
+        step_ids: list[str | int] = []
+        for step in step_names:
+            # Convert any ElnEntrySteps into ExperimentEntries.
+            if isinstance(step, ElnEntryStep):
+                step: ExperimentEntry = step.eln_entry
+            # If an ExperimentEntry is provided, then add its ID to the list of steps to return.
+            if isinstance(step, ExperimentEntry):
+                step_ids.append(step.entry_id)
+                # Add this entry to the caches so that it doesn't need to be queried for. This will also verify that
+                # this entry belongs to the experiment that this handler is for.
+                self.add_entry_to_caches(step)
+            elif isinstance(step, (str, int)):
+                step_ids.append(step)
+
         ret_list: list[ElnEntryStep | None] = []
-        for name in step_names:
+        for step_id in step_ids:
             # 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 not self._queried_all_steps:
+                if ((isinstance(step_id, str) and step_id not in self._steps_by_name)
+                        or (isinstance(step_id, int) 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 +719,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.
@@ -740,7 +793,7 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :return: The data records for the given step.
         """
-        return self.__to_eln_step(step).get_records()
+        return self.get_step(step).get_records()
 
     def get_step_models(self, step: Step, wrapper_type: type[WrappedType] | None = None) \
             -> list[WrappedType] | list[PyRecordModel]:
@@ -777,13 +830,14 @@ class ExperimentHandler:
             A list of records to add to the given step.
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_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.")
+            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]}.")
@@ -791,8 +845,7 @@ class ExperimentHandler:
 
     def remove_step_records(self, step: Step, records: Iterable[SapioRecord]) -> None:
         """
-        Make a webservice call to remove a list of records from a step. Only functions for global data type table
-        entries. For removing from an ELN data type table entry, see remove_eln_rows.
+        Make a webservice call to remove a list of records from a 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.
@@ -804,13 +857,14 @@ class ExperimentHandler:
             A list of records to remove from the given step.
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_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.")
+            # 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]}.")
@@ -836,12 +890,17 @@ class ExperimentHandler:
             A list of records to set for the given step,
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_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]}.")
@@ -863,11 +922,28 @@ class ExperimentHandler:
             The record may be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel.
         """
         self.set_step_records(step, [record])
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_step(step)
         if isinstance(step.eln_entry, ExperimentFormEntry):
             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]:
         """
@@ -885,7 +961,7 @@ class ExperimentHandler:
             an unwrapped PyRecordModel.
         :return: A list of the newly created rows.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_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]
@@ -896,10 +972,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: ElnEntryStep = self.get_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 +1037,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
@@ -931,7 +1061,7 @@ class ExperimentHandler:
             A list of records to remove from the given step.
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_step(step)
         dt: str = step.get_data_type_names()[0]
         if not ElnBaseDataType.is_eln_type(dt):
             raise SapioException("The provided step is not an ELN data type entry.")
@@ -954,61 +1084,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 +1151,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.get_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
@@ -1213,7 +1205,7 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :param update: The update to make to the step.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_step(step)
         self._eln_man.update_experiment_entry(self._exp_id, step.get_id(), update)
         self._update_entry_details(step, update)
 
@@ -1233,7 +1225,7 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :param update: The update to make to the step.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_step(step)
         if step.eln_entry.entry_type != update.entry_type:
             raise SapioException(f"The provided step and update criteria are not of the same entry type. "
                                  f"The step is of type {step.eln_entry.entry_type} and the update criteria is of type "
@@ -1264,72 +1256,13 @@ class ExperimentHandler:
         Commit all the stored updates to the entries in this experiment. The updates are made in the order that they
         were stored.
         """
+        if not self._step_updates:
+            return
         self._eln_man.update_experiment_entries(self._exp_id, self._step_updates)
         for step_id, criteria in self._step_updates.items():
             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 +1280,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:
@@ -1491,7 +1424,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)
+        step: ElnEntryStep = self.get_step(step)
         if step not in self._step_options:
             self._step_options.update(ExperimentReportUtil.get_experiment_entry_options(self.user,
                                                                                         self.get_all_steps()))
@@ -1514,12 +1447,16 @@ 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.
         """
+        # PR-47698: Convert the given step to an ElnEntryStep if it is not already one.
+        step: ElnEntryStep = self.get_step(step)
         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:
         """
@@ -1535,9 +1472,11 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         """
         # Avoid unnecessary calls if the step is already initialized.
-        step: ElnEntryStep = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_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:
         """
@@ -1553,9 +1492,11 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         """
         # Avoid unnecessary calls if the step is already uninitialized.
-        step: ElnEntryStep = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_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:
         """
@@ -1570,7 +1511,7 @@ 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.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_step(step)
         if step.eln_entry.entry_status not in self._ENTRY_COMPLETE_STATUSES:
             step.complete_step()
             step.eln_entry.entry_status = ExperimentEntryStatus.Completed
@@ -1588,7 +1529,7 @@ 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.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_step(step)
         if step.eln_entry.entry_status in self._ENTRY_LOCKED_STATUSES:
             step.unlock_step()
             step.eln_entry.entry_status = ExperimentEntryStatus.UnlockedChangesRequired
@@ -1610,9 +1551,11 @@ 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.
         """
-        step = self.__to_eln_step(step)
+        step: ElnEntryStep = self.get_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:
         """
@@ -1627,7 +1570,7 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :return: True if the step's status is Completed or CompletedApproved. False otherwise.
         """
-        return self.__to_eln_step(step).eln_entry.entry_status in self._ENTRY_COMPLETE_STATUSES
+        return self.get_step(step).eln_entry.entry_status in self._ENTRY_COMPLETE_STATUSES
 
     def step_is_locked(self, step: Step) -> bool:
         """
@@ -1643,7 +1586,7 @@ class ExperimentHandler:
         :return: True if the step's status is Completed, CompletedApproved, Disabled, LockedAwaitingApproval,
             or LockedRejected. False otherwise.
         """
-        return self.__to_eln_step(step).eln_entry.entry_status in self._ENTRY_LOCKED_STATUSES
+        return self.get_step(step).eln_entry.entry_status in self._ENTRY_LOCKED_STATUSES
 
     # FR-47464: Some functions that can help with entry placement.
     def get_all_tabs(self) -> list[ElnExperimentTab]:
@@ -1656,6 +1599,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 +1633,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 +1670,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 +1680,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: ElnEntryStep = self.get_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,419 +1714,81 @@ 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:
-        """
-        Create a new temp data 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 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)
-
-    def create_text_step(self, entry_name: str, text: str | None = None, *,
-                         position: ElnEntryPosition | None = None) -> ElnEntryStep:
-        """
-        Create a new text entry in the experiment.
-
-        :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.
-        """
-        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
-
-    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
-
-    # 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:
-        """
-        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
+    # FR-47530: Add functions for dealing with entry positioning.
+    def step_to_position(self, step: Step) -> ElnEntryPosition:
+        """
+        Get the position of the input step in the experiment.
 
-        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)
+        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.
 
-        self.add_entry_to_caches(entry)
-        return ElnEntryStep(self._protocol, entry)
+        :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.
+        """
+        step: ElnEntryStep = self.get_step(step)
+        entry: ExperimentEntry = step.eln_entry
+        return ElnEntryPosition(entry.notebook_experiment_tab_id,
+                                entry.order,
+                                entry.column_span,
+                                entry.column_order)
 
-    def _to_field_defs(self, fields: list[ElnDataTypeFields], dt: ElnBaseDataType) \
-            -> list[AbstractVeloxFieldDefinition] | None:
+    def step_at_position(self, position: ElnEntryPosition) -> Step | None:
         """
-        Convert a list of ElnDataTypeField aliases to field definitions.
+        Get the step at the input position in 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 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.
         """
-        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]
-
-    def __to_eln_step(self, step: Step) -> ElnEntryStep:
-        """
-        Convert a variable that could be either a string or an ElnEntryStep to just an ElnEntryStep.
-        This will query and cache the steps for the experiment if the input step is a name and the steps have not been
-        cached before.
+        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
 
-        :return: The input step as an ElnEntryStep.
+    # FR-47530: Create a function for adding protocol templates to the experiment.
+    def add_protocol(self, protocol: ProtocolTemplateInfo | int, position: ElnEntryPosition) -> list[ElnEntryStep]:
         """
-        return self.get_step(step) if isinstance(step, str) else step
+        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.
+        """
+        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)
+
+    # CR-47700: Deleted __to_eln_step since it became redundant with the get_step method.
 
     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