sapiopycommons 2025.2.12a432__tar.gz → 2025.2.14a434__tar.gz

{sapiopycommons-2025.2.12a432 → sapiopycommons-2025.2.14a434}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.2.12a432
+Version: 2025.2.14a434
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

{sapiopycommons-2025.2.12a432 → sapiopycommons-2025.2.14a434}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2025.02.12a432'
+version='2025.02.14a434'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

{sapiopycommons-2025.2.12a432 → sapiopycommons-2025.2.14a434}/src/sapiopycommons/elain/tool_of_tools.py

@@ -12,6 +12,7 @@ from sapiopylib.rest.pojo.chartdata.DashboardDefinition import GaugeChartDefinit
 from sapiopylib.rest.pojo.chartdata.DashboardEnums import ChartGroupingType, ChartOperationType
 from sapiopylib.rest.pojo.chartdata.DashboardSeries import GaugeChartSeries
 from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition, FieldType
+from sapiopylib.rest.pojo.eln.ElnEntryPosition import ElnEntryPosition
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
 from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry
 from sapiopylib.rest.pojo.eln.ExperimentEntryCriteria import ElnEntryCriteria, ElnFormEntryUpdateCriteria, \
@@ -33,12 +34,9 @@ EXP_ID_HEADER: Final[str] = "EXPERIMENT_ID"
 TAB_PREFIX_HEADER: Final[str] = "TAB_PREFIX"
 
 
-# TODO: There's a lot of duplication between the static functions and the ToT Helper. This should just be one class
-#  that both the tool endpoints and the AI instantiate, or two classes where one is a subclass of the other. Maybe work
-#  on that after the initial implementation is done.
-# FR-47422: Create utility methods to assist the tool of tools.
+# FR-47422: Create utility classes and methods to assist the tool of tools.
 def create_tot_headers(url: str, username: str, password: str, experiment_id: int, tab_prefix: str) \
-        -> tuple[str, dict[str, str]]:
+        -> dict[str, str]:
     """
     Create the headers to be passed to a tool of tools endpoint.
 
@@ -47,7 +45,7 @@ def create_tot_headers(url: str, username: str, password: str, experiment_id: in
     :param password: The password of the user making the changes.
     :param experiment_id: The ID of the experiment to make the changes in.
     :param tab_prefix: The prefix to use for the tab name that will be created by the tool.
-    :return: The encoded credentials and the headers to be passed to the endpoint.
+    :return: The headers to be passed to the endpoint.
     """
     # Combine the credentials into the format "username:password"
     credentials: str = f"{username}:{password}"
@@ -60,7 +58,7 @@ def create_tot_headers(url: str, username: str, password: str, experiment_id: in
         EXP_ID_HEADER: str(experiment_id),
         TAB_PREFIX_HEADER: tab_prefix
     }
-    return encoded_credentials, headers
+    return headers
 
 
 def create_user_from_tot_headers(headers: Mapping[str, str]) -> SapioUser:
@@ -87,140 +85,9 @@ def format_tot_headers(headers: Mapping[str, str]) -> dict[str, str]:
     return {k.lower(): v for k, v in headers.items()}
 
 
-def create_experiment_details_from_data_frame(user: SapioUser,
-                                              exp_id: int,
-                                              entry_name: str,
-                                              tab: ElnExperimentTab,
-                                              df: DataFrame) -> ExperimentEntry | None:
-    """
-    Create an experiment detail entry from a DataFrame.
-
-    :param user: The user to send the request from.
-    :param exp_id: The ID of the experiment to create the entry in.
-    :param entry_name: The name of the entry.
-    :param tab: The tab that the entry should be added to.
-    :param df: The DataFrame to create the entry from.
-    :return: The created entry object.
-    """
-    json_list: list[dict[str, Any]] = []
-    for _, row in df.iterrows():
-        json_list.append(row.to_dict())
-    return create_experiment_details_from_json(user, exp_id, entry_name, tab, json_list)
-
-
-def create_experiment_details_from_json(user: SapioUser,
-                                        exp_id: int,
-                                        entry_name: str,
-                                        tab: ElnExperimentTab,
-                                        json_list: list[dict[str, Any]]) -> ExperimentEntry | None:
-    """
-    Create an experiment detail entry from a list of JSON dictionaries.
-
-    :param user: The user to send the request from.
-    :param exp_id: The ID of the experiment to create the entry in.
-    :param entry_name: The name of the entry.
-    :param tab: The tab that the entry should be added to.
-    :param json_list: The list of JSON dictionaries to create the entry from. Each dictionary is expected to have the
-        same keys.
-    :return: The created entry object.
-    """
-    if not json_list:
-        return None
-
-    # Determine which fields in the JSON can be used to create field definitions.
-    fb = FieldBuilder()
-    fields: list[AbstractVeloxFieldDefinition] = []
-    fields_by_name: dict[str, AbstractVeloxFieldDefinition] = {}
-    for key, value in json_list[0].items():
-        field_name: str = key.replace(" ", "_")
-        if isinstance(value, str):
-            field = fb.string_field(field_name, display_name=key)
-            fields.append(field)
-            fields_by_name[key] = field
-        elif isinstance(value, (int, float)):
-            field = fb.double_field(field_name, display_name=key, precision=3)
-            fields.append(field)
-            fields_by_name[key] = field
-
-    # Extract the valid field values from the JSON.
-    field_maps: list[dict[str, Any]] = []
-    for json_dict in json_list:
-        field_map: dict[str, Any] = {}
-        for key, field in fields_by_name.items():
-            # Watch out for NaN values or other special values.
-            val: Any = json_dict.get(key)
-            if (field.data_field_type == FieldType.DOUBLE
-                    and (not isinstance(val, (int, float))) or (isinstance(val, float) and math.isnan(val))):
-                val = None
-            field_map[field.data_field_name] = val
-        field_maps.append(field_map)
-
-    detail_entry = ElnEntryCriteria(ElnEntryType.Table, entry_name,
-                                    ElnBaseDataType.EXPERIMENT_DETAIL.data_type_name,
-                                    tab_next_entry_order(user, exp_id, tab),
-                                    notebook_experiment_tab_id=tab.tab_id,
-                                    field_definition_list=fields)
-    entry = ElnManager(user).add_experiment_entry(exp_id, detail_entry)
-    DataRecordManager(user).add_data_records_with_data(entry.data_type_name, field_maps)
-    return entry
-
-
-def tab_next_entry_order(user: SapioUser, exp_id: int, tab: ElnExperimentTab) -> int:
-    max_order: int = 0
-    for step in ElnExperimentProtocol(ElnExperiment(exp_id, "", 0), user).get_sorted_step_list():
-        if step.eln_entry.notebook_experiment_tab_id == tab.tab_id and step.eln_entry.order > max_order:
-            max_order = step.eln_entry.order
-    return max_order + 1
-
-
-def set_text_entry(timestamp: str, description: str, text_entry: ExperimentEntry, exp_id: int, user: SapioUser,
-                   auto_format: bool = True) -> None:
-    """
-    Set the text of a text entry.
-
-    :param timestamp: The timestamp to display at the top of the text entry.
-    :param description: The description to display in the text entry.
-    :param text_entry: The text entry to set the text of.
-    :param exp_id: The ID of the experiment that the text entry is in.
-    :param user: The user to send the request from.
-    :param auto_format: Whether to automatically format the text to be added.
-    """
-    if auto_format:
-        timestamp = HtmlFormatter.timestamp(timestamp)
-        description = HtmlFormatter.body(description)
-    description: str = f"<p>{timestamp}<br>{description}</p>"
-    protocol = ElnExperimentProtocol(ElnExperiment(exp_id, "", 0), user)
-    step = ElnEntryStep(protocol, text_entry)
-    text_record: DataRecord = step.get_records()[0]
-    text_record.set_field_value(ElnBaseDataType.get_text_entry_data_field_name(), description)
-    DataRecordManager(user).commit_data_records([text_record])
-
-
-def add_to_text_entry(description: str, text_entry: ExperimentEntry, exp_id: int, user: SapioUser,
-                      auto_format: bool = True) -> None:
-    """
-    Add to the text of a text entry.
-
-    :param description: The text to add to the text entry.
-    :param text_entry: The text entry to add the text to.
-    :param exp_id: The ID of the experiment that the text entry is in.
-    :param user: The user to send the request from.
-    :param auto_format: Whether to automatically format the text to be added.
-    """
-    protocol = ElnExperimentProtocol(ElnExperiment(exp_id, "", 0), user)
-    step = ElnEntryStep(protocol, text_entry)
-    text_record: DataRecord = step.get_records()[0]
-    update: str = text_record.get_field_value(ElnBaseDataType.get_text_entry_data_field_name())
-    if auto_format:
-        description = HtmlFormatter.body(description)
-    update += f"<p style=\"padding-top: 10px;\">{description}</p>"
-    text_record.set_field_value(ElnBaseDataType.get_text_entry_data_field_name(), update)
-    DataRecordManager(user).commit_data_records([text_record])
-
-
 class HtmlFormatter:
     """
-    A class for formatting text in HTML with classes supported by the client.
+    A class for formatting text in HTML with tag classes supported by the client.
     """
     TIMESTAMP_TEXT__CSS_CLASS_NAME: Final[str] = "timestamp-text"
     HEADER_1_TEXT__CSS_CLASS_NAME: Final[str] = "header1-text"
@@ -300,6 +167,228 @@ class HtmlFormatter:
         return re.sub("\r?\n", "<br>", text)
 
 
+class AiHelper:
+    """
+    A class with helper methods for the AI to make use of when creating/updating experiment tabs and entries.
+    """
+    # Contextual info.
+    user: SapioUser
+    exp_id: int
+
+    # Managers.
+    dr_man: DataRecordManager
+    eln_man: ElnManager
+
+    def __init__(self, user: SapioUser, exp_id: int):
+        """
+        :param user: The user to send the requests from.
+        :param exp_id: The ID of the experiment to create the entries in.
+        """
+        self.user = user
+        self.exp_id = exp_id
+
+        self.dr_man = DataRecordManager(self.user)
+        self.eln_man = ElnManager(self.user)
+
+    @property
+    def protocol(self) -> ElnExperimentProtocol:
+        """
+        :return: An experiment protocol object for this helper's experiment. (Recreating a new protocol object every
+            time this is called since the protocol's cache could be invalidated by things that the AI is doing.)
+        """
+        # The experiment name and record ID aren't necessary to know for our purposes.
+        return ElnExperimentProtocol(ElnExperiment(self.exp_id, "", 0), self.user)
+
+    def create_tab(self, name: str) -> ElnExperimentTab:
+        """
+        Create a new tab in the experiment.
+
+        :param name: The name of the tab to create.
+        :return: The newly created tab.
+        """
+        tab_crit = ElnExperimentTabAddCriteria(name, [])
+        return self.eln_man.add_tab_for_experiment(self.exp_id, tab_crit)
+
+    def tab_next_entry_order(self, tab: ElnExperimentTab) -> int:
+        """
+        :param tab: A tab in this helper's experiment.
+        :return: The order that the next entry that gets created in the tab should have.
+        """
+        max_order: int = 0
+        for step in self.protocol.get_sorted_step_list():
+            if step.eln_entry.notebook_experiment_tab_id == tab.tab_id and step.eln_entry.order > max_order:
+                max_order = step.eln_entry.order
+        return max_order + 1
+
+    def create_experiment_details_from_data_frame(self,
+                                                  tab: ElnExperimentTab,
+                                                  entry_name: str,
+                                                  df: DataFrame) -> ExperimentEntry | None:
+        """
+        Create an experiment detail entry from a DataFrame.
+
+        :param tab: The tab that the entry should be added to.
+        :param entry_name: The name of the entry.
+        :param df: The DataFrame to create the entry from.
+        :return: The newly created experiment detail entry.
+        """
+        json_list: list[dict[str, Any]] = []
+        for _, row in df.iterrows():
+            json_list.append(row.to_dict())
+        return self.create_experiment_details_from_json(tab, entry_name, json_list)
+
+    def create_experiment_details_from_json(self,
+                                            tab: ElnExperimentTab,
+                                            entry_name: str,
+                                            json_list: list[dict[str, Any]]) -> ExperimentEntry | None:
+        """
+        Create an experiment detail entry from a list of JSON dictionaries.
+
+        :param tab: The tab that the entry should be added to.
+        :param entry_name: The name of the entry.
+        :param json_list: The list of JSON dictionaries to create the entry from. Each dictionary is expected to have the
+            same keys.
+        :return: The newly created experiment detail entry.
+        """
+        if not json_list:
+            return None
+
+        # Determine which fields in the JSON can be used to create field definitions.
+        fb = FieldBuilder()
+        fields: list[AbstractVeloxFieldDefinition] = []
+        fields_by_name: dict[str, AbstractVeloxFieldDefinition] = {}
+        for key, value in json_list[0].items():
+            field_name: str = key.replace(" ", "_")
+            if isinstance(value, str):
+                field = fb.string_field(field_name, display_name=key)
+                fields.append(field)
+                fields_by_name[key] = field
+            elif isinstance(value, (int, float)):
+                field = fb.double_field(field_name, display_name=key, precision=3)
+                fields.append(field)
+                fields_by_name[key] = field
+
+        # Extract the valid field values from the JSON.
+        field_maps: list[dict[str, Any]] = []
+        for json_dict in json_list:
+            field_map: dict[str, Any] = {}
+            for key, field in fields_by_name.items():
+                # Watch out for NaN values or other special values.
+                val: Any = json_dict.get(key)
+                if (field.data_field_type == FieldType.DOUBLE
+                        and (not isinstance(val, (int, float))) or (isinstance(val, float) and math.isnan(val))):
+                    val = None
+                field_map[field.data_field_name] = val
+            field_maps.append(field_map)
+
+        detail_entry = ElnEntryCriteria(ElnEntryType.Table, entry_name,
+                                        ElnBaseDataType.EXPERIMENT_DETAIL.data_type_name,
+                                        self.tab_next_entry_order(tab),
+                                        notebook_experiment_tab_id=tab.tab_id,
+                                        field_definition_list=fields)
+        entry = self.eln_man.add_experiment_entry(self.exp_id, detail_entry)
+        self.dr_man.add_data_records_with_data(entry.data_type_name, field_maps)
+        return entry
+
+    def create_text_entry(self, tab: ElnExperimentTab, timestamp: str, description: str, auto_format: bool = True) \
+            -> ExperimentEntry:
+        """
+        Create a new text entry in the experiment.
+
+        :param tab: The tab to create the text entry in.
+        :param timestamp: The timestamp to display at the top of the text entry.
+        :param description: The description to display in the text entry.
+        :param auto_format: Whether to automatically format the text to be added.
+        :return: The newly created text entry.
+        """
+        if auto_format:
+            description: str = f"<p>{HtmlFormatter.timestamp(timestamp)}<br>{HtmlFormatter.body(description)}</p>"
+        else:
+            description: str = f"<p>{timestamp}<br>{description}</p>"
+        position = ElnEntryPosition(tab.tab_id, self.tab_next_entry_order(tab))
+        text_entry: ElnEntryStep = ELNStepFactory.create_text_entry(self.protocol, description, position)
+        return text_entry.eln_entry
+
+    def set_text_entry(self, text_entry: ExperimentEntry, timestamp: str, description: str,
+                       auto_format: bool = True) -> None:
+        """
+        Set the text of a text entry.
+
+        :param text_entry: The text entry to set the text of.
+        :param timestamp: The timestamp to display at the top of the text entry.
+        :param description: The description to display in the text entry.
+        :param auto_format: Whether to automatically format the text to be added.
+        """
+        if auto_format:
+            timestamp = HtmlFormatter.timestamp(timestamp)
+            description = HtmlFormatter.body(description)
+        description: str = f"<p>{timestamp}<br>{description}</p>"
+        step = ElnEntryStep(self.protocol, text_entry)
+        text_record: DataRecord = step.get_records()[0]
+        text_record.set_field_value(ElnBaseDataType.get_text_entry_data_field_name(), description)
+        self.dr_man.commit_data_records([text_record])
+
+    def add_to_text_entry(self, text_entry: ExperimentEntry, description: str, auto_format: bool = True) -> None:
+        """
+        Add to the text of a text entry.
+
+        :param text_entry: The text entry to add the text to.
+        :param description: The text to add to the text entry.
+        :param auto_format: Whether to automatically format the text to be added.
+        """
+        step = ElnEntryStep(self.protocol, text_entry)
+        text_record: DataRecord = step.get_records()[0]
+        update: str = text_record.get_field_value(ElnBaseDataType.get_text_entry_data_field_name())
+        if auto_format:
+            description = HtmlFormatter.body(description)
+        update += f"<p style=\"padding-top: 10px;\">{description}</p>"
+        text_record.set_field_value(ElnBaseDataType.get_text_entry_data_field_name(), update)
+        self.dr_man.commit_data_records([text_record])
+
+    def create_attachment_entry(self, tab: ElnExperimentTab, entry_name: str, file_name: str, file_data: str | bytes) \
+            -> ExperimentEntry:
+        """
+        Add a new attachment entry to the experiment with the provided attachment data.
+
+        :param tab: The tab where the attachment entry will be added.
+        :param entry_name: Name of the attachment entry to create in the experiment.
+        :param file_name: The name of the attachment.
+        :param file_data: The data of the attachment. This can be a string or bytes.
+        :return: The newly created attachment entry.
+        """
+        tab_id: int = tab.tab_id
+
+        # Encode the file contents in base64.
+        if isinstance(file_data, str):
+            file_data: bytes = file_data.encode("utf-8")
+        base64_encoded: str = base64.b64encode(file_data).decode("utf-8")
+
+        # Crete an attachment entry with the provided data.
+        attachment_entry = self.eln_man.add_experiment_entry(
+            self.exp_id,
+            ElnEntryCriteria(ElnEntryType.Attachment, entry_name, "Attachment", order=2,
+                             notebook_experiment_tab_id=tab_id, attachment_file_name=file_name,
+                             attachment_data_base64=base64_encoded)
+        )
+
+        # Return the entry object for further use.
+        return attachment_entry
+
+    def create_attachment_entry_from_file(self, tab: ElnExperimentTab, entry_name: str, file_path: str) \
+            -> ExperimentEntry:
+        """
+        Add a new attachment entry to the experiment with the provided file path to a file in the file system.
+
+        :param tab: The tab where the attachment entry will be added.
+        :param entry_name: Name of the attachment entry to create in the experiment.
+        :param file_path: The path to a file in the system to attach to the experiment.
+        :return: The newly created attachment entry.
+        """
+        with open(file_path, 'rb') as f:
+            file_contents: bytes = f.read()
+            return self.create_attachment_entry(tab, entry_name, file_path, file_contents)
+
+
 class ToolOfToolsHelper:
     """
     A class with helper methods utilized by the Tool of Tools for the creation and updating of experiment tabs that
@@ -309,7 +398,7 @@ class ToolOfToolsHelper:
     user: SapioUser
     tab_prefix: str
     exp_id: int
-    _protocol: ElnExperimentProtocol
+    helper: AiHelper
 
     # Tool info.
     name: str
@@ -317,8 +406,8 @@ class ToolOfToolsHelper:
     results_data_type: str | None
 
     # Managers.
-    eln_man: ElnManager
     dr_man: DataRecordManager
+    eln_man: ElnManager
 
     # Stuff created by this helper.
     _initialized: bool
@@ -351,15 +440,14 @@ class ToolOfToolsHelper:
         self.user = create_user_from_tot_headers(headers)
         self.exp_id = int(headers[EXP_ID_HEADER.lower()])
         self.tab_prefix = headers[TAB_PREFIX_HEADER.lower()]
-        # The experiment name and record ID aren't necessary to know.
-        self._protocol = ElnExperimentProtocol(ElnExperiment(self.exp_id, "", 0), self.user)
+        self.helper = AiHelper(self.user, self.exp_id)
 
         self.name = name
         self.description = description
         self.results_data_type = results_data_type
 
-        self.eln_man = ElnManager(self.user)
         self.dr_man = DataRecordManager(self.user)
+        self.eln_man = ElnManager(self.user)
 
         self._initialized = False
 
@@ -376,7 +464,7 @@ class ToolOfToolsHelper:
             if tab.tab_name != tab_name:
                 continue
 
-            for entry in self._protocol.get_sorted_step_list():
+            for entry in self.helper.protocol.get_sorted_step_list():
                 if entry.eln_entry.notebook_experiment_tab_id != tab.tab_id:
                     continue
 
@@ -413,9 +501,7 @@ class ToolOfToolsHelper:
             return tab
 
         # Otherwise, create the tab for the tool progress and results.
-        tab_crit = ElnExperimentTabAddCriteria(tab_name, [])
-        tab: ElnExperimentTab = self.eln_man.add_tab_for_experiment(self.exp_id, tab_crit)
-        self.tab = tab
+        self.tab = self.helper.create_tab(tab_name)
 
         # Create a hidden entry for tracking the progress of the tool.
         field_sets: list[ElnFieldSetInfo] = self.eln_man.get_field_set_info_list()
@@ -425,9 +511,9 @@ class ToolOfToolsHelper:
             raise SapioException("Unable to locate the field set for the Tool of Tools progress.")
         progress_entry_crit = ElnEntryCriteria(ElnEntryType.Form, f"ELaiN: {self.name} Progress",
                                                ElnBaseDataType.EXPERIMENT_DETAIL.data_type_name, 1,
-                                               notebook_experiment_tab_id=tab.tab_id,
+                                               notebook_experiment_tab_id=self.tab.tab_id,
                                                enb_field_set_id=progress_field_set[0].field_set_id)
-        progress_entry = ElnEntryStep(self._protocol,
+        progress_entry = ElnEntryStep(self.helper.protocol,
                                       self.eln_man.add_experiment_entry(self.exp_id, progress_entry_crit))
         self.progress_entry = progress_entry
         self.progress_record = progress_entry.get_records()[0]
@@ -441,26 +527,26 @@ class ToolOfToolsHelper:
         # tool started and format the description so that the text isn't too small to read.
         # TODO: Get the UTC offset in seconds from the header once that's being sent.
         now: str = TimeUtil.now_in_format("%Y-%m-%d %H:%M:%S UTC", "UTC")
-        description: str = f"<p>{HtmlFormatter.timestamp(now)}<br>{HtmlFormatter.body(self.description)}</p>"
-        text_entry: ElnEntryStep = ELNStepFactory.create_text_entry(self._protocol, description)
+        text_entry = ElnEntryStep(self.helper.protocol, self.helper.create_text_entry(self.tab, now, self.description))
         self.description_entry = text_entry
         self.description_record = text_entry.get_records()[0]
 
         # Shrink the text entry by one column.
         text_update_crit = ElnTextEntryUpdateCriteria()
+        text_update_crit.column_order = 0
         text_update_crit.column_span = 2
         self.eln_man.update_experiment_entry(self.exp_id, self.description_entry.get_id(), text_update_crit)
 
         # Create a gauge entry to display the progress.
-        gauge_entry: ElnEntryStep = self._create_gauge_chart(self._protocol, progress_entry,
+        gauge_entry: ElnEntryStep = self._create_gauge_chart(self.helper.protocol, progress_entry,
                                                              f"{self.name} Progress", "Progress", "StatusMsg")
         self.progress_gauge_entry = gauge_entry
 
         # Make sure the gauge entry isn't too big and stick it to the right of the text entry.
         dash_update_crit = ElnDashboardEntryUpdateCriteria()
         dash_update_crit.entry_height = 250
-        dash_update_crit.column_span = 2
         dash_update_crit.column_order = 2
+        dash_update_crit.column_span = 2
         self.eln_man.update_experiment_entry(self.exp_id, self.progress_gauge_entry.get_id(), dash_update_crit)
 
         # TODO: Bulk updates aren't working?
@@ -472,13 +558,13 @@ class ToolOfToolsHelper:
 
         # Create a results entry if this tool produces result records.
         if self.results_data_type:
-            results_entry = ELNStepFactory.create_table_step(self._protocol, f"{self.name} Results",
+            results_entry = ELNStepFactory.create_table_step(self.helper.protocol, f"{self.name} Results",
                                                              self.results_data_type)
             self.results_entry = results_entry
         else:
             self.results_entry = None
 
-        return tab
+        return self.tab
 
     def add_to_description(self, description: str, auto_format: bool = True) -> None:
         """
@@ -532,64 +618,35 @@ class ToolOfToolsHelper:
             raise SapioException("The tab for this tool has not been initialized.")
         if not self.results_entry:
             raise SapioException("This tool does not produce result records.")
-        return ELNStepFactory.create_bar_chart_step(self._protocol, self.results_entry, f"{self.name} Results Chart",
-                                                    x_axis, y_axis)[0].eln_entry
+        return ELNStepFactory.create_bar_chart_step(self.helper.protocol, self.results_entry,
+                                                    f"{self.name} Results Chart", x_axis, y_axis)[0].eln_entry
 
-    def add_attachment_entry(self, file_name: str, file_data: str | bytes, entry_name: str,
-                             tab: ElnExperimentTab | None = None) -> ExperimentEntry:
+    def add_attachment_entry(self, entry_name: str, file_name: str, file_data: str | bytes) -> ExperimentEntry:
         """
         Add a new attachment entry to the experiment with the provided attachment data.
 
+        :param entry_name: Name of the attachment entry to create in the experiment.
         :param file_name: The name of the attachment.
         :param file_data: The data of the attachment. This can be a string or bytes.
-        :param entry_name: Name of the attachment entry to create in the experiment.
-        :param tab: The tab where the attachment will be added. If not provided, the tab initialized by this helper
-            will be used.
-        :return: The created entry object.
+        :return: The newly created attachment entry.
         """
-        # Check if the tab has been initialized or a tab has been provided.
-        if not self._initialized and tab is None:
-            raise SapioException("The tab for this tool has not been initialized. Either initialize a tab for this "
-                                 "tool or provide the tab to this function to add the attachment entry to.")
-        tab_id: int = self.tab.tab_id if tab is None else tab.tab_id
-
-        # Encode the file contents in base64.
-        if isinstance(file_data, str):
-            file_data: bytes = file_data.encode("utf-8")
-        base64_encoded: str = base64.b64encode(file_data).decode("utf-8")
-
-        # Crete an attachment entry with the provided data.
-        attachment_entry = self.eln_man.add_experiment_entry(
-            self.exp_id,
-            ElnEntryCriteria(ElnEntryType.Attachment, entry_name, "Attachment", order=2,
-                             notebook_experiment_tab_id=tab_id, attachment_file_name=file_name,
-                             attachment_data_base64=base64_encoded)
-        )
+        if not self._initialized:
+            raise SapioException("The tab for this tool has not been initialized.")
 
-        # Return the entry object for further use.
-        return attachment_entry
+        return self.helper.create_attachment_entry(self.tab, entry_name, file_name, file_data)
 
-    def add_attachment_entry_from_file_system(self, file_path: str, entry_name: str,
-                                              tab: ElnExperimentTab | None = None) -> ExperimentEntry:
+    def add_attachment_entry_from_file(self, entry_name: str, file_path: str) -> ExperimentEntry:
         """
         Add a new attachment entry to the experiment with the provided file path to a file in the file system.
 
-        :param file_path: The path to a file in the system to attach to the experiment.
         :param entry_name: Name of the attachment entry to create in the experiment.
-        :param tab: The tab where the attachment will be added. If not provided, the tab initialized by this helper
-            will be used.
-        :return: The created entry object.
+        :param file_path: The path to a file in the system to attach to the experiment.
+        :return: The newly created attachment entry.
         """
-        # Check if the tab has been initialized or a tab has been provided.
-        # This is redundant with the same check in the add_attachment_entry function, but it's duplicated here as to
-        # not read the provided file and then find out we can't do anything with it anyway.
-        if not self._initialized and tab is None:
-            raise SapioException("The tab for this tool has not been initialized. Either initialize a tab for this "
-                                 "tool or provide the tab to this function to add the attachment entry to.")
+        if not self._initialized:
+            raise SapioException("The tab for this tool has not been initialized.")
 
-        with open(file_path, 'rb') as f:
-            file_contents: bytes = f.read()
-            return self.add_attachment_entry(file_path, file_contents, entry_name, tab)
+        return self.helper.create_attachment_entry_from_file(self.tab, entry_name, file_path)
 
     # TODO: Remove this once pylib's gauge chart definition is up to date.
     @staticmethod