sapiopycommons 2025.4.9a150__py3-none-any.whl → 2025.4.9a476__py3-none-any.whl

sapiopycommons/eln/experiment_handler.py

@@ -1,19 +1,35 @@
 from __future__ import annotations
 
-import time
+import warnings
 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, TabIdentifier
+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.ELNService import ElnManager
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
+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
-from sapiopylib.rest.pojo.eln.ExperimentEntryCriteria import AbstractElnEntryUpdateCriteria
+from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry, ExperimentTableEntry, ExperimentFormEntry, \
+    ExperimentAttachmentEntry, ExperimentPluginEntry, ExperimentDashboardEntry, ExperimentTextEntry, \
+    ExperimentTempDataEntry
+from sapiopylib.rest.pojo.eln.ExperimentEntryCriteria import AbstractElnEntryUpdateCriteria, \
+    ElnTableEntryUpdateCriteria, ElnFormEntryUpdateCriteria, ElnAttachmentEntryUpdateCriteria, \
+    ElnPluginEntryUpdateCriteria, ElnDashboardEntryUpdateCriteria, ElnTextEntryUpdateCriteria, \
+    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.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
@@ -23,12 +39,7 @@ from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelInst
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 from sapiopylib.rest.utils.recordmodel.properties import Child
 
-from sapiopycommons.eln.experiment_report_util import ExperimentReportUtil
-from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, UserIdentifier, \
-    DataTypeIdentifier, RecordModel
-from sapiopycommons.general.exceptions import SapioException
-
-Step = str | ElnEntryStep
+Step: TypeAlias = str | ExperimentEntryIdentifier
 """An object representing an identifier to an ElnEntryStep. May be either the name of the step or the ElnEntryStep
 itself."""
 
@@ -37,53 +48,74 @@ itself."""
 class ExperimentHandler:
     user: SapioUser
     context: SapioWebhookContext | None
-    """The context that this handler is working from."""
+    """The context that this handler is working from, if any."""
 
+    # CR-47485: Made variables protected instead of private.
     # Basic experiment info from the context.
-    __eln_exp: ElnExperiment
+    _eln_exp: ElnExperiment
     """The ELN experiment from the context."""
-    __protocol: ElnExperimentProtocol
+    _protocol: ElnExperimentProtocol
     """The ELN experiment as a protocol."""
-    __exp_id: int
+    _exp_id: int
     """The ID of this experiment's notebook. Used for making update webservice calls."""
 
     # Managers.
-    __eln_man: ElnManager
+    _eln_man: ElnManager
     """The ELN manager. Used for updating the experiment and its steps."""
-    __inst_man: RecordModelInstanceManager
+    _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
+    """The record handler. Also used for wrapping the data records of a step as record models."""
 
     # Only a fraction of the information about the current experiment exists in the context. Much information requires
     # additional queries to obtain, but may also be repeatedly accessed. In such cases, cache the information after it
     # has been requested so that the user doesn't need to worry about caching it themselves.
     # CR-46341: Replace class variables with instance variables.
-    __exp_record: DataRecord | None
+    _exp_record: DataRecord | None
     """The data record for this experiment. Only cached when first accessed."""
-    __exp_template: ElnTemplate | None
+    _exp_template: ElnTemplate | None
     """The template for this experiment. Only cached when first accessed."""
-    __exp_options: dict[str, str]
+    _exp_options: dict[str, str]
     """Experiment options for this experiment. Only cached when first accessed."""
 
-    __queried_all_steps: bool
+    _queried_all_steps: bool
     """Whether this ExperimentHandler has queried the system for all steps in the experiment."""
-    __steps: dict[str, ElnEntryStep]
-    """Steps from this experiment. All steps are cached the first time any individual step is accessed."""
-    __step_options: dict[int, dict[str, str]]
+    _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."""
+    _step_options: dict[int, dict[str, str]]
     """Entry options for each step in this experiment. All entry options are cached the first time any individual step's
     options are queried. The cache is updated whenever the entry options for a step are changed by this handler."""
 
+    _step_updates: dict[int, AbstractElnEntryUpdateCriteria]
+    """A dictionary of entry updates that have been made by this handler. Used to batch update entries."""
+
+    _queried_all_tabs: bool
+    """Whether this ExperimentHandler has queried the system for all tabs in the experiment."""
+    _tabs: list[ElnExperimentTab]
+    """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."""
+
     # Constants
-    __ENTRY_COMPLETE_STATUSES = [ExperimentEntryStatus.Completed, ExperimentEntryStatus.CompletedApproved]
+    _ENTRY_COMPLETE_STATUSES = [ExperimentEntryStatus.Completed, ExperimentEntryStatus.CompletedApproved]
     """The set of statuses that an ELN entry could have and be considered completed/submitted."""
-    __ENTRY_LOCKED_STATUSES = [ExperimentEntryStatus.Completed, ExperimentEntryStatus.CompletedApproved,
-                               ExperimentEntryStatus.Disabled, ExperimentEntryStatus.LockedAwaitingApproval,
-                               ExperimentEntryStatus.LockedRejected]
+    _ENTRY_LOCKED_STATUSES = [ExperimentEntryStatus.Completed, ExperimentEntryStatus.CompletedApproved,
+                              ExperimentEntryStatus.Disabled, ExperimentEntryStatus.LockedAwaitingApproval,
+                              ExperimentEntryStatus.LockedRejected]
     """The set of statuses that an ELN entry could have and be considered locked."""
-    __EXPERIMENT_COMPLETE_STATUSES = [ElnExperimentStatus.Completed, ElnExperimentStatus.CompletedApproved]
+    _EXPERIMENT_COMPLETE_STATUSES = [ElnExperimentStatus.Completed, ElnExperimentStatus.CompletedApproved]
     """The set of statuses that an ELN experiment could have and be considered completed."""
-    __EXPERIMENT_LOCKED_STATUSES = [ElnExperimentStatus.Completed, ElnExperimentStatus.CompletedApproved,
-                                    ElnExperimentStatus.LockedRejected, ElnExperimentStatus.LockedAwaitingApproval,
-                                    ElnExperimentStatus.Canceled]
+    _EXPERIMENT_LOCKED_STATUSES = [ElnExperimentStatus.Completed, ElnExperimentStatus.CompletedApproved,
+                                   ElnExperimentStatus.LockedRejected, ElnExperimentStatus.LockedAwaitingApproval,
+                                   ElnExperimentStatus.Canceled]
     """The set of statuses that an ELN experiment could have and be considered locked."""
 
     __instances: WeakValueDictionary[str, ExperimentHandler] = WeakValueDictionary()
@@ -123,27 +155,44 @@ class ExperimentHandler:
         experiment = param_results[2]
 
         # Get the basic information about this experiment that already exists in the context and is often used.
-        self.__eln_exp = experiment
-        self.__protocol = ElnExperimentProtocol(experiment, self.user)
-        self.__exp_id = self.__protocol.get_id()
+        self._eln_exp = experiment
+        self._protocol = ElnExperimentProtocol(experiment, self.user)
+        self._exp_id = self._protocol.get_id()
 
         # Grab various managers that may be used.
-        self.__eln_man = DataMgmtServer.get_eln_manager(self.user)
-        self.__inst_man = RecordModelManager(self.user).instance_manager
+        self._eln_man = 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.__steps = {}
-        self.__step_options = {}
+        self._queried_all_steps = False
+        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
+
         # CR-46330: Cache any experiment entry information that might already exist in the context.
-        self.__queried_all_steps = False
         # We can only trust the entries in the context if the experiment that this handler is for is the same as the
         # one from the context.
         if self.context is not None and self.context.eln_experiment == experiment:
+            cache_steps: list[ElnEntryStep] = []
             if self.context.experiment_entry is not None:
-                self.__steps.update({self.context.active_step.get_name(): self.context.active_step})
+                cache_steps.append(ElnEntryStep(self._protocol, self.context.experiment_entry))
             if self.context.experiment_entry_list is not None:
                 for entry in self.context.experiment_entry_list:
-                    self.__steps.update({entry.entry_name: ElnEntryStep(self.__protocol, entry)})
+                    cache_steps.append(ElnEntryStep(self._protocol, entry))
+            for step in cache_steps:
+                self._steps.append(step)
+                self._steps_by_name.update({step.get_name(): step})
+                self._steps_by_id.update({step.get_id(): step})
 
     @staticmethod
     def __parse_params(context: UserIdentifier, experiment: ExperimentIdentifier | SapioRecord | None = None) \
@@ -180,10 +229,99 @@ class ExperimentHandler:
                 if not experiment:
                     raise SapioException(f"No experiment with record ID {record_id} located in the system.")
         if experiment is None:
-            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment found in the provided parameters.")
+            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment found in the provided "
+                                 "parameters.")
 
         return user, context, experiment
 
+    @property
+    def protocol(self) -> ElnExperimentProtocol:
+        """
+        The ELN experiment that this handler is for as a protocol object.
+        """
+        return self._protocol
+
+    # CR-47485: Add methods for clearing and updating the caches of this ExperimentHandler.
+    def clear_all_caches(self) -> None:
+        """
+        Clear all caches that this ExperimentHandler uses.
+        """
+        self.clear_step_caches()
+        self.clear_experiment_caches()
+        self.clear_tab_caches()
+
+    def clear_step_caches(self) -> None:
+        """
+        Clear the step caches that this ExperimentHandler uses.
+        """
+        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()
+
+    def clear_experiment_caches(self) -> None:
+        """
+        Clear the experiment information caches that this ExperimentHandler uses.
+        """
+        self._exp_record = None
+        self._exp_template = None
+        self._exp_options = {}
+
+    def clear_tab_caches(self) -> None:
+        """
+        Clear the tab caches that this ExperimentHandler uses.
+        """
+        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) -> ElnEntryStep:
+        """
+        Add the given entry to the cache of steps for this experiment. This is necessary in order for certain methods to
+        work. You should only need to do this if you have created a new entry in your code using a method outside
+        of this ExperimentHandler.
+
+        :param entry: The entry to add to the cache.
+        :return: The entry that was added to the cache as an ElnEntryStep.
+        """
+        if isinstance(entry, ExperimentEntry):
+            entry = ElnEntryStep(self._protocol, entry)
+        self._steps.append(entry)
+        self._steps_by_name.update({entry.get_name(): entry})
+        self._steps_by_id.update({entry.get_id(): entry})
+        # Skipping the options cache. The get_step_options method will update the cache when necessary.
+        return entry
+
+    def add_entries_to_caches(self, entries: list[ExperimentEntry | ElnEntryStep]) -> 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:
+            new_entries.append(self.add_entry_to_caches(entry))
+        return new_entries
+
+    def add_tab_to_cache(self, tab: ElnExperimentTab) -> None:
+        """
+        Add the given tab to the cache of tabs for this experiment. This is necessary in order for certain methods
+        to work properly. You should only need to do this if you have created a new tab in your code using a method
+        outside of this ExperimentHandler.
+
+        :param tab: The tab to add to the cache.
+        """
+        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.
     @staticmethod
     def create_experiment(context: SapioWebhookContext,
@@ -211,22 +349,10 @@ class ExperimentHandler:
         :param active_templates_only: Whether only active templates should be queried for.
         :return: The newly created experiment.
         """
-        template_query = TemplateExperimentQueryPojo(latest_version_only=(template_version is None),
-                                                     active_templates_only=active_templates_only)
-        templates: list[ElnTemplate] = context.eln_manager.get_template_experiment_list(template_query)
-        launch_template: ElnTemplate | None = None
-        for template in templates:
-            if template.template_name != template_name:
-                continue
-            if template_version is not None and template.template_version != template_version:
-                continue
-            launch_template = template
-            break
-        if launch_template is None:
-            raise SapioException(f"No template with the name \"{template_name}\"" +
-                                 ("" if template_version is None else f" and the version {template_version}") +
-                                 f" found.")
-
+        launch_template: ElnTemplate = ExperimentCacheManager(context).get_experiment_template(template_name,
+                                                                                               active_templates_only,
+                                                                                               template_version,
+                                                                                               first_match=True)
         if experiment_name is None:
             experiment_name: str = launch_template.display_name
         if parent_record is not None:
@@ -239,7 +365,8 @@ class ExperimentHandler:
                           template_name: str,
                           experiment_name: str | None = None,
                           parent_record: SapioRecord | None = None, *,
-                          template_version: int | None = None, active_templates_only: bool = True) -> SapioWebhookResult:
+                          template_version: int | None = None,
+                          active_templates_only: bool = True) -> SapioWebhookResult:
         """
         Create a SapioWebhookResult that, when returned by a webhook handler, sends the user to a new experiment of the
         input template name.
@@ -275,24 +402,24 @@ class ExperimentHandler:
             when the experiment template doesn't exist.
         :return: This experiment's template. None if it has no template.
         """
-        template_id: int | None = self.__eln_exp.template_id
+        template_id: int | None = self._eln_exp.template_id
         if template_id is None:
-            self.__exp_template = None
+            self._exp_template = None
             if exception_on_none:
-                raise SapioException(f"Experiment with ID {self.__exp_id} has no template ID.")
+                raise SapioException(f"Experiment with ID {self._exp_id} has no template ID.")
             return None
 
-        if not hasattr(self, "_ExperimentHandler__exp_template"):
+        if not hasattr(self, "_exp_template"):
             # PR-46504: Allow inactive and non-latest version templates to be queried.
             query = TemplateExperimentQueryPojo(template_id_white_list=[template_id],
                                                 active_templates_only=False,
                                                 latest_version_only=False)
-            templates: list[ElnTemplate] = self.__eln_man.get_template_experiment_list(query)
+            templates: list[ElnTemplate] = self._eln_man.get_template_experiment_list(query)
             # PR-46504: Set the exp_template to None if there are no results.
-            self.__exp_template = templates[0] if templates else None
-        if self.__exp_template is None and exception_on_none:
-            raise SapioException(f"Experiment template not found for experiment with ID {self.__exp_id}.")
-        return self.__exp_template
+            self._exp_template = templates[0] if templates else None
+        if self._exp_template is None and exception_on_none:
+            raise SapioException(f"Experiment template not found for experiment with ID {self._exp_id}.")
+        return self._exp_template
 
     # CR-46104: Change get_template_name to behave like NotebookProtocolImpl.getTemplateName (i.e. first see if the
     # experiment template exists, and if not, see if the experiment record exists, instead of only checking the
@@ -309,18 +436,18 @@ class ExperimentHandler:
             when the template name doesn't exist.
         :return: The template name of the current experiment. None if it has no template name.
         """
-        if not hasattr(self, "_ExperimentHandler__exp_template"):
+        if not hasattr(self, "_exp_template"):
             self.get_experiment_template(False)
-        if self.__exp_template is None and not hasattr(self, "_ExperimentHandler__exp_record"):
+        if self._exp_template is None and not hasattr(self, "_exp_record"):
             self.get_experiment_record(False)
 
         name: str | None = None
-        if self.__exp_template is not None:
-            name = self.__exp_template.template_name
-        elif self.__exp_record is not None:
-            name = self.__exp_record.get_field_value("TemplateExperimentName")
+        if self._exp_template is not None:
+            name = self._exp_template.template_name
+        elif self._exp_record is not None:
+            name = self._exp_record.get_field_value("TemplateExperimentName")
         if name is None and exception_on_none:
-            raise SapioException(f"Template name not found for experiment with ID {self.__exp_id}.")
+            raise SapioException(f"Template name not found for experiment with ID {self._exp_id}.")
         return name
 
     def get_experiment_record(self, exception_on_none: bool = True) -> DataRecord | None:
@@ -331,21 +458,23 @@ class ExperimentHandler:
             when the experiment record doesn't exist.
         :return: The data record for this experiment. None if it has no record.
         """
-        if not hasattr(self, "_ExperimentHandler__exp_record"):
-            self.__exp_record = self.__protocol.get_record()
-        if self.__exp_record is None and exception_on_none:
-            raise SapioException(f"Experiment record not found for experiment with ID {self.__exp_id}.")
-        return self.__exp_record
+        if not hasattr(self, "_exp_record"):
+            self._exp_record = self._protocol.get_record()
+        if self._exp_record is None and exception_on_none:
+            raise SapioException(f"Experiment record not found for experiment with ID {self._exp_id}.")
+        return self._exp_record
 
-    def get_experiment_model(self, wrapper_type: type[WrappedType]) -> WrappedType:
+    # CR-47491: Support not providing a wrapper type to receive PyRecordModels instead of WrappedRecordModels.
+    def get_experiment_model(self, wrapper_type: type[WrappedType] | None = None) -> WrappedType | PyRecordModel:
         """
         Query for the data record of this experiment and wrap it as a record model with the given wrapper.
         The returned record is cached by the ExperimentHandler.
 
-        :param wrapper_type: The record model wrapper to use.
+        :param wrapper_type: The record model wrapper to use. If not provided, the record is returned as a
+            PyRecordModel instead of a WrappedRecordModel.
         :return: The record model for this experiment.
         """
-        return self.__inst_man.add_existing_record_of_type(self.get_experiment_record(), wrapper_type)
+        return self._rec_handler.wrap_model(self.get_experiment_record(), wrapper_type)
 
     def update_experiment(self,
                           experiment_name: str | None = None,
@@ -367,14 +496,14 @@ class ExperimentHandler:
         criteria.new_experiment_name = experiment_name
         criteria.new_experiment_status = experiment_status
         criteria.experiment_option_map = experiment_option_map
-        self.__eln_man.update_notebook_experiment(self.__exp_id, criteria)
+        self._eln_man.update_notebook_experiment(self._exp_id, criteria)
 
         if experiment_name is not None:
-            self.__eln_exp.notebook_experiment_name = experiment_name
+            self._eln_exp.notebook_experiment_name = experiment_name
         if experiment_status is not None:
-            self.__eln_exp.notebook_experiment_status = experiment_status
+            self._eln_exp.notebook_experiment_status = experiment_status
         if experiment_option_map is not None:
-            self.__exp_options = experiment_option_map
+            self._exp_options = experiment_option_map
 
     def get_experiment_option(self, option: str) -> str:
         """
@@ -399,7 +528,10 @@ class ExperimentHandler:
 
         :return: The map of options for this experiment.
         """
-        return self.__get_experiment_options()
+        if hasattr(self, "_exp_options"):
+            return self._exp_options
+        self._exp_options = self._eln_man.get_notebook_experiment_options(self._exp_id)
+        return self._exp_options
 
     def add_experiment_options(self, mapping: Mapping[str, str]) -> None:
         """
@@ -424,7 +556,7 @@ class ExperimentHandler:
 
         :return: True if the experiment's status is Completed or CompletedApproved. False otherwise.
         """
-        return self.__eln_exp.notebook_experiment_status in self.__EXPERIMENT_COMPLETE_STATUSES
+        return self._eln_exp.notebook_experiment_status in self._EXPERIMENT_COMPLETE_STATUSES
 
     def experiment_is_canceled(self) -> bool:
         """
@@ -432,7 +564,7 @@ class ExperimentHandler:
 
         :return: True if the experiment's status is Canceled. False otherwise.
         """
-        return self.__eln_exp.notebook_experiment_status == ElnExperimentStatus.Canceled
+        return self._eln_exp.notebook_experiment_status == ElnExperimentStatus.Canceled
 
     def experiment_is_locked(self) -> bool:
         """
@@ -441,29 +573,34 @@ class ExperimentHandler:
         :return: True if the experiment's status is Completed, CompletedApproved, Canceled, LockedAwaitingApproval,
             or LockedRejected. False otherwise.
         """
-        return self.__eln_exp.notebook_experiment_status in self.__EXPERIMENT_LOCKED_STATUSES
+        return self._eln_exp.notebook_experiment_status in self._EXPERIMENT_LOCKED_STATUSES
 
     def complete_experiment(self) -> None:
         """
         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()
-            self.__eln_exp.notebook_experiment_status = ElnExperimentStatus.Completed
+            self._protocol.complete_protocol()
+            self._eln_exp.notebook_experiment_status = ElnExperimentStatus.Completed
 
     def cancel_experiment(self) -> None:
         """
         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()
-            self.__eln_exp.notebook_experiment_status = ElnExperimentStatus.Canceled
+            self._protocol.cancel_protocol()
+            self._eln_exp.notebook_experiment_status = ElnExperimentStatus.Canceled
 
     def step_exists(self, step_name: str) -> bool:
         """
@@ -489,14 +626,14 @@ class ExperimentHandler:
         """
         return all([x is not None for x in self.get_steps(step_names, False)])
 
-    def get_step(self, step_name: str, exception_on_none: bool = True) -> ElnEntryStep | None:
+    def get_step(self, step_name: str | int, exception_on_none: bool = True) -> ElnEntryStep | None:
         """
         Get the step of the given name from the experiment.
 
         If no step functions have been called before and a step is being searched for by name, queries for the
         list of steps in the experiment and caches them.
 
-        :param step_name: The name for the step to return.
+        :param step_name: The name or ID for the step to return.
         :param exception_on_none: If false, returns None if the entry can't be found. If true, raises an exception
             when the named entry doesn't exist in the experiment.
         :return: An ElnEntrySteps matching the provided name. If there is no match and no exception is to be thrown,
@@ -504,31 +641,32 @@ class ExperimentHandler:
         """
         return self.get_steps([step_name], exception_on_none)[0]
 
-    def get_steps(self, step_names: Iterable[str], exception_on_none: bool = True) -> list[ElnEntryStep | None]:
+    def get_steps(self, step_names: Iterable[str | int], exception_on_none: bool = True) -> list[ElnEntryStep | None]:
         """
         Get a list of steps of the given names from the experiment, sorted in the same order as the names are provided.
 
         If no step functions have been called before and a step is being searched for by name, queries for the
         list of steps in the experiment and caches them.
 
-        :param step_names: A list of names for the entries to return and the order to return them in.
+        :param step_names: A list of names or IDs for the entries to return and the order to return them in.
         :param exception_on_none: If false, returns None for entries that can't be found. If true, raises an exception
             when the named entry doesn't exist in the experiment.
         :return: A list of ElnEntrySteps matching the provided names in the order they were provided in. If there is no
             match for a given step and no exception is to be thrown, returns None for that step.
         """
         ret_list: list[ElnEntryStep | None] = []
-        for name in step_names:
+        for step_id in step_names:
             # If we haven't queried the system for all steps in the experiment yet, then the reason that a step is
             # missing may be because it wasn't in the webhook context. Therefore, query all steps and then check
             # if the step name is still missing from the experiment before potentially throwing an exception.
-            if self.__queried_all_steps is False and name not in self.__steps:
-                self.__queried_all_steps = True
-                self.__steps.update({step.get_name(): step for step in self.__protocol.get_sorted_step_list()})
-
-            step: ElnEntryStep = self.__steps.get(name)
+            if self._queried_all_steps is False and step_id not in self._steps_by_name and step_id not in self._steps_by_id:
+                self._query_all_steps()
+            if isinstance(step_id, str):
+                step: ElnEntryStep = self._steps_by_name.get(step_id)
+            else:
+                step: ElnEntryStep = self._steps_by_id.get(step_id)
             if step is None and exception_on_none is True:
-                raise SapioException(f"ElnEntryStep of name \"{name}\" not found in experiment with ID {self.__exp_id}.")
+                raise SapioException(f"ElnEntryStep of name \"{step_id}\" not found in experiment with ID {self._exp_id}.")
             ret_list.append(step)
         return ret_list
 
@@ -542,15 +680,35 @@ class ExperimentHandler:
             a data type name or wrapper is given, only returns entries that match that data type name or wrapper.
         :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()
+        if self._queried_all_steps is False:
+            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(entry.notebook_experiment_tab_id).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.
@@ -599,7 +757,8 @@ class ExperimentHandler:
         """
         return self.__to_eln_step(step).get_records()
 
-    def get_step_models(self, step: Step, wrapper_type: type[WrappedType]) -> list[WrappedType]:
+    def get_step_models(self, step: Step, wrapper_type: type[WrappedType] | None = None) \
+            -> list[WrappedType] | list[PyRecordModel]:
         """
         Query for the data records for the given step and wrap them as record models with the given type. The returned
         records are not cached by the ExperimentHandler.
@@ -611,10 +770,11 @@ class ExperimentHandler:
             The step to get the data records for.
             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: The record model wrapper to use.
+        :param wrapper_type: The record model wrapper to use. If not provided, the records are returned as
+            PyRecordModels instead of WrappedRecordModels.
         :return: The record models for the given step.
         """
-        return self.__inst_man.add_existing_records_of_type(self.get_step_records(step), wrapper_type)
+        return self._rec_handler.wrap_models(self.get_step_records(step), wrapper_type)
 
     def add_step_records(self, step: Step, records: Iterable[SapioRecord]) -> None:
         """
@@ -637,8 +797,9 @@ class ExperimentHandler:
             return
         dt: str = AliasUtil.to_singular_data_type_name(records)
         if ElnBaseDataType.is_base_data_type(dt):
-            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
-                                 f"Use add_eln_rows or add_sample_details instead.")
+            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. ELN "
+                                 f"records that are committed to the system will automatically appear in the ELN entry "
+                                 f"with the matching data type name.")
         if dt != step.get_data_type_names()[0]:
             raise SapioException(f"Cannot add {dt} records to entry {step.get_name()} of type "
                                  f"{step.get_data_type_names()[0]}.")
@@ -664,8 +825,9 @@ class ExperimentHandler:
             return
         dt: str = AliasUtil.to_singular_data_type_name(records)
         if ElnBaseDataType.is_base_data_type(dt):
-            raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
-                                 f"Use remove_eln_rows or remove_sample_details instead.")
+            # CR-47532: Add remove_step_records support for Experiment Detail and Sample Detail entries.
+            self.remove_eln_rows(step, records)
+            return
         if dt != step.get_data_type_names()[0]:
             raise SapioException(f"Cannot remove {dt} records from entry {step.get_name()} of type "
                                  f"{step.get_data_type_names()[0]}.")
@@ -694,9 +856,14 @@ class ExperimentHandler:
         step = self.__to_eln_step(step)
         if records:
             dt: str = AliasUtil.to_singular_data_type_name(records)
+            # CR-47532: Add set_step_records support for Experiment Detail and Sample Detail entries.
             if ElnBaseDataType.is_base_data_type(dt):
-                raise SapioException(f"{dt} is an ELN data type. This function call has no effect on ELN data types. "
-                                     f"Use add_eln_rows or add_sample_details instead.")
+                remove_rows: list[PyRecordModel] = []
+                for record in self.get_step_models(step):
+                    if record not in records:
+                        remove_rows.append(record)
+                self.remove_eln_rows(step, remove_rows)
+                return
             if dt != step.get_data_type_names()[0]:
                 raise SapioException(f"Cannot set {dt} records for entry {step.get_name()} of type "
                                      f"{step.get_data_type_names()[0]}.")
@@ -718,10 +885,30 @@ 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)
+        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[PyRecordModel | WrappedType]:
+            -> list[WrappedType] | list[PyRecordModel]:
         """
         Add rows to an ELNExperimentDetail or ELNSampleDetail table entry. The rows will not appear in the system
         until a record manager store and commit has occurred.
@@ -743,15 +930,69 @@ class ExperimentHandler:
         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.")
-        records: list[PyRecordModel] = self.__inst_man.add_new_records(dt, count)
+        records: list[PyRecordModel] = self._inst_man.add_new_records(dt, count)
         if wrapper_type:
-            return self.__inst_man.wrap_list(records, wrapper_type)
+            return self._inst_man.wrap_list(records, wrapper_type)
         return records
 
-    def add_eln_row(self, step: Step, wrapper_type: type[WrappedType] | None = None) -> PyRecordModel | WrappedType:
+    def add_sample_detail(self, step: Step, sample: RecordModel,
+                           wrapper_type: type[WrappedType] | None = None) \
+            -> WrappedType | PyRecordModel:
         """
-        Add a row to an ELNExperimentDetail or ELNSampleDetail table entry. The row will not appear in the system
-        until a record manager store and commit has occurred.
+        Add a sample detail to a sample detail entry while relating it to the input sample record.
+
+        :param step:
+            The step may be provided as either a string for the name of the step or an ElnEntryStep.
+            If given a name, throws an exception if no step of the given name exists in the experiment.
+        :param sample: The sample record to add the sample detail to.
+        :param wrapper_type: Optionally wrap the sample detail in a record model wrapper. If not provided, returns
+            an unwrapped PyRecordModel.
+        :return: The newly created sample detail.
+        """
+        return self.add_sample_details(step, [sample], wrapper_type)[0]
+
+    def add_sample_details(self, step: Step, samples: Iterable[RecordModel],
+                           wrapper_type: type[WrappedType] | None = None) \
+            -> list[WrappedType] | list[PyRecordModel]:
+        """
+        Add sample details to a sample details entry while relating them to the input sample records.
+
+        :param step:
+            The step may be provided as either a string for the name of the step or an ElnEntryStep.
+            If given a name, throws an exception if no step of the given name exists in the experiment.
+        :param samples: The sample records to add the sample details to.
+        :param wrapper_type: Optionally wrap the sample details in a record model wrapper. If not provided, returns
+            an unwrapped PyRecordModel.
+        :return: The newly created sample details. The indices of the samples in the input list match the index of the
+            sample details in this list that they are related to.
+        """
+        step = self.__to_eln_step(step)
+        if step.eln_entry.entry_type != ElnEntryType.Table:
+            raise SapioException("The provided step is not a table entry.")
+        dt: str = step.get_data_type_names()[0]
+        if not ElnBaseDataType.is_eln_type(dt) or ElnBaseDataType.get_base_type(dt) != ElnBaseDataType.SAMPLE_DETAIL:
+            raise SapioException("The provided step is not an ELNSampleDetail entry.")
+        records: list[PyRecordModel] = []
+        for sample in samples:
+            if sample.data_type_name != "Sample":
+                raise SapioException(f"Received a {sample.data_type_name} record when Sample records were expected.")
+            detail: PyRecordModel = sample.add(Child.create_by_name(dt))
+            detail.set_field_values({
+                "SampleId": sample.get_field_value("SampleId"),
+                "OtherSampleId": sample.get_field_value("OtherSampleId")
+            })
+            records.append(detail)
+        if wrapper_type:
+            return self._inst_man.wrap_list(records, wrapper_type)
+        return records
+
+    def remove_eln_row(self, step: Step, record: SapioRecord) -> None:
+        """
+        Remove a row from an ELNExperimentDetail or ELNSampleDetail table entry. ELN data type table entries display all
+        records in the system that match the entry's data type. This means that removing rows from an ELN data type
+        table entry is equivalent to deleting the records for the rows.
+
+        The row will not be deleted in the system until a record manager store and commit has occurred.
 
         If no step functions have been called before and a step is being searched for by name, queries for the
         list of steps in the experiment and caches them.
@@ -759,13 +1000,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
@@ -802,64 +1043,11 @@ class ExperimentHandler:
             else:
                 record.delete()
         if data_records:
-            record_models: list[PyRecordModel] = self.__inst_man.add_existing_records(data_records)
+            record_models: list[PyRecordModel] = self._inst_man.add_existing_records(data_records)
             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]) \
-            -> list[PyRecordModel | WrappedType]:
-        """
-        Add sample details to a sample details entry while relating them to the input sample records.
-
-        :param step:
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        :param samples: The sample records to add the sample details to.
-        :param wrapper_type: Optionally wrap the sample details in a record model wrapper. If not provided, returns
-            an unwrapped PyRecordModel.
-        :return: The newly created sample details. The indices of the samples in the input list match the index of the
-            sample details in this list that they are related to.
-        """
-        step = self.__to_eln_step(step)
-        if step.eln_entry.entry_type != ElnEntryType.Table:
-            raise SapioException("The provided step is not a table entry.")
-        dt: str = step.get_data_type_names()[0]
-        if not ElnBaseDataType.is_eln_type(dt) or ElnBaseDataType.get_base_type(dt) != ElnBaseDataType.SAMPLE_DETAIL:
-            raise SapioException("The provided step is not an ELNSampleDetail entry.")
-        records: list[PyRecordModel] = []
-        for sample in samples:
-            if sample.data_type_name != "Sample":
-                raise SapioException(f"Received a {sample.data_type_name} record when Sample records were expected.")
-            detail: PyRecordModel = sample.add(Child.create_by_name(dt))
-            detail.set_field_values({
-                "SampleId": sample.get_field_value("SampleId"),
-                "OtherSampleId": sample.get_field_value("OtherSampleId")
-            })
-            records.append(detail)
-        if wrapper_type:
-            return self.__inst_man.wrap_list(records, wrapper_type)
-        return records
-
+    # noinspection PyPep8Naming
     def update_step(self, step: Step,
                     entry_name: str | None = None,
                     related_entry_set: Iterable[int] | None = None,
@@ -926,8 +1114,227 @@ 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.",
+                      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.
+
+        Consider using store_step_update and commit_step_updates instead if the update does not need to be immediate.
+
+        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 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)
+
+    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
+        of the Step that is being updated.
+
+        Consider using store_step_update and commit_step_updates instead if the update does not need to be immediate.
+
+        If no step functions have been called before and a step is being searched for by name, queries for the
+        list of steps in the experiment and caches them.
+
+        :param step: The step to 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 update: The update to make to the step.
+        """
+        step = self.__to_eln_step(step)
+        self._eln_man.update_experiment_entry(self._exp_id, step.get_id(), update)
+        self._update_entry_details(step, update)
+
+    def store_step_update(self, step: Step, update: AbstractElnEntryUpdateCriteria) -> None:
+        """
+        Store updates to be made to an entry in this experiment. The updates are not committed until
+        commit_entry_updates is called.
+
+        If the same entry is updated multiple times before committing, the latest update will be merged on top of the
+        previous updates; where the new update and old update conflict, the new update will take precedence.
+
+        If no step functions have been called before and a step is being searched for by name, queries for the
+        list of steps in the experiment and caches them.
+
+        :param step: The step to 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 update: The update to make to the step.
+        """
+        step = self.__to_eln_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 "
+                                 f"{update.entry_type}.")
+        if step.get_id() in self._step_updates:
+            self._merge_updates(update, self._step_updates[step.get_id()])
+        else:
+            self._step_updates[step.get_id()] = update
+
+    def store_step_updates(self, updates: dict[Step, AbstractElnEntryUpdateCriteria]) -> None:
+        """
+        Store updates to be made to multiple entries in this experiment. The updates are not committed until
+        commit_entry_updates is called.
+
+        If the same entry is updated multiple times before committing, the latest update will be merged on top of the
+        previous updates; where the new update and old update conflict, the new update will take precedence.
+
+        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 updates: A dictionary of steps and their respective updates.
+        """
+        for step, update in updates.items():
+            self.store_step_update(step, update)
+
+    def commit_step_updates(self) -> None:
+        """
+        Commit all the stored updates to the entries in this experiment. The updates are made in the order that they
+        were stored.
+        """
+        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)
-        criteria = AbstractElnEntryUpdateCriteria(step.eln_entry.entry_type)
+        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.
@@ -936,81 +1343,154 @@ class ExperimentHandler:
         if dependency_set is not None:
             dependency_set = list(dependency_set)
 
-        criteria.entry_name = entry_name
-        criteria.related_entry_set = related_entry_set
-        criteria.dependency_set = dependency_set
-        criteria.entry_status = entry_status
-        criteria.order = order
-        criteria.description = description
-        criteria.requires_grabber_plugin = requires_grabber_plugin
-        criteria.is_initialization_required = is_initialization_required
-        criteria.notebook_experiment_tab_id = notebook_experiment_tab_id
-        criteria.entry_height = entry_height
-        criteria.column_order = column_order
-        criteria.column_span = column_span
-        criteria.is_removable = is_removable
-        criteria.is_renamable = is_renamable
-        criteria.source_entry_id = source_entry_id
-        criteria.clear_source_entry_id = clear_source_entry_id
-        criteria.is_hidden = is_hidden
-        criteria.is_static_View = is_static_View
-        criteria.is_shown_in_template = is_shown_in_template
-        criteria.template_item_fulfilled_timestamp = template_item_fulfilled_timestamp
-        criteria.clear_template_item_fulfilled_timestamp = clear_template_item_fulfilled_timestamp
-        criteria.entry_options_map = entry_options_map
-
-        self.__eln_man.update_experiment_entry(self.__exp_id, step.get_id(), criteria)
-
-        # Update the cached information for this entry in case it's needed by the caller after updating.
+        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:
+        """
+        Merge the new update criteria onto the old update criteria. The new update will take precedence where there
+        are conflicts.
+        """
+        for key, value in new_update.__dict__.items():
+            if value is not None:
+                old_update.__dict__[key] = value
+
+    def _update_entry_details(self, step: Step, update: AbstractElnEntryUpdateCriteria) -> None:
+        """
+        Update the cached information for this entry in case it's needed by the caller after updating.
+        """
         entry: ExperimentEntry = step.eln_entry
-        if entry_name is not None:
+        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)
-            entry.entry_name = entry_name
-            self.__steps.update({entry_name: step})
-        if related_entry_set is not None:
-            entry.related_entry_id_set = related_entry_set
-        if dependency_set is not None:
-            entry.dependency_set = dependency_set
-        if entry_status is not None:
-            entry.entry_status = entry_status
-        if order is not None:
-            entry.order = order
-        if description is not None:
-            entry.description = description
-        if requires_grabber_plugin is not None:
-            entry.requires_grabber_plugin = requires_grabber_plugin
-        if is_initialization_required is not None:
-            entry.is_initialization_required = is_initialization_required
-        if notebook_experiment_tab_id is not None:
-            entry.notebook_experiment_tab_id = notebook_experiment_tab_id
-        if entry_height is not None:
-            entry.entry_height = entry_height
-        if column_order is not None:
-            entry.column_order = column_order
-        if column_span is not None:
-            entry.column_span = column_span
-        if is_removable is not None:
-            entry.is_removable = is_removable
-        if is_renamable is not None:
-            entry.is_renamable = is_renamable
-        if source_entry_id is not None:
-            entry.source_entry_id = source_entry_id
-        if clear_source_entry_id is True:
+            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_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:
+            entry.dependency_set = update.dependency_set
+        if update.entry_status is not None:
+            entry.entry_status = update.entry_status
+        if update.order is not None:
+            entry.order = update.order
+        if update.description is not None:
+            entry.description = update.description
+        if update.requires_grabber_plugin is not None:
+            entry.requires_grabber_plugin = update.requires_grabber_plugin
+        if update.is_initialization_required is not None:
+            entry.is_initialization_required = update.is_initialization_required
+        if update.notebook_experiment_tab_id is not None:
+            entry.notebook_experiment_tab_id = update.notebook_experiment_tab_id
+        if update.entry_height is not None:
+            entry.entry_height = update.entry_height
+        if update.column_order is not None:
+            entry.column_order = update.column_order
+        if update.column_span is not None:
+            entry.column_span = update.column_span
+        if update.is_removable is not None:
+            entry.is_removable = update.is_removable
+        if update.is_renamable is not None:
+            entry.is_renamable = update.is_renamable
+        if update.source_entry_id is not None:
+            entry.source_entry_id = update.source_entry_id
+        if update.clear_source_entry_id is True:
             entry.source_entry_id = None
-        if is_hidden is not None:
-            entry.is_hidden = is_hidden
-        if is_static_View is not None:
-            entry.is_static_View = is_static_View
-        if is_shown_in_template is not None:
-            entry.is_shown_in_template = is_shown_in_template
-        if template_item_fulfilled_timestamp is not None:
-            entry.template_item_fulfilled_timestamp = template_item_fulfilled_timestamp
-        if clear_template_item_fulfilled_timestamp is True:
+        if update.is_hidden is not None:
+            entry.is_hidden = update.is_hidden
+        if update.is_static_View is not None:
+            entry.is_static_View = update.is_static_View
+        if update.is_shown_in_template is not None:
+            entry.is_shown_in_template = update.is_shown_in_template
+        if update.template_item_fulfilled_timestamp is not None:
+            entry.template_item_fulfilled_timestamp = update.template_item_fulfilled_timestamp
+        if update.clear_template_item_fulfilled_timestamp is True:
             entry.template_item_fulfilled_timestamp = None
-        if entry_options_map is not None:
-            self.__step_options.update({step.get_id(): entry_options_map})
+        if update.entry_options_map is not None:
+            self._step_options.update({step.get_id(): update.entry_options_map})
+
+        if isinstance(entry, ExperimentAttachmentEntry) and isinstance(update, ElnAttachmentEntryUpdateCriteria):
+            if update.entry_attachment_list is not None:
+                entry.entry_attachment_list = update.entry_attachment_list
+            if update.record_id is not None:
+                entry.record_id = update.record_id
+            if update.attachment_name is not None:
+                entry.attachment_name = update.attachment_name
+        elif isinstance(entry, ExperimentDashboardEntry) and isinstance(update, ElnDashboardEntryUpdateCriteria):
+            if update.dashboard_guid is not None:
+                entry.dashboard_guid = update.dashboard_guid
+            if update.dashboard_guid_list is not None:
+                entry.dashboard_guid_list = update.dashboard_guid_list
+            if update.data_source_entry_id is not None:
+                entry.data_source_entry_id = update.data_source_entry_id
+        elif isinstance(entry, ExperimentFormEntry) and isinstance(update, ElnFormEntryUpdateCriteria):
+            if update.record_id is not None:
+                entry.record_id = update.record_id
+            if update.form_name_list is not None:
+                entry.form_name_list = update.form_name_list
+            if update.data_type_layout_name is not None:
+                entry.data_type_layout_name = update.data_type_layout_name
+            if update.field_set_id_list is not None:
+                entry.field_set_id_list = update.field_set_id_list
+            if update.extension_type_list is not None:
+                entry.extension_type_list = update.extension_type_list
+            if update.data_field_name_list is not None:
+                entry.data_field_name_list = update.data_field_name_list
+            if update.is_existing_field_removable is not None:
+                entry.is_existing_field_removable = update.is_existing_field_removable
+            if update.is_field_addable is not None:
+                entry.is_field_addable = update.is_field_addable
+        elif isinstance(entry, ExperimentPluginEntry) and isinstance(update, ElnPluginEntryUpdateCriteria):
+            if update.plugin_name is not None:
+                entry.plugin_name = update.plugin_name
+            if update.provides_template_data is not None:
+                entry.provides_template_data = update.provides_template_data
+            if update.using_template_data is not None:
+                entry.using_template_data = update.using_template_data
+        if isinstance(entry, ExperimentTableEntry) and isinstance(update, ElnTableEntryUpdateCriteria):
+            if update.data_type_layout_name is not None:
+                entry.data_type_layout_name = update.data_type_layout_name
+            if update.extension_type_list is not None:
+                entry.extension_type_list = update.extension_type_list
+            if update.field_set_id_list is not None:
+                entry.field_set_id_list = update.field_set_id_list
+            if update.is_existing_field_removable is not None:
+                entry.is_existing_field_removable = update.is_existing_field_removable
+            if update.is_field_addable is not None:
+                entry.is_field_addable = update.is_field_addable
+            if update.show_key_fields is not None:
+                entry.show_key_fields = update.show_key_fields
+            if update.table_column_list is not None:
+                entry.table_column_list = update.table_column_list
+        elif isinstance(entry, ExperimentTempDataEntry) and isinstance(update, ElnTempDataEntryUpdateCriteria):
+            if update.plugin_path is not None:
+                entry.plugin_path = update.plugin_path
+        elif isinstance(entry, ExperimentTextEntry) and isinstance(update, ElnTextEntryUpdateCriteria):
+            # Text update criteria has no additional fields.
+            pass
 
     def get_step_option(self, step: Step, option: str) -> str:
         """
@@ -1050,9 +1530,10 @@ class ExperimentHandler:
         :return: The map of options for the input step.
         """
         step = self.__to_eln_step(step)
-        if step not in self.__step_options:
-            self.__step_options.update(ExperimentReportUtil.get_experiment_entry_options(self.user, self.get_all_steps()))
-        return self.__step_options[step.get_id()]
+        if step not in self._step_options:
+            self._step_options.update(ExperimentReportUtil.get_experiment_entry_options(self.user,
+                                                                                        self.get_all_steps()))
+        return self._step_options[step.get_id()]
 
     def add_step_options(self, step: Step, mapping: Mapping[str, str]):
         """
@@ -1076,7 +1557,7 @@ class ExperimentHandler:
         """
         options: dict[str, str] = self.get_step_options(step)
         options.update(mapping)
-        self.update_step(step, entry_options_map=options)
+        self.force_step_update_params(step, entry_options_map=options)
 
     def initialize_step(self, step: Step) -> None:
         """
@@ -1094,7 +1575,7 @@ class ExperimentHandler:
         # Avoid unnecessary calls if the step is already initialized.
         step: ElnEntryStep = self.__to_eln_step(step)
         if step.eln_entry.template_item_fulfilled_timestamp is None:
-            self.update_step(step, template_item_fulfilled_timestamp=round(time.time() * 1000))
+            self.force_step_update_params(step, template_item_fulfilled_timestamp=TimeUtil.now_in_millis())
 
     def uninitialize_step(self, step: Step) -> None:
         """
@@ -1112,7 +1593,7 @@ class ExperimentHandler:
         # Avoid unnecessary calls if the step is already uninitialized.
         step: ElnEntryStep = self.__to_eln_step(step)
         if step.eln_entry.template_item_fulfilled_timestamp is not None:
-            self.update_step(step, clear_template_item_fulfilled_timestamp=True)
+            self.force_step_update_params(step, clear_template_item_fulfilled_timestamp=True)
 
     def complete_step(self, step: Step) -> None:
         """
@@ -1128,7 +1609,7 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         """
         step = self.__to_eln_step(step)
-        if step.eln_entry.entry_status not in self.__ENTRY_COMPLETE_STATUSES:
+        if step.eln_entry.entry_status not in self._ENTRY_COMPLETE_STATUSES:
             step.complete_step()
             step.eln_entry.entry_status = ExperimentEntryStatus.Completed
 
@@ -1146,7 +1627,7 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         """
         step = self.__to_eln_step(step)
-        if step.eln_entry.entry_status in self.__ENTRY_LOCKED_STATUSES:
+        if step.eln_entry.entry_status in self._ENTRY_LOCKED_STATUSES:
             step.unlock_step()
             step.eln_entry.entry_status = ExperimentEntryStatus.UnlockedChangesRequired
 
@@ -1168,8 +1649,8 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         """
         step = self.__to_eln_step(step)
-        if step.eln_entry.entry_status in self.__ENTRY_LOCKED_STATUSES:
-            self.update_step(step, entry_status=ExperimentEntryStatus.Disabled)
+        if step.eln_entry.entry_status in self._ENTRY_LOCKED_STATUSES:
+            self.force_step_update_params(step, entry_status=ExperimentEntryStatus.Disabled)
 
     def step_is_submitted(self, step: Step) -> bool:
         """
@@ -1184,7 +1665,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.__to_eln_step(step).eln_entry.entry_status in self._ENTRY_COMPLETE_STATUSES
 
     def step_is_locked(self, step: Step) -> bool:
         """
@@ -1200,7 +1681,171 @@ 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.__to_eln_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]:
+        """
+        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.
+
+        :return: A list of all the tabs in the experiment in order of appearance.
+        """
+        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
+
+    def get_first_tab(self) -> ElnExperimentTab:
+        """
+        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.
+
+        :return: The first tab in the experiment.
+        """
+        return self.get_all_tabs()[0]
+
+    def get_last_tab(self) -> ElnExperimentTab:
+        """
+        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.
+
+        :return: The last tab in the experiment.
+        """
+        return self.get_all_tabs()[-1]
+
+    def create_tab(self, tab_name: str) -> ElnExperimentTab:
+        """
+        Create a new tab in the experiment with the input name.
+
+        :param tab_name: The name of the tab to create.
+        :return: The newly created tab.
+        """
+        crit = ElnExperimentTabAddCriteria(tab_name, [])
+        tab: ElnExperimentTab = self._eln_man.add_tab_for_experiment(self._exp_id, crit)
+        self.add_tab_to_cache(tab)
+        return tab
+
+    def get_tab(self, tab_name: 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 or ID of the tab to get.
+        :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 tab_name not in self._tabs_by_name and tab_name not in self._tabs_by_id:
+            self.get_all_tabs()
+        if isinstance(tab_name, str):
+            tab = self._tabs_by_name.get(tab_name)
+        else:
+            tab = self._tabs_by_id.get(tab_name)
+        if tab is None and exception_on_none:
+            raise SapioException(f"No tab with the name\\ID \"{tab_name}\" exists in this experiment.")
+        return tab
+
+    def get_steps_in_tab(self, tab: TabIdentifier | str, data_type: DataTypeIdentifier | None = None) \
+            -> list[ElnEntryStep]:
+        """
+        Get all the steps in the input tab sorted in order of appearance.
+
+        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 tab: The tab to get the steps of. This can be either an ElnExperimentTab object, or the name or ID of
+            the tab.
+        :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.
+        """
+        tab: ElnExperimentTab = self.__to_eln_tab(tab)
+        steps: list[ElnEntryStep] = []
+        for step in self.get_all_steps(data_type):
+            if step.eln_entry.notebook_experiment_tab_id == tab.tab_id:
+                steps.append(step)
+        return steps
+
+    def get_next_entry_order_in_tab(self, tab: TabIdentifier | str) -> int:
+        """
+        Get the next available order for a new entry in the input tab.
+
+        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 tab: The tab to get the next entry order of. This can be either an ElnExperimentTab object, or the name
+            or ID of the tab.
+        :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-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.
+
+        If no step functions have been called before and a step is being searched for by name, queries for the
+        list of steps in the experiment and caches them.
+
+        :param step:
+            The step to 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.__to_eln_step(step)
+        entry: ExperimentEntry = step.eln_entry
+        return ElnEntryPosition(entry.notebook_experiment_tab_id,
+                                entry.order,
+                                entry.column_span,
+                                entry.column_order)
+
+    def step_at_position(self, position: ElnEntryPosition) -> Step | None:
+        """
+        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 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
+
+    # FR-47530: Create a function for adding protocol templates to the experiment.
+    def add_protocol(self, protocol: ProtocolTemplateInfo | int, position: ElnEntryPosition) -> list[ElnEntryStep]:
+        """
+        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)
 
     def __to_eln_step(self, step: Step) -> ElnEntryStep:
         """
@@ -1210,15 +1855,24 @@ class ExperimentHandler:
 
         :return: The input step as an ElnEntryStep.
         """
-        return self.get_step(step) if isinstance(step, str) else step
+        if isinstance(step, str):
+            return self.get_step(step)
+        if isinstance(step, int):
+            return self._steps_by_id.get(step)
+        if isinstance(step, ExperimentEntry):
+            return self.add_entry_to_caches(step)
+        return step
 
-    def __get_experiment_options(self) -> dict[str, str]:
+    def __to_eln_tab(self, tab: TabIdentifier | str) -> ElnExperimentTab:
         """
-        Cache the experiment options if they haven't been cached yet.
+        Convert a variable that could be either a string or an ElnExperimentTab to just an ElnExperimentTab.
+        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 options for this experiment.
+        :return: The input tab as an ElnExperimentTab.
         """
-        if hasattr(self, "_ExperimentHandler__exp_options"):
-            return self.__exp_options
-        self.__exp_options = self.__eln_man.get_notebook_experiment_options(self.__exp_id)
-        return self.__exp_options
+        if isinstance(tab, str):
+            return self.get_tab(tab)
+        if isinstance(tab, int):
+            return [x for x in self._tabs if x.tab_id == tab][0]
+        return tab