sapiopycommons 2025.4.5a470__py3-none-any.whl → 2025.4.8a473__py3-none-any.whl

sapiopycommons/eln/experiment_handler.py

@@ -5,60 +5,43 @@ 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.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.ELNService import ElnManager
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.TableColumn import TableColumn
-from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition
 from sapiopylib.rest.pojo.eln.ElnEntryPosition import ElnEntryPosition
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, TemplateExperimentQueryPojo, ElnTemplate, \
     InitializeNotebookExperimentPojo, ElnExperimentUpdateCriteria
 from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry, ExperimentTableEntry, ExperimentFormEntry, \
     ExperimentAttachmentEntry, ExperimentPluginEntry, ExperimentDashboardEntry, ExperimentTextEntry, \
-    ExperimentTempDataEntry, EntryAttachment, EntryRecordAttachment
+    ExperimentTempDataEntry
 from sapiopylib.rest.pojo.eln.ExperimentEntryCriteria import AbstractElnEntryUpdateCriteria, \
     ElnTableEntryUpdateCriteria, ElnFormEntryUpdateCriteria, ElnAttachmentEntryUpdateCriteria, \
     ElnPluginEntryUpdateCriteria, ElnDashboardEntryUpdateCriteria, ElnTextEntryUpdateCriteria, \
-    ElnTempDataEntryUpdateCriteria, ElnEntryCriteria
+    ElnTempDataEntryUpdateCriteria
 from sapiopylib.rest.pojo.eln.SapioELNEnums import ExperimentEntryStatus, ElnExperimentStatus, ElnEntryType, \
     ElnBaseDataType
 from sapiopylib.rest.pojo.eln.eln_headings import ElnExperimentTab, ElnExperimentTabAddCriteria
-from sapiopylib.rest.pojo.eln.field_set import ElnFieldSetInfo
 from sapiopylib.rest.pojo.eln.protocol_template import ProtocolTemplateInfo
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.pojo.webhook.WebhookDirective import ElnExperimentDirective
 from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
 from sapiopylib.rest.utils.Protocols import ElnEntryStep, ElnExperimentProtocol
-from sapiopylib.rest.utils.plates.MultiLayerPlating import MultiLayerPlateConfig, MultiLayerPlateLayer, \
-    MultiLayerDataTypeConfig, MultiLayerReplicateConfig, MultiLayerDilutionConfig
-from sapiopylib.rest.utils.plates.MultiLayerPlatingUtils import MultiLayerPlatingManager
-from sapiopylib.rest.utils.plates.PlatingUtils import PlatingOrder
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelInstanceManager, RecordModelManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 from sapiopylib.rest.utils.recordmodel.properties import Child
 
-from sapiopycommons.datatype.data_fields import SystemFields
-from sapiopycommons.datatype.experiment_cache import ExperimentCacheManager
-from sapiopycommons.eln.experiment_report_util import ExperimentReportUtil
-from sapiopycommons.eln.experiment_tags import PLATE_DESIGNER_PLUGIN
-from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, UserIdentifier, \
-    DataTypeIdentifier, RecordModel, FieldMap, FieldIdentifier
-from sapiopycommons.general.exceptions import SapioException
-from sapiopycommons.general.time_util import TimeUtil
-from sapiopycommons.recordmodel.record_handler import RecordHandler
-
-Step: TypeAlias = str | ElnEntryStep
+Step: TypeAlias = str | ExperimentEntryIdentifier
 """An object representing an identifier to an ElnEntryStep. May be either the name of the step or the ElnEntryStep
 itself."""
-TabIdentifier: TypeAlias = int | str | ElnExperimentTab
-"""An object representing an identifier to an ElnExperimentTab. May be either the ID or name of the tab, or the
-ElnExperimentTab itself."""
-ElnDataTypeFields: TypeAlias = AbstractVeloxFieldDefinition | ElnFieldSetInfo | str | int
-"""An object representing an identifier to an ElnDataType field. These can be field definitions for ad hoc fields,
-predefined field set info objects, predefined field names, or integers for predefined field set IDs."""
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -99,7 +82,9 @@ class ExperimentHandler:
 
     _queried_all_steps: bool
     """Whether this ExperimentHandler has queried the system for all steps in the experiment."""
-    _steps: dict[str, ElnEntryStep]
+    _steps: list[ElnEntryStep]
+    """The sorted list of steps for this experiment. All steps are cached the first time any individual step is accessed."""
+    _steps_by_name: dict[str, ElnEntryStep]
     """Steps from this experiment by their name. All steps are cached the first time any individual step is accessed."""
     _steps_by_id: dict[int, ElnEntryStep]
     """Steps from this experiment by their ID. All steps are cached the first time any individual step is accessed."""
@@ -113,7 +98,9 @@ class ExperimentHandler:
     _queried_all_tabs: bool
     """Whether this ExperimentHandler has queried the system for all tabs in the experiment."""
     _tabs: list[ElnExperimentTab]
-    """The tabs for this experiment. Only cached when first accessed."""
+    """The sorted tabs for this experiment. Only cached when first accessed."""
+    _tabs_by_id: dict[int, ElnExperimentTab]
+    """The tabs for this experiment by their ID. Only cached when first accessed."""
     _tabs_by_name: dict[str, ElnExperimentTab]
     """The tabs for this experiment by their name. Only cached when first accessed."""
 
@@ -180,12 +167,14 @@ class ExperimentHandler:
 
         # Create empty caches to fill when necessary.
         self._queried_all_steps = False
-        self._steps = {}
+        self._steps_by_name = {}
         self._steps_by_id = {}
+        self._steps = []
         self._step_options = {}
         self._step_updates = {}
 
         self._tabs = []
+        self._tabs_by_id = {}
         self._tabs_by_name = {}
 
         self._queried_all_tabs = False
@@ -201,7 +190,8 @@ class ExperimentHandler:
                 for entry in self.context.experiment_entry_list:
                     cache_steps.append(ElnEntryStep(self._protocol, entry))
             for step in cache_steps:
-                self._steps.update({step.get_name(): step})
+                self._steps.append(step)
+                self._steps_by_name.update({step.get_name(): step})
                 self._steps_by_id.update({step.get_id(): step})
 
     @staticmethod
@@ -266,6 +256,7 @@ class ExperimentHandler:
         """
         self._queried_all_steps = False
         self._steps.clear()
+        self._steps_by_name.clear()
         self._steps_by_id.clear()
         self._step_options.clear()
         self._step_updates.clear()
@@ -284,6 +275,7 @@ class ExperimentHandler:
         """
         self._queried_all_tabs = False
         self._tabs.clear()
+        self._tabs_by_id.clear()
         self._tabs_by_name.clear()
 
     def add_entry_to_caches(self, entry: ExperimentEntry | ElnEntryStep) -> ElnEntryStep:
@@ -297,7 +289,8 @@ class ExperimentHandler:
         """
         if isinstance(entry, ExperimentEntry):
             entry = ElnEntryStep(self._protocol, entry)
-        self._steps.update({entry.get_name(): entry})
+        self._steps.append(entry)
+        self._steps_by_name.update({entry.get_name(): entry})
         self._steps_by_id.update({entry.get_id(): entry})
         # Skipping the options cache. The get_step_options method will update the cache when necessary.
         return entry
@@ -326,6 +319,7 @@ class ExperimentHandler:
         """
         self._tabs.append(tab)
         self._tabs.sort(key=lambda t: t.tab_order)
+        self._tabs_by_id[tab.tab_id] = tab
         self._tabs_by_name[tab.tab_name] = tab
 
     # FR-46495: Split the creation of the experiment in launch_experiment into a create_experiment function.
@@ -632,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,
@@ -647,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
 
@@ -686,14 +681,34 @@ class ExperimentHandler:
         :return: Every entry in the experiment in order of appearance that match the provided data type, if any.
         """
         if self._queried_all_steps is False:
-            self._queried_all_steps = True
-            self._steps.update({step.get_name(): step for step in self._protocol.get_sorted_step_list()})
-        all_steps: list[ElnEntryStep] = self._protocol.get_sorted_step_list()
+            self._query_all_steps()
+        else:
+            # Re-sort the steps in case any new steps were added before the last time that this was called.
+            def sort_steps(step: ElnEntryStep) -> tuple:
+                entry = step.eln_entry
+                tab_order: int = self.get_tab(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.
@@ -936,7 +951,7 @@ class ExperimentHandler:
         """
         return self.add_sample_details(step, [sample], wrapper_type)[0]
 
-    def add_sample_details(self, step: Step, samples: list[RecordModel],
+    def add_sample_details(self, step: Step, samples: Iterable[RecordModel],
                            wrapper_type: type[WrappedType] | None = None) \
             -> list[WrappedType] | list[PyRecordModel]:
         """
@@ -991,7 +1006,7 @@ class ExperimentHandler:
         """
         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
@@ -1370,10 +1385,10 @@ class ExperimentHandler:
         entry: ExperimentEntry = step.eln_entry
         if update.entry_name is not None:
             # PR-46477 - Ensure that the previous name of the updated entry already existed in the cache.
-            if entry.entry_name in self._steps:
-                self._steps.pop(entry.entry_name)
+            if entry.entry_name in self._steps_by_name:
+                self._steps_by_name.pop(entry.entry_name)
             entry.entry_name = update.entry_name
-            self._steps.update({update.entry_name: step})
+            self._steps_by_name.update({update.entry_name: step})
         if update.related_entry_set is not None:
             entry.related_entry_id_set = update.related_entry_set
         if update.dependency_set is not None:
@@ -1679,6 +1694,7 @@ class ExperimentHandler:
         if not self._queried_all_tabs:
             self._tabs = self._eln_man.get_tabs_for_experiment(self._exp_id)
             self._tabs.sort(key=lambda t: t.tab_order)
+            self._tabs_by_id = {tab.tab_id: tab for tab in self._tabs}
             self._tabs_by_name = {tab.tab_name: tab for tab in self._tabs}
         return self._tabs
 
@@ -1712,21 +1728,29 @@ class ExperimentHandler:
         self.add_tab_to_cache(tab)
         return tab
 
-    def get_tab(self, tab_name: str) -> ElnExperimentTab:
+    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 of the tab to get.
-        :return: The tab with the input name.
+        :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:
+        if tab_name not in self._tabs_by_name and tab_name not in self._tabs_by_id:
             self.get_all_tabs()
-        return self._tabs_by_name[tab_name]
+        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, data_type: DataTypeIdentifier | None = None) -> list[ElnEntryStep]:
+    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.
 
@@ -1746,10 +1770,9 @@ class ExperimentHandler:
         for step in self.get_all_steps(data_type):
             if step.eln_entry.notebook_experiment_tab_id == tab.tab_id:
                 steps.append(step)
-        steps.sort(key=lambda s: (s.eln_entry.order, s.eln_entry.column_order))
         return steps
 
-    def get_next_entry_order_in_tab(self, tab: TabIdentifier) -> int:
+    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.
 
@@ -1824,385 +1847,6 @@ class ExperimentHandler:
         new_entries: list[ExperimentEntry] = self._eln_man.add_protocol_template(self._exp_id, protocol, position)
         return self.add_entries_to_caches(new_entries)
 
-    # FR-47468: Add functions for creating new entries in the experiment.
-    def create_attachment_step(self, entry_name: str, data_type: DataTypeIdentifier,
-                               *,
-                               position: ElnEntryPosition | None = None,
-                               attachments: list[EntryAttachment] | list[SapioRecord] | None = None) -> ElnEntryStep:
-        """
-        Create a new attachment entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param position: Information about where to place the entry in the experiment.
-        :param attachments: The list of attachments to initially populate the entry with.
-        :return: The newly created attachment entry.
-        """
-        step = self._create_step(ElnEntryType.Attachment, entry_name, data_type, position)
-        if attachments:
-            entry_attachments: list[EntryAttachment] = []
-            for entry in attachments:
-                if isinstance(entry, EntryAttachment):
-                    entry_attachments.append(entry)
-                elif isinstance(entry, SapioRecord):
-                    entry: SapioRecord
-                    file_name: str = entry.get_field_value("FilePath")
-                    if not file_name:
-                        file_name = entry.get_field_value(SystemFields.DATA_RECORD_NAME__FIELD.field_name)
-                    rec_id: int = AliasUtil.to_record_id(entry)
-                    entry_attachments.append(EntryRecordAttachment(file_name, rec_id))
-                else:
-                    raise SapioException("Attachments must be of type EntryAttachment or SapioRecord.")
-            update = ElnAttachmentEntryUpdateCriteria()
-            update.entry_attachment_list = attachments
-            self.force_step_update(step, update)
-        return step
-
-    def create_form_step(self, entry_name: str,
-                         data_type: DataTypeIdentifier,
-                         fields: list[FieldIdentifier] | None = None,
-                         layout_name: str | None = None,
-                         form_names: list[str] | None = None,
-                         *,
-                         position: ElnEntryPosition | None = None,
-                         record: SapioRecord | None = None) -> ElnEntryStep:
-        """
-        Create a new form entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param fields: The list of data field names for the given data type that should appear on the
-            form. Fields will appear in the order they are provided. If not provided and a layout name is not provided,
-            the entry will be created with the data type's default layout.
-        :param layout_name: The name of the layout to use for the entry. If not provided and field names are not
-            provided, the entry will be created with the data type's default layout.
-        :param form_names: The list of layout component form names to use from the specified layout name. If not
-            provided, then all available forms from the specified layout will be used.
-        :param position: Information about where to place the entry in the experiment.
-        :param record: The record to initially populate the entry with.
-        :return: The newly created form entry.
-        """
-        if record:
-            rdt: str = AliasUtil.to_data_type_name(record)
-            sdt: str = AliasUtil.to_data_type_name(data_type)
-            if rdt != sdt:
-                raise SapioException(f"Cannot set {rdt} records for entry {entry_name} of type "
-                                     f"{sdt}.")
-
-        step = self._create_step(ElnEntryType.Form, entry_name, data_type, position)
-        if fields or layout_name or form_names or record:
-            update = ElnFormEntryUpdateCriteria()
-            if fields:
-                update.data_field_name_list = AliasUtil.to_data_field_names(fields)
-            update.data_type_layout_name = layout_name
-            update.form_name_list = form_names
-            if record:
-                update.record_id = AliasUtil.to_record_id(record)
-            self.force_step_update(step, update)
-        return step
-
-    def create_experiment_detail_form_step(self, entry_name: str,
-                                           fields: list[ElnDataTypeFields] | None = None,
-                                           field_map: FieldMap | None = None,
-                                           *,
-                                           position: ElnEntryPosition | None = None,
-                                           is_field_addable: bool | None = None,
-                                           is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN experiment details form entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_map: A field map that will be used to populate the entry. The data field names in
-            the map must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created form entry.
-        """
-        return self._create_eln_dt_form_step(entry_name, ElnBaseDataType.EXPERIMENT_DETAIL, fields, field_map,
-                                             position=position,
-                                             is_field_addable=is_field_addable,
-                                             is_existing_field_removable=is_existing_field_removable)
-
-    def create_sample_detail_form_step(self, entry_name: str,
-                                       fields: list[ElnDataTypeFields] | None = None,
-                                       field_map: FieldMap | None = None,
-                                       *,
-                                       position: ElnEntryPosition | None = None,
-                                       is_field_addable: bool | None = None,
-                                       is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN sample details form entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_map: A field map that will be used to populate the entry. The data field names in
-            the map must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created form entry.
-        """
-        return self._create_eln_dt_form_step(entry_name, ElnBaseDataType.SAMPLE_DETAIL, fields, field_map,
-                                             position=position,
-                                             is_field_addable=is_field_addable,
-                                             is_existing_field_removable=is_existing_field_removable)
-
-    def _create_eln_dt_form_step(self, entry_name: str,
-                                 dt: ElnBaseDataType,
-                                 fields: list[ElnDataTypeFields] | None = None,
-                                 field_map: FieldMap | None = None,
-                                 *,
-                                 position: ElnEntryPosition | None = None,
-                                 is_field_addable: bool | None = None,
-                                 is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        fields: list[AbstractVeloxFieldDefinition] | None = self._to_field_defs(fields, dt)
-        step = self._create_step(ElnEntryType.Form, entry_name, dt.data_type_name,
-                                 position,
-                                 field_definition_list=fields,
-                                 field_map_list=[field_map] if field_map else None)
-        if is_field_addable is not None or is_existing_field_removable is not None:
-            update = ElnFormEntryUpdateCriteria()
-            update.is_field_addable = is_field_addable
-            update.is_existing_field_removable = is_existing_field_removable
-            self.force_step_update(step, update)
-        return step
-
-    def create_plugin_step(self, entry_name: str, data_type: DataTypeIdentifier, plugin_path: str, *,
-                           position: ElnEntryPosition | None = None) -> ElnEntryStep:
-        """
-        Create a new plugin entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param plugin_path: The plugin path to the CSP that determines this entry's functionality.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created plugin entry.
-        """
-        return self._create_step(ElnEntryType.Plugin, entry_name, data_type, position,
-                                 csp_plugin_name=plugin_path)
-
-    def create_table_step(self, entry_name: str, data_type: DataTypeIdentifier,
-                          fields: list[FieldIdentifier] | list[TableColumn] | None = None,
-                          layout_name: str | None = None,
-                          show_key_fields: bool | None = None,
-                          *,
-                          position: ElnEntryPosition | None = None,
-                          records: list[SapioRecord] | None = None) -> ElnEntryStep:
-        """
-        Create a new table entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param fields: The list of data field names for the given data type that should appear on the
-            table. You may also provide a list of TableColumns instead of a list of field names for when you want to
-            set the sort order and direction of the columns in the table. Fields will appear in the order they are
-            provided. If not provided and a layout name is not provided, the entry will be created with the data type's
-            default layout.
-        :param layout_name: The name of the layout to use for the entry. If not provided and field names are not
-            provided, the entry will be created with the data type's default layout.
-        :param show_key_fields: Whether the table should only show key fields of the data type.
-        :param position: Information about where to place the entry in the experiment.
-        :param records: The list of records to initially populate the entry with.
-        :return: The newly created table entry.
-        """
-        step = self._create_step(ElnEntryType.Table, entry_name, data_type, position)
-        if fields or layout_name:
-            update = ElnTableEntryUpdateCriteria()
-            if fields:
-                dt: str = AliasUtil.to_data_type_name(data_type)
-                columns: list[TableColumn] = []
-                for field in fields:
-                    if isinstance(field, TableColumn):
-                        columns.append(field)
-                    else:
-                        columns.append(TableColumn(dt, AliasUtil.to_data_field_name(field)))
-                update.table_column_list = columns
-            update.data_type_layout_name = layout_name
-            update.show_key_fields = show_key_fields
-            self.force_step_update(step, update)
-        if records:
-            self.set_step_records(step, records)
-        return step
-
-    def create_experiment_detail_table_step(self, entry_name: str,
-                                            fields: list[ElnDataTypeFields] | None = None,
-                                            field_maps: list[FieldMap] | None = None, *,
-                                            position: ElnEntryPosition | None = None,
-                                            is_field_addable: bool | None = None,
-                                            is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN experiment details table entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_maps: A field maps list that will be used to populate the entry. The data field names in
-            the maps must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created table entry.
-        """
-        return self._create_eln_dt_table_step(entry_name, ElnBaseDataType.EXPERIMENT_DETAIL, fields, field_maps,
-                                              position=position,
-                                              is_field_addable=is_field_addable,
-                                              is_existing_field_removable=is_existing_field_removable)
-
-    def create_sample_detail_table_step(self, entry_name: str,
-                                        fields: list[ElnDataTypeFields] | None = None,
-                                        field_maps: list[FieldMap] | None = None, *,
-                                        position: ElnEntryPosition | None = None,
-                                        is_field_addable: bool | None = None,
-                                        is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        """
-        Create a new ELN sample details table entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param fields: A list of objects representing the data fields that should appear on the entry. Fields
-            will appear in the order they are provided.
-        :param field_maps: A field maps list that will be used to populate the entry. The data field names in
-            the maps must match the field names of the provided field definitions.
-        :param position: Information about where to place the entry in the experiment.
-        :param is_field_addable: Whether users are able to add additional fields to this entry in the UI.
-        :param is_existing_field_removable: Whether users are able to remove existing fields from this entry in the UI.
-        :return: The newly created table entry.
-        """
-        return self._create_eln_dt_table_step(entry_name, ElnBaseDataType.SAMPLE_DETAIL, fields, field_maps,
-                                              position=position,
-                                              is_field_addable=is_field_addable,
-                                              is_existing_field_removable=is_existing_field_removable)
-
-    def _create_eln_dt_table_step(self, entry_name: str,
-                                  dt: ElnBaseDataType,
-                                  fields: list[ElnDataTypeFields] | None = None,
-                                  field_maps: list[FieldMap] | None = None, *,
-                                  position: ElnEntryPosition | None = None,
-                                  is_field_addable: bool | None = None,
-                                  is_existing_field_removable: bool | None = None) -> ElnEntryStep:
-        fields: list[AbstractVeloxFieldDefinition] | None = self._to_field_defs(fields, dt)
-        step = self._create_step(ElnEntryType.Table, entry_name, dt.data_type_name,
-                                 position,
-                                 field_definition_list=fields,
-                                 field_map_list=field_maps)
-        if is_field_addable is not None or is_existing_field_removable is not None:
-            update = ElnTableEntryUpdateCriteria()
-            update.is_field_addable = is_field_addable
-            update.is_existing_field_removable = is_existing_field_removable
-            self.force_step_update(step, update)
-        return step
-
-    def create_temp_data_step(self, entry_name: str, data_type: DataTypeIdentifier, plugin_path: str, *,
-                              position: ElnEntryPosition | None = None) -> ElnEntryStep:
-        """
-        Create a new temp data entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param data_type: The data type of the entry.
-        :param plugin_path: The plugin path to the plugin that populates the entry.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created temp data entry.
-        """
-        return self._create_step(ElnEntryType.TempData, entry_name, data_type, position,
-                                 temp_data_plugin_path=plugin_path)
-
-    def create_text_step(self, entry_name: str, text: str | None = None, *,
-                         position: ElnEntryPosition | None = None) -> ElnEntryStep:
-        """
-        Create a new text entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param text: The text to populate the entry with.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created text entry.
-        """
-        step: ElnEntryStep = self._create_step(ElnEntryType.Text, entry_name,
-                                               ElnBaseDataType.TEXT_ENTRY_DETAIL.data_type_name, position)
-        if text:
-            text_record: DataRecord = self.get_step_records(entry_name)[0]
-            text_record.set_field_value(ElnBaseDataType.get_text_entry_data_field_name(), text)
-            DataRecordManager(self.user).commit_data_records([text_record])
-        return step
-
-    def create_plate_designer_step(self, entry_name: str, source_entry: Step, *,
-                                   position: ElnEntryPosition | None = None) -> ElnEntryStep:
-        """
-        Create a new 3D plate designer entry in the experiment.
-
-        :param entry_name: The name of the entry.
-        :param source_entry: The entry that the plate designer will source its samples from.
-        :param position: Information about where to place the entry in the experiment.
-        :return: The newly created plate designer entry.
-        """
-        step = self.create_plugin_step(entry_name, "Sample", PLATE_DESIGNER_PLUGIN, position=position)
-        default_layer = MultiLayerPlateLayer(
-            MultiLayerDataTypeConfig("Sample"),
-            PlatingOrder.FillBy.BY_COLUMN,
-            MultiLayerReplicateConfig(),
-            MultiLayerDilutionConfig()
-        )
-        initial_step_options: dict[str, str] = {
-            "MultiLayerPlating_Plate_RecordIdList": "",
-            "MultiLayerPlating_Entry_Prefs": MultiLayerPlatingManager.get_entry_prefs_json([default_layer]),
-            "MultiLayerPlating_Entry_PrePlating_Prefs": MultiLayerPlatingManager.get_plate_configs_json(MultiLayerPlateConfig())
-        }
-        source_entry = self.__to_eln_step(source_entry)
-        self.force_step_update_params(step, entry_height=600, entry_options_map=initial_step_options,
-                                      related_entry_set=[source_entry.get_id()])
-        return step
-
-    # TODO: Update these functions to use entry type-specific creation criteria once Sapiopylib supports that.
-    #  This should take in an entry creation criteria object that handles all the abstract attributes that
-    #  every entry type shares.
-    def _create_step(self, entry_type: ElnEntryType, entry_name: str, data_type: DataTypeIdentifier,
-                     position: ElnEntryPosition | None = None, **kwargs) \
-            -> ElnEntryStep:
-        """
-        Create a new entry in the experiment of the given type.
-        """
-        if position is not None:
-            order: int = position.order
-            tab_id: int = position.tab_id
-            column_order: int = position.column_order
-            column_span: int = position.column_span
-        else:
-            last_tab: ElnExperimentTab = self.get_last_tab()
-            order: int = self.get_next_entry_order_in_tab(last_tab)
-            tab_id: int = last_tab.tab_id
-            column_order: int = 0
-            column_span: int = last_tab.max_number_of_columns
-
-        data_type: str = AliasUtil.to_data_type_name(data_type)
-        crit = ElnEntryCriteria(entry_type, entry_name, data_type, order,
-                                notebook_experiment_tab_id=tab_id,
-                                column_order=column_order,
-                                column_span=column_span,
-                                **kwargs)
-        entry: ExperimentEntry = self._eln_man.add_experiment_entry(self._exp_id, crit)
-
-        self.add_entry_to_caches(entry)
-        return ElnEntryStep(self._protocol, entry)
-
-    def _to_field_defs(self, fields: list[ElnDataTypeFields], dt: ElnBaseDataType) \
-            -> list[AbstractVeloxFieldDefinition] | None:
-        """
-        Convert a list of ElnDataTypeField aliases to field definitions.
-        """
-        if not fields:
-            return None
-        field_defs: list[AbstractVeloxFieldDefinition] = []
-        for field in fields:
-            if isinstance(field, AbstractVeloxFieldDefinition):
-                field_defs.append(field)
-            elif isinstance(field, (int, ElnFieldSetInfo)):
-                field_defs.extend(self._exp_cache.get_field_set_fields(field))
-            elif isinstance(field, str):
-                field_defs.append(self._exp_cache.get_predefined_field(field, dt))
-        return field_defs
-
     def __to_eln_step(self, step: Step) -> ElnEntryStep:
         """
         Convert a variable that could be either a string or an ElnEntryStep to just an ElnEntryStep.
@@ -2211,9 +1855,15 @@ class ExperimentHandler:
 
         :return: The input step as an ElnEntryStep.
         """
-        return self.get_step(step) if isinstance(step, str) else step
+        if isinstance(step, str):
+            return self.get_step(step)
+        if isinstance(step, int):
+            return self._steps_by_id.get(step)
+        if isinstance(step, ExperimentEntry):
+            return self.add_entry_to_caches(step)
+        return step
 
-    def __to_eln_tab(self, tab: TabIdentifier) -> ElnExperimentTab:
+    def __to_eln_tab(self, tab: TabIdentifier | str) -> ElnExperimentTab:
         """
         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