sapiopycommons 2025.7.31a664__tar.gz → 2025.8.1a670__tar.gz

{sapiopycommons-2025.7.31a664 → sapiopycommons-2025.8.1a670}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.7.31a664
+Version: 2025.8.1a670
 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>
@@ -17,7 +17,7 @@ Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: databind>=4.5
-Requires-Dist: sapiopylib>=2025.4.17.264
+Requires-Dist: sapiopylib>=2025.7.31a279
 Description-Content-Type: text/markdown
 
 

{sapiopycommons-2025.7.31a664 → sapiopycommons-2025.8.1a670}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2025.07.31a664'
+version='2025.08.01a670'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },
@@ -14,7 +14,7 @@ license = "MPL-2.0"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-        'sapiopylib>=2025.4.17.264', 'databind>=4.5'
+        'sapiopylib>=2025.7.31a279', 'databind>=4.5'
 ]
 classifiers = [
     "Intended Audience :: Developers",

{sapiopycommons-2025.7.31a664 → sapiopycommons-2025.8.1a670}/src/sapiopycommons/ai/tool_of_tools.py

@@ -1,30 +1,31 @@
 import base64
 import io
 import math
-import re
 from typing import Final, Mapping, Any
 
 import requests
 from pandas import DataFrame
 from requests import Response
+from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.DataTypeService import DataTypeManager
 from sapiopylib.rest.ELNService import ElnManager
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.Sort import SortDirection
-from sapiopylib.rest.pojo.chartdata.DashboardDefinition import GaugeChartDefinition
-from sapiopylib.rest.pojo.chartdata.DashboardEnums import ChartGroupingType, ChartOperationType
+from sapiopylib.rest.pojo.chartdata.DashboardDefinition import GaugeChartDefinition, DashboardDefinition
+from sapiopylib.rest.pojo.chartdata.DashboardEnums import ChartGroupingType, ChartOperationType, DashboardScope
 from sapiopylib.rest.pojo.chartdata.DashboardSeries import GaugeChartSeries
 from sapiopylib.rest.pojo.datatype.DataType import DataTypeDefinition
 from sapiopylib.rest.pojo.datatype.DataTypeLayout import DataTypeLayout, TableLayout
-from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition, FieldType
+from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition, FieldType, \
+    VeloxStringFieldDefinition
 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, \
-    ElnDashboardEntryUpdateCriteria, ElnTextEntryUpdateCriteria
-from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnEntryType, ElnBaseDataType
+    ElnDashboardEntryUpdateCriteria
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnEntryType, ElnBaseDataType, ExperimentEntryStatus
 from sapiopylib.rest.pojo.eln.eln_headings import ElnExperimentTabAddCriteria, ElnExperimentTab
 from sapiopylib.rest.pojo.eln.field_set import ElnFieldSetInfo
 from sapiopylib.rest.utils.ProtocolUtils import ELNStepFactory
@@ -33,6 +34,7 @@ from sapiopylib.rest.utils.Protocols import ElnEntryStep, ElnExperimentProtocol
 from sapiopycommons.callbacks.field_builder import FieldBuilder
 from sapiopycommons.general.aliases import AliasUtil, SapioRecord
 from sapiopycommons.general.exceptions import SapioException
+from sapiopycommons.general.html_formatter import HtmlFormatter
 from sapiopycommons.general.time_util import TimeUtil
 from sapiopycommons.multimodal.multimodal import MultiModalManager
 from sapiopycommons.multimodal.multimodal_data import ImageDataRequestPojo
@@ -100,88 +102,6 @@ def format_tot_headers(headers: Mapping[str, str]) -> dict[str, str]:
     return {k.lower(): v for k, v in headers.items()}
 
 
-class HtmlFormatter:
-    """
-    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"
-    HEADER_2_TEXT__CSS_CLASS_NAME: Final[str] = "header2-text"
-    HEADER_3_TEXT__CSS_CLASS_NAME: Final[str] = "header3-text"
-    BODY_TEXT__CSS_CLASS_NAME: Final[str] = "body-text"
-    CAPTION_TEXT__CSS_CLASS_NAME: Final[str] = "caption-text"
-
-    @staticmethod
-    def timestamp(text: str) -> str:
-        """
-        Given a text string, return that same text string HTML formatted using the timestamp CSS class.
-
-        :param text: The text to format.
-        :return: The HTML formatted text.
-        """
-        return f"<span class=\"{HtmlFormatter.TIMESTAMP_TEXT__CSS_CLASS_NAME}\">{text}</span>"
-
-    @staticmethod
-    def header_1(text: str) -> str:
-        """
-        Given a text string, return that same text string HTML formatted using the header 1 CSS class.
-
-        :param text: The text to format.
-        :return: The HTML formatted text.
-        """
-        return f"<span class=\"{HtmlFormatter.HEADER_1_TEXT__CSS_CLASS_NAME}\">{text}</span>"
-
-    @staticmethod
-    def header_2(text: str) -> str:
-        """
-        Given a text string, return that same text string HTML formatted using the header 2 CSS class.
-
-        :param text: The text to format.
-        :return: The HTML formatted text.
-        """
-        return f"<span class=\"{HtmlFormatter.HEADER_2_TEXT__CSS_CLASS_NAME}\">{text}</span>"
-
-    @staticmethod
-    def header_3(text: str) -> str:
-        """
-        Given a text string, return that same text string HTML formatted using the header 3 CSS class.
-
-        :param text: The text to format.
-        :return: The HTML formatted text.
-        """
-        return f"<span class=\"{HtmlFormatter.HEADER_3_TEXT__CSS_CLASS_NAME}\">{text}</span>"
-
-    @staticmethod
-    def body(text: str) -> str:
-        """
-        Given a text string, return that same text string HTML formatted using the body CSS class.
-
-        :param text: The text to format.
-        :return: The HTML formatted text.
-        """
-        return f"<span class=\"{HtmlFormatter.BODY_TEXT__CSS_CLASS_NAME}\">{text}</span>"
-
-    @staticmethod
-    def caption(text: str) -> str:
-        """
-        Given a text string, return that same text string HTML formatted using the caption CSS class.
-
-        :param text: The text to format.
-        :return: The HTML formatted text.
-        """
-        return f"<span class=\"{HtmlFormatter.CAPTION_TEXT__CSS_CLASS_NAME}\">{text}</span>"
-
-    @staticmethod
-    def replace_newlines(text: str) -> str:
-        """
-        Given a text string, return that same text string HTML formatted with newlines replaced by HTML line breaks.
-
-        :param text: The text to format.
-        :return: The HTML formatted text.
-        """
-        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.
@@ -189,25 +109,28 @@ class AiHelper:
     # Contextual info.
     user: SapioUser
     exp_id: int
+    timeout: int
 
     # Managers.
     dr_man: DataRecordManager
     eln_man: ElnManager
     dt_man: DataTypeManager
 
-    def __init__(self, user: SapioUser, exp_id: int):
+    def __init__(self, user: SapioUser, exp_id: int, timeout: int = 120):
         """
         :param user: The user to send the requests from.
         :param exp_id: The ID of the experiment to create the entries in.
+        :param timeout: The timeout in seconds to use for requests.
         """
         self.user = user
         self.exp_id = exp_id
+        self.timeout = timeout
 
         self.dr_man = DataRecordManager(self.user)
         self.eln_man = ElnManager(self.user)
         self.dt_man = DataTypeManager(self.user)
 
-    def call_endpoint(self, url: str, payload: Any, tab_prefix: str = "") -> Response:
+    def call_post_endpoint(self, url: str, payload: Any, tab_prefix: str = "") -> Response:
         """
         Call a tool endpoint. Constructs the tool headers and checks the response for errors for the caller.
 
@@ -217,7 +140,21 @@ class AiHelper:
         :return: The Response object returned by the endpoint.
         """
         headers = create_tot_headers(self.user.url, self.user.username, self.user.password, self.exp_id, tab_prefix)
-        response = requests.post(url, json=payload, headers=headers)
+        response = requests.post(url, json=payload, headers=headers, timeout=self.timeout)
+        response.raise_for_status()
+        return response
+
+    def call_get_endpoint(self, url: str, params: Any, tab_prefix: str = "") -> Response:
+        """
+        Call a tool endpoint. Constructs the tool headers and checks the response for errors for the caller.
+
+        :param url: The URL of the endpoint to call.
+        :param params: The query parameters to send to the endpoint.
+        :param tab_prefix: The prefix to use for the tab name that will be created by the tool.
+        :return: The Response object returned by the endpoint.
+        """
+        headers = create_tot_headers(self.user.url, self.user.username, self.user.password, self.exp_id, tab_prefix)
+        response = requests.get(url, params=params, headers=headers, timeout=self.timeout)
         response.raise_for_status()
         return response
 
@@ -307,20 +244,75 @@ class AiHelper:
         if not json_list:
             return None
 
+        def update_string_field(f: AbstractVeloxFieldDefinition, v: Any) -> None:
+            """
+            Update the max length of the string field and whether it is a link-out field depending on the length and
+            form of the given value.
+
+            :param f: The definition of the string field.
+            :param v: A field value that will be present for this field.
+            """
+            if not isinstance(f, VeloxStringFieldDefinition) or v is None:
+                return
+            sv = str(v)
+            f.max_length = max(f.max_length, len(sv))
+            if not f.link_out and sv.startswith("http://") or sv.startswith("https://"):
+                link_out, link_out_url = FieldBuilder._convert_link_out({"Link": "[[LINK_OUT]]"})
+                f.link_out = link_out
+                f.link_out_url = link_out_url
+
         # 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
+        json_key_to_field_def: dict[str, AbstractVeloxFieldDefinition] = {}
+        numeric_string_fields: set[str] = set()
+        for values in json_list:
+            for key, value in values.items():
+                # Skip null values, since we can't know what type they're meant to represent.
+                if value is None:
+                    continue
+
+                # The field name is the JSON key name, but with spaces and dashes replaced by underscores and with a
+                # leading underscore added if the field name starts with a number.
+                field_name: str = key.strip()
+                if " " in field_name:
+                    field_name = field_name.replace(" ", "_")
+                if "-" in field_name:
+                    field_name = field_name.replace("-", "_")
+                if field_name[0].isnumeric():
+                    field_name = "_" + field_name
+
+                # If this is the first time this key is being encountered, create a field for it.
+                if key not in json_key_to_field_def:
+                    if isinstance(value, str):
+                        json_key_to_field_def[key] = fb.string_field(field_name, display_name=key)
+                        update_string_field(json_key_to_field_def[key], value)
+                    elif isinstance(value, bool):
+                        json_key_to_field_def[key] = fb.boolean_field(field_name, display_name=key)
+                    elif isinstance(value, (int, float)):
+                        json_key_to_field_def[key] = fb.double_field(field_name, display_name=key, precision=3)
+                    # All other values in the JSON get skipped.
+                    continue
+
+                # The field definition already exists, but it may not be a valid field type for this value.
+                field_type: FieldType = json_key_to_field_def[key].data_field_type
+                # Strings can be anything, so we don't need to check the value type.
+                if field_type == FieldType.STRING:
+                    # We still need to make sure the lengths are fine.
+                    update_string_field(json_key_to_field_def[key], value)
+                    continue
+                # Boolean values can only be booleans.
+                if field_type == FieldType.BOOLEAN and isinstance(value, bool):
+                    continue
+                # Integers and floats both fit in DOUBLE fields, but floats can't be NaN or infinity.
+                if field_type == FieldType.DOUBLE:
+                    # Booleans count as ints for isinstance, so make sure that true integers continue but bools don't.
+                    if isinstance(value, int) and not isinstance(value, bool):
+                        continue
+                    if isinstance(value, float) and not math.isnan(value) and not math.isinf(value):
+                        continue
+                    numeric_string_fields.add(key)
+                json_key_to_field_def[key] = fb.string_field(field_name, display_name=key)
+                update_string_field(json_key_to_field_def[key], value)
 
         # Sort the JSON list if requested.
         if sort_field and sort_direction != SortDirection.NONE:
@@ -340,12 +332,10 @@ class AiHelper:
         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 in numeric columns.
+            for key, field in json_key_to_field_def.items():
                 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
+                if key in numeric_string_fields and val is not None and isinstance(val, (int, float)):
+                    val: str = f"{val:.3f}"
                 field_map[field.data_field_name] = val
             field_maps.append(field_map)
 
@@ -354,7 +344,7 @@ class AiHelper:
                                         ElnBaseDataType.EXPERIMENT_DETAIL.data_type_name,
                                         self.tab_next_entry_order(tab),
                                         notebook_experiment_tab_id=tab.tab_id,
-                                        field_definition_list=fields)
+                                        field_definition_list=[y for x, y in json_key_to_field_def.items()])
         entry = self.eln_man.add_experiment_entry(self.exp_id, detail_entry)
         records: list[DataRecord] = self.dr_man.add_data_records_with_data(entry.data_type_name, field_maps)
 
@@ -539,6 +529,8 @@ class ToolOfToolsHelper:
     # Stuff created by this helper.
     _initialized: bool
     """Whether a tab for this tool has been initialized."""
+    _new_tab: bool
+    """Whether a new tab was created for this tool."""
     tab: ElnExperimentTab
     """The tab that contains the tool's entries."""
     description_entry: ElnEntryStep | None
@@ -577,6 +569,15 @@ class ToolOfToolsHelper:
         self.eln_man = ElnManager(self.user)
 
         self._initialized = False
+        self._new_tab = False
+
+    @property
+    def is_initialized(self) -> bool:
+        return self._initialized
+
+    @property
+    def is_new_tab(self) -> bool:
+        return self._new_tab
 
     def initialize_tab(self) -> ElnExperimentTab:
         if self._initialized:
@@ -629,6 +630,7 @@ class ToolOfToolsHelper:
 
         # Otherwise, create the tab for the tool progress and results.
         self.tab = self.helper.create_tab(tab_name)
+        self._new_tab = True
 
         # Create a hidden entry for tracking the progress of the tool.
         field_sets: list[ElnFieldSetInfo] = self.eln_man.get_field_set_info_list()
@@ -636,16 +638,18 @@ class ToolOfToolsHelper:
                                                      x.field_set_name == "Tool of Tools Progress"]
         if not progress_field_set:
             raise SapioException("Unable to locate the field set for the Tool of Tools progress.")
-        progress_entry_crit = ElnEntryCriteria(ElnEntryType.Form, f"{tab_name} Progress",
-                                               ElnBaseDataType.EXPERIMENT_DETAIL.data_type_name, 1,
-                                               notebook_experiment_tab_id=self.tab.tab_id,
-                                               enb_field_set_id=progress_field_set[0].field_set_id)
+        progress_entry_crit = _ElnEntryCriteria(ElnEntryType.Form, f"{tab_name} Progress",
+                                                ElnBaseDataType.EXPERIMENT_DETAIL.data_type_name, 1,
+                                                notebook_experiment_tab_id=self.tab.tab_id,
+                                                enb_field_set_id=progress_field_set[0].field_set_id,
+                                                is_hidden=True)
         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]
 
         # Hide the progress entry.
+        # TODO: Remove once we get this working on entry creation.
         form_update_crit = ElnFormEntryUpdateCriteria()
         form_update_crit.is_hidden = True
         self.eln_man.update_experiment_entry(self.exp_id, self.progress_entry.get_id(), form_update_crit)
@@ -654,26 +658,22 @@ 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")
-        text_entry = ElnEntryStep(self.helper.protocol, self.helper.create_text_entry(self.tab, now, self.description))
+        description: str = f"<p>{HtmlFormatter.timestamp(now)}<br>{HtmlFormatter.body(self.description)}</p>"
+        text_entry: ElnEntryStep = _ELNStepFactory.create_text_entry(self.helper.protocol, description,
+                                                                     column_order=0, column_span=2)
         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.helper.protocol, progress_entry,
-                                                             f"{self.name} Progress", "Progress", "StatusMsg")
+        gauge_entry: ElnEntryStep = _ELNStepFactory._create_gauge_chart(self.helper.protocol, progress_entry,
+                                                                        f"{self.name} Progress", "Progress", "StatusMsg",
+                                                                        column_order=2, column_span=2, entry_height=250)
         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.
+        # TODO: Remove once we get this working on entry creation.
         dash_update_crit = ElnDashboardEntryUpdateCriteria()
         dash_update_crit.entry_height = 250
-        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)
 
         # Create a results entry if this tool produces result records.
@@ -768,10 +768,37 @@ class ToolOfToolsHelper:
 
         return self.helper.create_attachment_entry_from_file(self.tab, entry_name, file_path)
 
+
+class _ELNStepFactory:
+    """
+    Factory that provides simple functions to create a new ELN step under an ELN protocol.
+    """
+    @staticmethod
+    def create_text_entry(protocol: ElnExperimentProtocol, text_data: str,
+                          position: ElnEntryPosition | None = None, **kwargs) -> ElnEntryStep:
+        """
+        Create a text entry at the end of the protocol, with a initial text specified in the text entry.
+        :param protocol: The protocol to create a new step for.
+        :param text_data: Must be non-blank. This is what will be displayed. Some HTML format tags can be inserted.
+        :param position: The position of the new step. If not specified, the new step will be added at the end.
+        :return: The new text entry step.
+        """
+        eln_manager, new_entry = _ELNStepFactory._get_entry_creation_criteria(ElnBaseDataType.TEXT_ENTRY_DETAIL.data_type_name,
+                                                                              protocol, 'Text Entry', ElnEntryType.Text,
+                                                                              position, **kwargs)
+        record = eln_manager.get_data_records_for_entry(protocol.eln_experiment.notebook_experiment_id,
+                                                        new_entry.entry_id).result_list[0]
+        record.set_field_value(ElnBaseDataType.get_text_entry_data_field_name(), text_data)
+        DataMgmtServer.get_data_record_manager(protocol.user).commit_data_records([record])
+        ret = ElnEntryStep(protocol, new_entry)
+        protocol.invalidate()
+        return ret
+
     # TODO: Remove this once pylib's gauge chart definition is up to date.
     @staticmethod
     def _create_gauge_chart(protocol: ElnExperimentProtocol, data_source_step: ElnEntryStep, step_name: str,
-                            field_name: str, status_field: str, group_by_field_name: str = "DataRecordName") \
+                            field_name: str, status_field: str, group_by_field_name: str = "DataRecordName",
+                            **kwargs) \
             -> ElnEntryStep:
         """
         Create a gauge chart step in the experiment protocol.
@@ -790,11 +817,55 @@ class ToolOfToolsHelper:
         chart.grouping_type = ChartGroupingType.GROUP_BY_FIELD
         chart.grouping_type_data_type_name = data_type_name
         chart.grouping_type_data_field_name = group_by_field_name
-        dashboard, step = ELNStepFactory._create_dashboard_step_from_chart(chart, data_source_step, protocol, step_name,
-                                                                           None)
+        dashboard, step = _ELNStepFactory._create_dashboard_step_from_chart(chart, data_source_step, protocol, step_name,
+                                                                            None, **kwargs)
         protocol.invalidate()
         return step
 
+    @staticmethod
+    def _create_dashboard_step_from_chart(chart: GaugeChartDefinition, data_source_step: ElnEntryStep,
+                                          protocol: ElnExperimentProtocol, step_name: str,
+                                          position: ElnEntryPosition | None = None, **kwargs) -> \
+            tuple[DashboardDefinition, ElnEntryStep]:
+        dashboard: DashboardDefinition = DashboardDefinition()
+        dashboard.chart_definition_list = [chart]
+        dashboard.dashboard_scope = DashboardScope.PRIVATE_ELN
+        dashboard = DataMgmtServer.get_dashboard_manager(protocol.user).store_dashboard_definition(dashboard)
+        eln_manager, new_entry = _ELNStepFactory._get_entry_creation_criteria("", protocol, step_name,
+                                                                              ElnEntryType.Dashboard, position,
+                                                                              **kwargs)
+        # noinspection PyTypeChecker
+        update_criteria = ElnDashboardEntryUpdateCriteria()
+        update_criteria.dashboard_guid = dashboard.dashboard_guid
+        update_criteria.data_source_entry_id = data_source_step.get_id()
+        update_criteria.entry_height = 500
+        eln_manager.update_experiment_entry(protocol.eln_experiment.notebook_experiment_id, new_entry.entry_id,
+                                            update_criteria)
+        step = ElnEntryStep(protocol, new_entry)
+        return dashboard, step
+
+    @staticmethod
+    def _get_entry_creation_criteria(data_type_name: str | None, protocol: ElnExperimentProtocol,
+                                     step_name: str, entry_type: ElnEntryType, position: ElnEntryPosition | None = None,
+                                     **kwargs):
+        tab_id: int | None = None
+        order: int | None = None
+        if position:
+            tab_id = position.tab_id
+            order = position.order
+        # noinspection PyTypeChecker
+        last_step: ElnEntryStep = protocol.get_sorted_step_list()[-1]
+        if tab_id is None:
+            tab_id = last_step.eln_entry.notebook_experiment_tab_id
+        if order is None:
+            order = last_step.eln_entry.order + 1
+        eln_manager = DataMgmtServer.get_eln_manager(protocol.user)
+        entry_criteria = _ElnEntryCriteria(entry_type, step_name, data_type_name, order,
+                                           notebook_experiment_tab_id=tab_id, **kwargs)
+        new_entry: ExperimentEntry = eln_manager.add_experiment_entry(protocol.eln_experiment.notebook_experiment_id,
+                                                                      entry_criteria)
+        return eln_manager, new_entry
+
 
 # TODO: Using this to set the new status field setting.
 class _GaugeChartDefinition(GaugeChartDefinition):
@@ -807,3 +878,40 @@ class _GaugeChartDefinition(GaugeChartDefinition):
             "dataFieldName": self.status_field
         }
         return result
+
+
+class _ElnEntryCriteria(ElnEntryCriteria):
+    is_hidden: bool | None
+    entry_height: int | None
+    description: str | None
+    is_initialization_required: bool | None
+    collapse_entry: bool | None
+    entry_status: ExperimentEntryStatus | None
+    template_item_fulfilled_timestamp: int | None
+
+    def __init__(self, entry_type: ElnEntryType, entry_name: str | None, data_type_name: str | None, order: int,
+                 is_hidden: bool | None = None, entry_height: int | None = None, description: str | None = None,
+                 is_initialization_required: bool | None = None, collapse_entry: bool | None = None,
+                 entry_status: ExperimentEntryStatus | None = None, template_item_fulfilled_timestamp: int | None = None,
+                 **kwargs):
+        super().__init__(entry_type, entry_name, data_type_name, order, **kwargs)
+        self.is_hidden = is_hidden
+        self.entry_height = entry_height
+        self.description = description
+        self.is_initialization_required = is_initialization_required
+        self.collapse_entry = collapse_entry
+        self.entry_status = entry_status
+        self.template_item_fulfilled_timestamp = template_item_fulfilled_timestamp
+
+    def to_json(self) -> dict[str, Any]:
+        ret: dict[str, Any] = super().to_json()
+        ret.update({
+            "hidden": self.is_hidden,
+            "entryHeight": self.entry_height,
+            "description": self.description,
+            "initializationRequired": self.is_initialization_required,
+            "collapsed": self.collapse_entry,
+            "entryStatus": self.entry_status,
+            "templateItemFulfilledTimestamp": self.template_item_fulfilled_timestamp
+        })
+        return ret

{sapiopycommons-2025.7.31a664 → sapiopycommons-2025.8.1a670}/src/sapiopycommons/callbacks/callback_util.py

@@ -1815,7 +1815,8 @@ class CallbackUtil:
         return response
 
     def request_file(self, title: str, exts: Iterable[str] | None = None,
-                     show_image_editor: bool = False, show_camera_button: bool = False) -> tuple[str, bytes]:
+                     show_image_editor: bool = False, show_camera_button: bool = False,
+                     *, enforce_file_extensions: bool = True) -> tuple[str, bytes]:
         """
         Request a single file from the user.
 
@@ -1825,6 +1826,8 @@ class CallbackUtil:
         :param show_image_editor: Whether the user will see an image editor when image is uploaded in this file prompt.
         :param show_camera_button: Whether the user will be able to use camera to take a picture as an upload request,
             rather than selecting an existing file.
+        :param enforce_file_extensions: If true, then the file extensions provided in the exts parameter will be
+            enforced. If false, then the user may upload any file type.
         :return: The file name and bytes of the uploaded file.
         """
         # If no extensions were provided, use an empty list for the extensions instead.
@@ -1844,11 +1847,12 @@ class CallbackUtil:
             file_path: str = self.__send_dialog(request, self.callback.show_file_dialog, data_sink=do_consume)
 
         # Verify that each of the file given matches the expected extension(s).
-        self.__verify_file(file_path, sink.data, exts)
+        self.__verify_file(file_path, sink.data, exts if enforce_file_extensions else None)
         return file_path, sink.data
 
     def request_files(self, title: str, exts: Iterable[str] | None = None,
-                      show_image_editor: bool = False, show_camera_button: bool = False) -> dict[str, bytes]:
+                      show_image_editor: bool = False, show_camera_button: bool = False,
+                      *, enforce_file_extensions: bool = True) -> dict[str, bytes]:
         """
         Request multiple files from the user.
 
@@ -1858,6 +1862,8 @@ class CallbackUtil:
         :param show_image_editor: Whether the user will see an image editor when image is uploaded in this file prompt.
         :param show_camera_button: Whether the user will be able to use camera to take a picture as an upload request,
             rather than selecting an existing file.
+        :param enforce_file_extensions: If true, then the file extensions provided in the exts parameter will be
+            enforced. If false, then the user may upload any file type.
         :return: A dictionary of file name to file bytes for each file the user uploaded.
         """
         # If no extensions were provided, use an empty list for the extensions instead.
@@ -1873,7 +1879,7 @@ class CallbackUtil:
         for file_path in file_paths:
             sink = InMemoryRecordDataSink(self.user)
             sink.consume_client_callback_file_path_data(file_path)
-            self.__verify_file(file_path, sink.data, exts)
+            self.__verify_file(file_path, sink.data, exts if enforce_file_extensions else None)
             ret_dict.update({file_path: sink.data})
 
         return ret_dict
@@ -1890,16 +1896,17 @@ class CallbackUtil:
         """
         if file_path is None or len(file_path) == 0 or file_bytes is None or len(file_bytes) == 0:
             raise SapioUserErrorException("Empty file provided or file unable to be read.")
-        if allowed_extensions:
-            matches: bool = False
-            for ext in allowed_extensions:
-                # FR-47690: Changed to a case-insensitive match.
-                if file_path.casefold().endswith("." + ext.lstrip(".").casefold()):
-                    matches = True
-                    break
-            if matches is False:
-                raise SapioUserErrorException("Unsupported file type. Expecting the following extension(s): "
-                                              + (",".join(allowed_extensions)))
+        if not allowed_extensions:
+            return
+        matches: bool = False
+        for ext in allowed_extensions:
+            # FR-47690: Changed to a case-insensitive match.
+            if file_path.casefold().endswith("." + ext.lstrip(".").casefold()):
+                matches = True
+                break
+        if not matches:
+            raise SapioUserErrorException("Unsupported file type. Expecting the following extension(s): "
+                                          + (",".join(allowed_extensions)))
 
     def write_file(self, file_name: str, file_data: str | bytes) -> None:
         """