sapiopycommons 2025.2.14a436__tar.gz → 2025.2.17a438__tar.gz

{sapiopycommons-2025.2.14a436 → sapiopycommons-2025.2.17a438}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.2.14a436
+Version: 2025.2.17a438
 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.14a436 → sapiopycommons-2025.2.17a438}/pyproject.toml

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

{sapiopycommons-2025.2.14a436 → sapiopycommons-2025.2.17a438}/src/sapiopycommons/ai/tool_of_tools.py

@@ -6,12 +6,16 @@ from typing import Final, Mapping, Any
 
 from pandas import DataFrame
 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.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.eln.ElnEntryPosition import ElnEntryPosition
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
@@ -55,6 +59,9 @@ def create_tot_headers(url: str, username: str, password: str, experiment_id: in
     # Encode the credentials to bytes, then encode them using base64,
     # and finally convert the result back into a string.
     encoded_credentials: str = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
+    # Remove the trailing slash from the URL if it exists.
+    if url.endswith("/"):
+        url.rstrip("/")
     headers: dict[str, str] = {
         CREDENTIALS_HEADER: f"Basic {encoded_credentials}",
         API_URL_HEADER: url,
@@ -74,7 +81,10 @@ def create_user_from_tot_headers(headers: Mapping[str, str]) -> SapioUser:
     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])
+    url: str = headers[API_URL_HEADER.lower()]
+    if url.endswith("/"):
+        url.rstrip("/")
+    return SapioUser(url, username=credentials[0], password=credentials[1])
 
 
 def format_tot_headers(headers: Mapping[str, str]) -> dict[str, str]:
@@ -181,6 +191,7 @@ class AiHelper:
     # Managers.
     dr_man: DataRecordManager
     eln_man: ElnManager
+    dt_man: DataTypeManager
 
     def __init__(self, user: SapioUser, exp_id: int):
         """
@@ -192,6 +203,7 @@ class AiHelper:
 
         self.dr_man = DataRecordManager(self.user)
         self.eln_man = ElnManager(self.user)
+        self.dt_man = DataTypeManager(self.user)
 
     @property
     def protocol(self) -> ElnExperimentProtocol:
@@ -226,24 +238,42 @@ class AiHelper:
     def create_experiment_details_from_data_frame(self,
                                                   tab: ElnExperimentTab,
                                                   entry_name: str,
-                                                  df: DataFrame) -> ExperimentEntry | None:
+                                                  df: DataFrame,
+                                                  sort_field: str | None = None,
+                                                  sort_direction: SortDirection = SortDirection.DESCENDING,
+                                                  smiles_column: str | None = None) -> 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.
+        :param sort_field: The field to sort the resulting entry rows by, if any.
+        :param sort_direction: The direction to sort the resulting entry rows in, if a sort_field is provided.
+        :param smiles_column: The column name in the provided DataFrame that corresponds to the SMILES strings of the
+            compounds tracked in the DataFrame, if any. If this is provided, then the entry will be created with
+            images of the compounds corresponding to the SMILES strings in each row of the table.
         :return: The newly created experiment detail entry.
         """
         json_list: list[dict[str, Any]] = []
+        smiles: list[str] = []
         for _, row in df.iterrows():
-            json_list.append(row.to_dict())
-        return self.create_experiment_details_from_json(tab, entry_name, json_list)
+            row_dict: dict[str, Any] = row.to_dict()
+            if smiles_column is not None:
+                smiles.append(row_dict.get(smiles_column))
+            json_list.append(row_dict)
+        images: list[bytes] | None = None
+        if smiles:
+            images = self.smiles_to_svg(smiles)
+        return self.create_experiment_details_from_json(tab, entry_name, json_list, sort_field, sort_direction, images)
 
     def create_experiment_details_from_json(self,
                                             tab: ElnExperimentTab,
                                             entry_name: str,
-                                            json_list: list[dict[str, Any]]) -> ExperimentEntry | None:
+                                            json_list: list[dict[str, Any]],
+                                            sort_field: str | None = None,
+                                            sort_direction: SortDirection = SortDirection.DESCENDING,
+                                            images: list[bytes] | None = None) -> ExperimentEntry | None:
         """
         Create an experiment detail entry from a list of JSON dictionaries.
 
@@ -251,6 +281,11 @@ class AiHelper:
         :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.
+        :param sort_field: The field to sort the resulting entry rows by, if any.
+        :param sort_direction: The direction to sort the resulting entry rows in, if a sort_field is provided.
+        :param images: The images to include in the entry, if any. The images will be added to the rows that they
+            correspond to based on the order of the images in the images list and the order of the rows in the
+            json list.
         :return: The newly created experiment detail entry.
         """
         if not json_list:
@@ -271,12 +306,26 @@ class AiHelper:
                 fields.append(field)
                 fields_by_name[key] = field
 
+        # Sort the JSON list if requested.
+        if sort_field and sort_direction != SortDirection.NONE:
+            if images:
+                old_order: list[str] = [x[sort_field] for x in json_list]
+            json_list.sort(key=lambda x: x.get(sort_field), reverse=sort_direction == SortDirection.DESCENDING)
+            # We'll need to resort the images as well.
+            if images:
+                new_order: list[str] = [x[sort_field] for x in json_list]
+                new_images: list[bytes] = []
+                for val in new_order:
+                    # noinspection PyUnboundLocalVariable
+                    new_images.append(images[old_order.index(val)])
+                images = new_images
+
         # 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.
+                # Watch out for NaN values or other special values in numeric columns.
                 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))):
@@ -284,13 +333,28 @@ class AiHelper:
                 field_map[field.data_field_name] = val
             field_maps.append(field_map)
 
+        # Create the experiment detail entry.
         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)
+        records: list[DataRecord] = self.dr_man.add_data_records_with_data(entry.data_type_name, field_maps)
+
+        # If images are provided, update the data type definition of the experiment detail data type to allow
+        # record images and add the images to the records.
+        if images:
+            dt: DataTypeDefinition = self.dt_man.get_data_type_definition(entry.data_type_name)
+            dt.is_record_image_assignable = True
+            self.eln_man.update_eln_data_type_definition(self.exp_id, entry.entry_id, dt)
+
+            layout: DataTypeLayout = self.dt_man.get_default_layout(entry.data_type_name)
+            layout.table_layout = TableLayout(cell_size=128, record_image_width=128)
+            self.eln_man.update_eln_data_type_layout(self.exp_id, entry.entry_id, layout)
+
+            self.update_record_images(records, images)
+
         return entry
 
     def create_text_entry(self, tab: ElnExperimentTab, timestamp: str, description: str, auto_format: bool = True) \
@@ -538,7 +602,7 @@ 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"ELaiN: {self.name} 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)