sapiopycommons 2025.2.3a411__tar.gz → 2025.2.5a412__tar.gz

{sapiopycommons-2025.2.3a411 → sapiopycommons-2025.2.5a412}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.2.3a411
+Version: 2025.2.5a412
 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.3a411 → sapiopycommons-2025.2.5a412}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2025.02.03a411'
+version='2025.02.05a412'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

{sapiopycommons-2025.2.3a411 → sapiopycommons-2025.2.5a412}/src/sapiopycommons/elain/tool_of_tools.py

@@ -1,4 +1,5 @@
 import base64
+from typing import Final, Mapping, Any
 
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.ELNService import ElnManager
@@ -18,6 +19,11 @@ from sapiopylib.rest.utils.Protocols import ElnEntryStep, ElnExperimentProtocol
 
 from sapiopycommons.general.exceptions import SapioException
 
+CREDENTIALS_HEADER: Final[str] = "SAPIO_APP_API_KEY"
+API_URL_HEADER: Final[str] = "SAPIO_APP_API_URL"
+EXP_ID_HEADER: Final[str] = "EXPERIMENT_ID"
+TAB_PREFIX_HEADER: Final[str] = "TAB_PREFIX"
+
 
 # FR-47422: Create utility methods to assist the tool of tools.
 def create_tot_headers(url: str, username: str, password: str, experiment_id: int, tab_prefix: str) \
@@ -38,23 +44,36 @@ def create_tot_headers(url: str, username: str, password: str, experiment_id: in
     # and finally convert the result back into a string.
     encoded_credentials: str = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
     headers: dict[str, str] = {
-        "SAPIO_APP_API_KEY": f"Basic {encoded_credentials}",
-        "SAPIO_APP_API_URL": url,
-        "EXPERIMENT_ID": str(experiment_id),
-        "TAB_PREFIX": tab_prefix
+        CREDENTIALS_HEADER: f"Basic {encoded_credentials}",
+        API_URL_HEADER: url,
+        EXP_ID_HEADER: str(experiment_id),
+        TAB_PREFIX_HEADER: tab_prefix
     }
     return encoded_credentials, headers
 
 
-def create_user_from_tot_headers(headers: dict[str, str]) -> SapioUser:
+def create_user_from_tot_headers(headers: Mapping[str, str]) -> SapioUser:
     """
     Create a SapioUser object from the headers passed to a tool of tools endpoint.
 
     :param headers: The headers that were passed to the endpoint.
     :return: A SapioUser object created from the headers that can be used to communicate with the Sapio server.
     """
-    credentials = base64.b64decode(headers["SAPIO_APP_API_KEY"].removeprefix("Basic ")).decode("utf-8").split(":", 1)
-    return SapioUser(headers["SAPIO_APP_API_URL"], username=credentials[0], password=credentials[1])
+    headers: dict[str, str] = format_tot_headers(headers)
+    credentials = (base64.b64decode(headers[CREDENTIALS_HEADER.lower()].removeprefix("Basic "))
+                   .decode("utf-8").split(":", 1))
+    return SapioUser(headers[API_URL_HEADER.lower()], username=credentials[0], password=credentials[1])
+
+
+def format_tot_headers(headers: Mapping[str, str]) -> dict[str, str]:
+    """
+    Format the headers passed to a tool of tools endpoint to guarantee that the keys are lowercase.
+
+    :param headers: The headers that were passed to the endpoint.
+    :return: The headers with all keys converted to lowercase. (Conflicting keys will cause one to overwrite the other,
+        but there should not be any conflicting keys in the headers passed to a tool of tools endpoint.)
+    """
+    return {k.lower(): v for k, v in headers.items()}
 
 
 class ToolOfToolsHelper:
@@ -93,7 +112,8 @@ class ToolOfToolsHelper:
     results_entry: ElnEntryStep | None
     """An entry for displaying the results of the tool. If None, the tool does not produce result records."""
 
-    def __init__(self, headers: dict[str, str], name: str, description: str, results_data_type: str | None = None):
+    def __init__(self, headers: Mapping[str, str], name: str, description: str,
+                 results_data_type: str | None = None):
         """
         :param headers: The headers that were passed to the endpoint.
         :param name: The name of the tool.
@@ -101,9 +121,10 @@ class ToolOfToolsHelper:
         :param results_data_type: The data type name for the results of the tool. If None, the tool does not produce
             result records.
         """
+        headers: dict[str, str] = format_tot_headers(headers)
         self.user = create_user_from_tot_headers(headers)
-        self.exp_id = int(headers["EXPERIMENT_ID"])
-        self.tab_prefix = headers["TAB_PREFIX"]
+        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)
 
@@ -121,9 +142,49 @@ class ToolOfToolsHelper:
             return self.tab
         self._initialized = True
 
-        # Create the tab for the tool progress and results.
-        # The entry IDs list can't be empty, so we need to create a dummy entry just to get the tab created.
-        tab_crit = ElnExperimentTabAddCriteria(f"{self.tab_prefix} {self.name}", [])
+        # Determine if a previous call to this endpoint already created a tab for these results. If so, grab the entries
+        # from that tab.
+        tab_name: str = f"{self.tab_prefix.strip()} {self.name.strip()}"
+        tabs: list[ElnExperimentTab] = self.eln_man.get_tabs_for_experiment(self.exp_id)
+        for tab in tabs:
+            if tab.tab_name != tab_name:
+                continue
+
+            for entry in self._protocol.get_sorted_step_list():
+                if entry.eln_entry.notebook_experiment_tab_id != tab.tab_id:
+                    continue
+
+                dt: str = entry.get_data_type_names()[0]
+                if (entry.eln_entry.entry_type == ElnEntryType.Form
+                        and ElnBaseDataType.get_base_type(dt) == ElnBaseDataType.EXPERIMENT_DETAIL
+                        and not hasattr(self, "progress_entry")):
+                    self.progress_entry = entry
+                    self.progress_record = entry.get_records()[0]
+                elif (entry.eln_entry.entry_type == ElnEntryType.Dashboard
+                      and not hasattr(self, "progress_gauge_entry")):
+                    self.progress_gauge_entry = entry
+                elif (entry.eln_entry.entry_type == ElnEntryType.Text
+                      and not hasattr(self, "description_entry")):
+                    self.description_entry = entry
+                elif (entry.eln_entry.entry_type == ElnEntryType.Table
+                      and dt == self.results_data_type
+                      and not hasattr(self, "result_entry")):
+                    self.results_entry = entry
+
+            if not hasattr(self, "progress_entry"):
+                self.results_entry = None
+            if not hasattr(self, "progress_gauge_entry"):
+                self.results_entry = None
+            if not hasattr(self, "description_entry"):
+                self.results_entry = None
+            if not hasattr(self, "result_entry"):
+                self.results_entry = None
+
+            self.tab = tab
+            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
 
@@ -149,7 +210,7 @@ class ToolOfToolsHelper:
 
         # Create a gauge entry to display the progress.
         gauge_entry: ElnEntryStep = self._create_gauge_chart(self._protocol, progress_entry,
-                                                             f"{self.name} Progress", "Progress")
+                                                             f"{self.name} Progress", "Progress", "StatusMsg")
         self.progress_gauge_entry = gauge_entry
 
         # Create the text entry that displays the description of the tool.
@@ -158,7 +219,8 @@ 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", self.results_data_type)
+            results_entry = ELNStepFactory.create_table_step(self._protocol, f"{self.name} Results",
+                                                             self.results_data_type)
             self.results_entry = results_entry
         else:
             self.results_entry = None
@@ -237,7 +299,8 @@ class ToolOfToolsHelper:
     # TODO: Remove this once pylib has a gauge chart function in ElnStepFactory.
     @staticmethod
     def _create_gauge_chart(protocol: ElnExperimentProtocol, data_source_step: ElnEntryStep, step_name: str,
-                            field_name: str, group_by_field_name: str = "DataRecordName") -> ElnEntryStep:
+                            field_name: str, status_field: str, group_by_field_name: str = "DataRecordName") \
+            -> ElnEntryStep:
         """
         Create a gauge chart step in the experiment protocol.
         """
@@ -246,7 +309,9 @@ class ToolOfToolsHelper:
         data_type_name: str = data_source_step.get_data_type_names()[0]
         series = GaugeChartSeries(data_type_name, field_name)
         series.operation_type = ChartOperationType.VALUE
-        chart = _FixedGaugeChartDefinition()
+        chart = _GaugeChartDefinition()
+        chart.main_data_type_name = data_type_name
+        chart.status_field = status_field
         chart.minimum_value = 0.
         chart.maximum_value = 100.
         chart.series_list = [series]
@@ -259,6 +324,17 @@ class ToolOfToolsHelper:
 
 
 # TODO: This is only here because the get_chart_type function in pylib is wrong. Remove this once pylib is fixed.
-class _FixedGaugeChartDefinition(GaugeChartDefinition):
+#  Also using this to set the new status field setting.
+class _GaugeChartDefinition(GaugeChartDefinition):
+    status_field: str
+
     def get_chart_type(self) -> ChartType:
         return ChartType.GAUGE_CHART
+
+    def to_json(self) -> dict[str, Any]:
+        result = super().to_json()
+        result["statusValueField"] = {
+            "dataTypeName": self.main_data_type_name,
+            "dataFieldName": self.status_field
+        }
+        return result