sapiopycommons 2024.6.6a249__py3-none-any.whl → 2024.6.18a254__py3-none-any.whl

sapiopycommons/general/custom_report_util.py

@@ -3,7 +3,7 @@ from typing import Any
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReport
+from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReport, CustomReportCriteria, RawReportTerm
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
 
@@ -13,7 +13,9 @@ class CustomReportUtil:
     def run_system_report(context: SapioWebhookContext | SapioUser,
                           report_name: str,
                           filters: dict[str, Iterable[Any]] | None = None,
-                          page_limit: int | None = None) -> list[dict[str, Any]]:
+                          page_limit: int | None = None,
+                          page_size: int | None = None,
+                          page_number: int | None = None) -> list[dict[str, Any]]:
         """
         Run a system report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -27,26 +29,94 @@ class CustomReportUtil:
             filter on. Only those headers that both the filters and the custom report share will take effect. That is,
             any filters that have a header name that isn't in the custom report will be ignored.
         :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_size: The size of each page of results in the search. If None, the page size is set by the server.
+        :param page_number: The page number to start the search from, If None, starts on the first page.
         :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
             values in the dicts are the data field names of the columns.
+            If two columns in the search have the same data field name but differing data type names, then the
+            dictionary key to the value in the column will be "DataTypeName.DataFieldName". For example, if you
+            had a Sample column with a data field name of Identifier and a Request column with the same data field name,
+            then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
         """
-        results = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit)
+        results: tuple = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit,
+                                                                  page_size, page_number)
         columns: list[ReportColumn] = results[0]
         rows: list[list[Any]] = results[1]
+        return CustomReportUtil.__process_results(rows, columns, filters)
 
-        ret: list[dict[str, Any]] = []
-        for row in rows:
-            row_data: dict[str, Any] = {}
-            filter_row: bool = False
-            for value, column in zip(row, columns):
-                header: str = column.data_field_name
-                if filters is not None and header in filters and value not in filters.get(header):
-                    filter_row = True
-                    break
-                row_data.update({header: value})
-            if filter_row is False:
-                ret.append(row_data)
-        return ret
+    @staticmethod
+    def run_custom_report(context: SapioWebhookContext | SapioUser,
+                          report_criteria: CustomReportCriteria,
+                          filters: dict[str, Iterable[Any]] | None = None,
+                          page_limit: int | None = None,
+                          page_size: int | None = None,
+                          page_number: int | None = None) -> list[dict[str, Any]]:
+        """
+        Run a custom report and return the results of that report as a list of dictionaries for the values of each
+        column in each row.
+
+        Custom reports are constructed by the caller, specifying the report terms and the columns that will be in the
+        results. They are like advanced or predefined searches from the system, except they are constructed from
+        within the webhook instead of from within the system.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param report_criteria: The custom report criteria to run.
+        :param filters: If provided, filter the results of the report using the given mapping of headers to values to
+            filter on. Only those headers that both the filters and the custom report share will take effect. That is,
+            any filters that have a header name that isn't in the custom report will be ignored.
+            Note that this parameter is only provided for parity with the other run report functions. If you need to
+            filter the results of a search, it would likely be more beneficial to have just added a new term to the
+            input report criteria that corresponds to the filter.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_size: The size of each page of results in the search. If None, uses the value from the given report
+            criteria. If not None, overwrites the value from the given report criteria.
+        :param page_number: The page number to start the search from, If None, uses the value from the given report
+            criteria. If not None, overwrites the value from the given report criteria.
+        :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
+            values in the dicts are the data field names of the columns.
+            If two columns in the search have the same data field name but differing data type names, then the
+            dictionary key to the value in the column will be "DataTypeName.DataFieldName". For example, if you
+            had a Sample column with a data field name of Identifier and a Request column with the same data field name,
+            then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
+        """
+        results: tuple = CustomReportUtil.__exhaust_custom_report(context, report_criteria, page_limit,
+                                                                  page_size, page_number)
+        columns: list[ReportColumn] = results[0]
+        rows: list[list[Any]] = results[1]
+        return CustomReportUtil.__process_results(rows, columns, filters)
+
+    @staticmethod
+    def run_quick_report(context: SapioWebhookContext | SapioUser,
+                         report_term: RawReportTerm,
+                         filters: dict[str, Iterable[Any]] | None = None,
+                         page_limit: int | None = None,
+                         page_size: int | None = None,
+                         page_number: int | None = None) -> list[dict[str, Any]]:
+        """
+        Run a quick report and return the results of that report as a list of dictionaries for the values of each
+        column in each row.
+
+        Quick reports are helpful for cases where you need to query record field values in a more complex manner than
+        the data record manager allows, but still simpler than a full-blown custom report. The columns that are returned
+        in a quick search are every visible field from the data type that corresponds to the given report term. (Fields
+        which are not marked as visible in the data designer will be excluded.)
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param report_term: The raw report term to use for the quick report.
+        :param filters: If provided, filter the results of the report using the given mapping of headers to values to
+            filter on. Only those headers that both the filters and the custom report share will take effect. That is,
+            any filters that have a header name that isn't in the custom report will be ignored.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_size: The size of each page of results in the search. If None, the page size is set by the server.
+        :param page_number: The page number to start the search from, If None, starts on the first page.
+        :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
+            values in the dicts are the data field names of the columns.
+        """
+        results: tuple = CustomReportUtil.__exhaust_quick_report(context, report_term, page_limit,
+                                                                 page_size, page_number)
+        columns: list[ReportColumn] = results[0]
+        rows: list[list[Any]] = results[1]
+        return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
     def get_system_report_criteria(context: SapioWebhookContext | SapioUser, report_name: str) -> CustomReport:
@@ -69,22 +139,124 @@ class CustomReportUtil:
         return report_man.run_system_report_by_name(report_name, 1, 1)
 
     @staticmethod
-    def __exhaust_system_report(context: SapioWebhookContext | SapioUser, report_name: str, page_limit: int | None = None) \
+    def __exhaust_system_report(context: SapioWebhookContext | SapioUser,
+                                report_name: str,
+                                page_limit: int | None,
+                                page_size: int | None,
+                                page_number: int | None) \
+            -> tuple[list[ReportColumn], list[list[Any]]]:
+        """
+        Given a system report, iterate over every page of the report and collect the results
+        until there are no remaining pages.
+        """
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        report_man = DataMgmtServer.get_custom_report_manager(user)
+
+        result = None
+        has_next_page: bool = True
+        rows: list[list[Any]] = []
+        cur_page: int = 1
+        while has_next_page and (not page_limit or cur_page < page_limit):
+            result = report_man.run_system_report_by_name(report_name, page_size, page_number)
+            page_size = result.page_size
+            page_number = result.page_number
+            has_next_page = result.has_next_page
+            rows.extend(result.result_table)
+            cur_page += 1
+        return result.column_list, rows
+
+    @staticmethod
+    def __exhaust_custom_report(context: SapioWebhookContext | SapioUser,
+                                report: CustomReportCriteria,
+                                page_limit: int | None,
+                                page_size: int | None,
+                                page_number: int | None) \
+            -> tuple[list[ReportColumn], list[list[Any]]]:
+        """
+        Given a custom report, iterate over every page of the report and collect the results
+        until there are no remaining pages.
+        """
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        report_man = DataMgmtServer.get_custom_report_manager(user)
+
+        result = None
+        if page_size is not None:
+            report.page_size = page_size
+        if page_number is not None:
+            report.page_number = page_number
+        has_next_page: bool = True
+        rows: list[list[Any]] = []
+        cur_page: int = 1
+        while has_next_page and (not page_limit or cur_page < page_limit):
+            result = report_man.run_custom_report(report)
+            report.page_size = result.page_size
+            report.page_number = result.page_number
+            has_next_page = result.has_next_page
+            rows.extend(result.result_table)
+            cur_page += 1
+        return result.column_list, rows
+
+    @staticmethod
+    def __exhaust_quick_report(context: SapioWebhookContext | SapioUser,
+                               report_term: RawReportTerm,
+                               page_limit: int | None,
+                               page_size: int | None,
+                               page_number: int | None) \
             -> tuple[list[ReportColumn], list[list[Any]]]:
+        """
+        Given a quick report, iterate over every page of the report and collect the results
+        until there are no remaining pages.
+        """
         user: SapioUser = context if isinstance(context, SapioUser) else context.user
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
-        report = None
-        page_size: int | None = None
-        page_number: int | None = None
+        result = None
         has_next_page: bool = True
         rows: list[list[Any]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page < page_limit):
-            report = report_man.run_system_report_by_name(report_name, page_size, page_number)
-            page_size = report.page_size
-            page_number = report.page_number
-            has_next_page = report.has_next_page
-            rows.extend(report.result_table)
+            result = report_man.run_quick_report(report_term, page_size, page_number)
+            page_size = result.page_size
+            page_number = result.page_number
+            has_next_page = result.has_next_page
+            rows.extend(result.result_table)
             cur_page += 1
-        return report.column_list, rows
+        return result.column_list, rows
+
+    @staticmethod
+    def __process_results(rows: list[list[Any]], columns: list[ReportColumn],
+                          filters: dict[str, Iterable[Any]] | None) -> list[dict[str, Any]]:
+        """
+        Given the results of a report as a list of row values and the report's columns, combine these lists to
+        result in a singular list of dictionaries for each row in the results.
+
+        If any filter criteria has been provided, also use that to filter the row.
+        """
+        # It may be the case that two columns have the same data field name but differing data type names.
+        # If this occurs, then we need to be able to differentiate these columns in the resulting dictionary.
+        prepend_dt: set[str] = set()
+        encountered_names: list[str] = []
+        for column in columns:
+            field_name: str = column.data_field_name
+            if field_name in encountered_names:
+                prepend_dt.add(field_name)
+            else:
+                encountered_names.append(field_name)
+
+        ret: list[dict[str, Any]] = []
+        for row in rows:
+            row_data: dict[str, Any] = {}
+            filter_row: bool = False
+            for value, column in zip(row, columns):
+                header: str = column.data_field_name
+                # If two columns share the same data field name, prepend the data type name of the column to the
+                # data field name.
+                if header in prepend_dt:
+                    header = column.data_type_name + "." + header
+                if filters is not None and header in filters and value not in filters.get(header):
+                    filter_row = True
+                    break
+                row_data.update({header: value})
+            if filter_row is False:
+                ret.append(row_data)
+        return ret

sapiopycommons/multimodal/multimodal.py

@@ -46,19 +46,6 @@ class MultiModalManager:
         self._user.raise_for_status(response)
         return response.json()
 
-    def register_interactively(self, request: ChemInteractiveRegisterRequestPojo):
-        """
-        Prompt user interactively to load the provided file data.
-        User will be able to select or define a field map for the assay data included.
-        User will also be able to define which one is the SMILES column if csv.
-        """
-        # TODO pending client_callback enablement on the webhook => webservice endpoint route.
-        payload = dumps(request, ChemInteractiveRegisterRequestPojo)
-        response = self._user.plugin_post("chemistry/register_interactively",
-                                          payload=payload, is_payload_plain_text=True)
-        self._user.raise_for_status(response)
-        return loads(response.text, ChemCompleteImportPojo)
-
     def load_compounds(self, request: CompoundLoadRequestPojo):
         """
         Load compounds from the provided data here.

sapiopycommons/multimodal/multimodal_data.py

@@ -56,18 +56,6 @@ class PyCompound:
     props: dict[str, object] | None
 
 
-class ChemDataType(Enum):
-    CompoundPart = 'CompoundPart'
-    ChemicalReagentPart = 'ChemicalReagentPart'
-
-    def __init__(self, data_type_name: str):
-        self._data_type_name = data_type_name
-
-    @property
-    def data_type_name(self):
-        return self._data_type_name
-
-
 class ChemFileType(Enum):
     CSV = 0
     SDF = 1
@@ -133,12 +121,12 @@ class ChemCompleteImportPojo:
 
 @dataclass
 class ChemInteractiveRegisterRequestPojo:
-    dataType: ChemDataType
+    dataType: str
     fileType: ChemFileType
     fileDataEncodedBase64: str | None
     addingItems: bool
 
-    def __init__(self, data_type: ChemDataType, file_type: ChemFileType, is_adding_items: bool, file_data: bytes):
+    def __init__(self, data_type: str, file_type: ChemFileType, is_adding_items: bool, file_data: bytes):
         self.dataType = data_type
         self.fileType = file_type
         self.addingItems = is_adding_items
@@ -156,12 +144,12 @@ class CompoundLoadRequestPojo:
         dataList: If the source data is not a file, here you specify a list of string describing molecule for that src.
         fileDataBase64: If the source data is a file, the file's base64 data content.
     """
-    dataType: ChemDataType
+    dataType: str
     loadType: ChemLoadType
     dataList: list[str] | None
     fileDataBase64: str | None
 
-    def __init__(self, data_type: ChemDataType, load_type: ChemLoadType, data_list: list[str] | None = None,
+    def __init__(self, data_type: str, load_type: ChemLoadType, data_list: list[str] | None = None,
                  file_data: bytes | None = None):
         self.dataType = data_type
         self.loadType = load_type
@@ -184,10 +172,10 @@ class ChemRegisterRequestPojo:
         dataType: The data type of records to be registered in Sapio.
         registrationList: This list must be of correct data structure suitable for the type. For example, for CompoundPart data type the canonical form must be resolved by earlier call.
     """
-    dataType: ChemDataType
+    dataType: str
     registrationList: list[PyCompound]
 
-    def __init__(self, data_type: ChemDataType, registration_list: list[PyCompound]):
+    def __init__(self, data_type: str, registration_list: list[PyCompound]):
         self.dataType = data_type
         self.registrationList = registration_list
 
@@ -228,16 +216,6 @@ class PyIndigoReactionPojo:
     reactionRenderRxn: str
 
 
-class CartridgeMolJoinMethod(Enum):
-    """
-    The structure search join method to filter results against Sapio registry.
-    Since we have multiple registries in Sapio, you will need to specify which one to join against.
-    """
-    COMPOUND_REGISTRY = 0
-    REAGENT_REGISTRY = 1
-    HELM_STRUCTURE = 2
-
-
 @dataclass
 class ChemQuickSearchContextData:
     """
@@ -250,7 +228,7 @@ class ChemQuickSearchContextData:
     nextPageSearchAfter: str | None
     pitId: str | None
     query: str | None
-    joinMethod: CartridgeMolJoinMethod | None
+    joinSapioPartType: str | None
     simUpperLimit: float | None
 
 
@@ -269,11 +247,11 @@ class ChemSearchRequestPojo:
     """
     searchStr: str
     searchType: ChemSearchType
-    joinMethod: CartridgeMolJoinMethod | None
+    joinSapioType: str | None
     contextData: ChemQuickSearchContextData | None
     simSearchUpperLimit: float | None
 
-    def __init__(self, search_str: str, search_type: ChemSearchType, join_method: CartridgeMolJoinMethod | None = None,
+    def __init__(self, search_str: str, search_type: ChemSearchType, join_method: str | None = None,
                  context_data: ChemQuickSearchContextData | None = None, sim_search_upper: float | None = None):
         self.searchStr = search_str
         self.searchType = search_type