sapiopycommons 2024.8.27a312__py3-none-any.whl → 2024.8.28a313__py3-none-any.whl

sapiopycommons/recordmodel/record_handler.py

@@ -3,10 +3,8 @@ from typing import Any
 
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, RawReportTerm, ReportColumn
 from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.DataRecordPaging import DataRecordPojoPageCriteria
-from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.autopaging import QueryDataRecordsAutoPager, QueryDataRecordByIdListAutoPager, \
     QueryAllRecordsOfTypeAutoPager
@@ -77,43 +75,6 @@ class RecordHandler:
         """
         return self.query_models_with_criteria(wrapper_type, field, value_list, None, page_limit)[0]
 
-    def query_and_map_models(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
-                             page_limit: int | None = None, *, mapping_field: str | None = None) \
-            -> dict[Any, list[WrappedType]]:
-        """
-        Shorthand for using query_models to search for records given values on a specific field and then using
-        map_by_field to turn the returned list into a dictionary mapping field values to records.
-
-        :param wrapper_type: The record model wrapper to use.
-        :param field: The field to query and map on.
-        :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
-        :param mapping_field: If provided, use this field to map against instead of the field that was queried on.
-        :return: The record models for the queried records mapped by field values to the records with that value.
-        """
-        if mapping_field is None:
-            mapping_field = field
-        return self.map_by_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
-
-    def query_and_unique_map_models(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
-                                    page_limit: int | None = None, *, mapping_field: str | None = None) \
-            -> dict[Any, WrappedType]:
-        """
-        Shorthand for using query_models to search for records given values on a specific field and then using
-        map_by_unique_field to turn the returned list into a dictionary mapping field values to records.
-        If any two records share the same field value, throws an exception.
-
-        :param wrapper_type: The record model wrapper to use.
-        :param field: The field to query and map on.
-        :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
-        :param mapping_field: If provided, use this field to map against instead of the field that was queried on.
-        :return: The record models for the queried records mapped by field values to the record with that value.
-        """
-        if mapping_field is None:
-            mapping_field = field
-        return self.map_by_unique_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
-
     def query_models_with_criteria(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
                                    paging_criteria: DataRecordPojoPageCriteria | None = None,
                                    page_limit: int | None = None) \
@@ -199,58 +160,24 @@ class RecordHandler:
         return self.wrap_models(pager.get_all_at_once(), wrapper_type), pager.next_page_criteria
 
     def query_models_by_report(self, wrapper_type: type[WrappedType],
-                               report_name: str | RawReportTerm | CustomReportCriteria,
+                               report_name: str,
                                filters: dict[str, Iterable[Any]] | None = None,
-                               page_limit: int | None = None,
-                               page_size: int | None = None,
-                               page_number: int | None = None) -> list[WrappedType]:
+                               page_limit: int | None = None) -> list[WrappedType]:
         """
-        Run a report and use the results of that report to query for and return the records in the report results.
-        First runs the report, then runs a data record manager query on the results of the custom report.
-
-        Will throw an exception if given the name of a system report that does not have a RecordId column.
-        Quick and custom reports are guaranteed to have a record ID column.
+        Run a system report that contains a RecordId column and query for the records with those IDs.
+        First runs the custom report, then runs a data record manager query on the results of the custom report.
 
-        Any given custom report criteria should only have columns from a single data type.
+        Will throw an exception if the given system report does not have a RecordId column.
 
         :param wrapper_type: The record model wrapper to use.
-        :param report_name: The name of a system report, or a raw report term for a quick report, or custom report
-            criteria for a custom report.
+        :param report_name: The name of the system report to run.
         :param filters: If provided, filter the results of the report using the given mapping of headers to values to
             filter on. This filtering is done before the records are queried.
         :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.
-            If the input report is a custom report criteria, uses the value from the criteria, unless this value is
-            not None, in which case it overwrites the given report's value.
-        :param page_number: The page number to start the search from, If None, starts on the first page.
-            If the input report is a custom report criteria, uses the value from the criteria, unless this value is
-            not None, in which case it overwrites the given report's value.
-        :return: The record models for the queried records that matched the given report.
-        """
-        if isinstance(report_name, str):
-            results: list[dict[str, Any]] = CustomReportUtil.run_system_report(self.user, report_name, filters,
-                                                                               page_limit, page_size, page_number)
-        elif isinstance(report_name, RawReportTerm):
-            results: list[dict[str, Any]] = CustomReportUtil.run_quick_report(self.user, report_name, filters,
-                                                                              page_limit, page_size, page_number)
-        elif isinstance(report_name, CustomReportCriteria):
-            dt: str = wrapper_type.get_wrapper_data_type_name()
-            # Ensure that the root data type is the one we're looking for.
-            report_name.root_data_type = dt
-            # Raise an exception if any column in the report doesn't match the given data type.
-            if any([x.data_type_name != dt for x in report_name.column_list]):
-                raise SapioException("You may only query records from a report containing columns from that data type.")
-            # Enforce that the given custom report has a record ID column.
-            if not any([x.data_type_name == dt and x.data_field_name == "RecordId" for x in report_name.column_list]):
-                report_name.column_list.append(ReportColumn(dt, "RecordId", FieldType.LONG))
-            results: list[dict[str, Any]] = CustomReportUtil.run_custom_report(self.user, report_name, filters,
-                                                                               page_limit, page_size, page_number)
-        else:
-            raise SapioException("Unrecognized report object.")
-
-        # Using the bracket accessor because we want to throw an exception if RecordId doesn't exist in the report.
-        # This should only possibly be the case with system reports, as quick reports will include the record ID and
-        # we forced any given custom report to have a record ID column.
+        :return: The record models for the queried records.
+        """
+        results: list[dict[str, Any]] = CustomReportUtil.run_system_report(self.user, report_name, filters, page_limit)
+        # Using the bracket operators because we want to throw an exception if RecordId doesn't exist in the report.
         ids: list[int] = [row["RecordId"] for row in results]
         return self.query_models_by_id(wrapper_type, ids)
 
@@ -284,46 +211,10 @@ class RecordHandler:
             the fields in the fields list.
         """
         models: list[WrappedType] = self.add_models(wrapper_type, len(fields))
-        for model, field_list in zip(models, fields):
-            model.set_field_values(field_list)
+        for model, field in zip(models, fields):
+            model.set_field_values(field)
         return models
 
-    def find_or_add_model(self, wrapper_type: type[WrappedType], primary_identifier: str, id_value: Any,
-                          secondary_identifiers: FieldMap | None = None) -> WrappedType:
-        """
-        Find a unique record that matches the given field values. If no such records exist, add a record model to the
-        cache with the identifying fields set to the desired values. This record will be created in the system when
-        you store and commit changes. If more than one record with the identifying values exists, throws an exception.
-
-        The record is searched for using the primary identifier field name and value. If multiple records are returned
-        by the query on this primary identifier, then the secondary identifiers are used to filter the results.
-
-        Makes a webservice call to query for the existing record.
-
-        :param wrapper_type: The record model wrapper to use.
-        :param primary_identifier: The data field name of the field to search on.
-        :param id_value: The value of the identifying field to search for.
-        :param secondary_identifiers: Optional fields used to filter the records that are returned after searching on
-            the primary identifier.
-        :return: The record model with the identifying field value, either pulled from the system or newly created.
-        """
-        # PR-46335: Initialize the secondary identifiers parameter if None is provided to avoid an exception.
-        # If no secondary identifiers were provided, use an empty dictionary.
-        if secondary_identifiers is None:
-            secondary_identifiers = {}
-
-        unique_record: WrappedType | None = self.__find_model(wrapper_type, primary_identifier, id_value,
-                                                              secondary_identifiers)
-        # If a unique record matched the identifiers, return it.
-        if unique_record is not None:
-            return unique_record
-
-        # If none of the results matched the identifiers, create a new record with all identifiers set.
-        # Put the primary identifier and value into the secondary identifiers list and use that as the fields map
-        # for this new record.
-        secondary_identifiers.update({primary_identifier: id_value})
-        return self.add_models_with_data(wrapper_type, [secondary_identifiers])[0]
-
     def create_models(self, wrapper_type: type[WrappedType], num: int) -> list[WrappedType]:
         """
         Shorthand for creating new records via the data record manager and then returning them as wrapped
@@ -379,8 +270,24 @@ class RecordHandler:
         if secondary_identifiers is None:
             secondary_identifiers = {}
 
-        unique_record: WrappedType | None = self.__find_model(wrapper_type, primary_identifier, id_value,
-                                                              secondary_identifiers)
+        # Query for all records that match the primary identifier.
+        results: list[WrappedType] = self.query_models(wrapper_type, primary_identifier, [id_value])
+
+        # Find the one record, if any, that matches the secondary identifiers.
+        unique_record: WrappedType | None = None
+        for result in results:
+            matches_all: bool = True
+            for field, value in secondary_identifiers.items():
+                if result.get_field_value(field) != value:
+                    matches_all = False
+                    break
+            if matches_all:
+                # If a previous record in the results already matched all identifiers, then throw an exception.
+                if unique_record is not None:
+                    raise SapioException(f"More than one record of type {wrapper_type.get_wrapper_data_type_name()} "
+                                         f"encountered in system that matches all provided identifiers.")
+                unique_record = result
+
         # If a unique record matched the identifiers, return it.
         if unique_record is not None:
             return unique_record
@@ -422,29 +329,6 @@ class RecordHandler:
             return_dict[model] = model.get_parents_of_type(parent_type)
         return return_dict
 
-    @staticmethod
-    def map_by_parent(models: Iterable[RecordModel], parent_type: type[WrappedType]) \
-            -> dict[WrappedType, RecordModel]:
-        """
-        Take a list of record models and map them by their parent. Essentially an inversion of map_to_parent.
-        If two records share the same parent, an exception will be thrown. The parents must already be loaded.
-
-        :param models: A list of record models.
-        :param parent_type: The record model wrapper of the parents.
-        :return: A dict[ParentType, ModelType]. If an input model doesn't have a parent of the given parent type,
-            then it will not be in the resulting dictionary.
-        """
-        to_parent: dict[RecordModel, WrappedType] = RecordHandler.map_to_parent(models, parent_type)
-        by_parent: dict[WrappedType, RecordModel] = {}
-        for record, parent in to_parent.items():
-            if parent is None:
-                continue
-            if parent in by_parent:
-                raise SapioException(f"Parent {parent.data_type_name} {parent.record_id} encountered more than once "
-                                     f"in models list.")
-            by_parent[parent] = record
-        return by_parent
-
     @staticmethod
     def map_by_parents(models: Iterable[RecordModel], parent_type: type[WrappedType]) \
             -> dict[WrappedType, list[RecordModel]]:
@@ -495,29 +379,6 @@ class RecordHandler:
             return_dict[model] = model.get_children_of_type(child_type)
         return return_dict
 
-    @staticmethod
-    def map_by_child(models: Iterable[RecordModel], child_type: type[WrappedType]) \
-            -> dict[WrappedType, list[RecordModel]]:
-        """
-        Take a list of record models and map them by their children. Essentially an inversion of map_to_child.
-        If two records share the same child, an exception will be thrown. The children must already be loaded.
-
-        :param models: A list of record models.
-        :param child_type: The record model wrapper of the children.
-        :return: A dict[ChildType, ModelType]. If an input model doesn't have a child of the given child type,
-            then it will not be in the resulting dictionary.
-        """
-        to_child: dict[RecordModel, WrappedType] = RecordHandler.map_to_child(models, child_type)
-        by_child: dict[WrappedType, RecordModel] = {}
-        for record, child in to_child.items():
-            if child is None:
-                continue
-            if child in by_child:
-                raise SapioException(f"Child {child.data_type_name} {child.record_id} encountered more than once "
-                                     f"in models list.")
-            by_child[child] = record
-        return by_child
-
     @staticmethod
     def map_by_children(models: Iterable[RecordModel], child_type: type[WrappedType]) \
             -> dict[WrappedType, list[RecordModel]]:
@@ -555,8 +416,8 @@ class RecordHandler:
         return return_dict
 
     @staticmethod
-    def map_by_forward_side_links(models: Iterable[WrappedRecordModel], field_name: str,
-                                  side_link_type: type[WrappedType]) -> dict[WrappedType, list[WrappedRecordModel]]:
+    def map_by_forward_side_link(models: Iterable[WrappedRecordModel], field_name: str,
+                                 side_link_type: type[WrappedType]) -> dict[WrappedType, list[WrappedRecordModel]]:
         """
         Take a list of record models and map them by their forward side link. Essentially an inversion of
         map_to_forward_side_link. Input models that share a forward side link will end up in the same list.
@@ -568,44 +429,18 @@ class RecordHandler:
         :return: A dict[SideLink, list[ModelType]]. If an input model doesn't have a forward side link of the given type
             pointing to it, then it will not be in the resulting dictionary.
         """
-        to_side_link: dict[WrappedRecordModel, WrappedType] = RecordHandler\
+        to_side_link: dict[RecordModel, WrappedType] = RecordHandler\
             .map_to_forward_side_link(models, field_name, side_link_type)
-        by_side_link: dict[WrappedType, list[WrappedRecordModel]] = {}
+        by_side_link: dict[WrappedType, list[RecordModel]] = {}
         for record, side_link in to_side_link.items():
             if side_link is None:
                 continue
             by_side_link.setdefault(side_link, []).append(record)
         return by_side_link
 
-    @staticmethod
-    def map_by_forward_side_link(models: Iterable[WrappedRecordModel], field_name: str,
-                                 side_link_type: type[WrappedType]) -> dict[WrappedType, WrappedRecordModel]:
-        """
-        Take a list of record models and map them by their forward side link. Essentially an inversion of
-        map_to_forward_side_link, but if two records share the same forward link, an exception is thrown.
-        The forward side link must already be loaded.
-
-        :param models: A list of record models.
-        :param field_name: The field name on the record models where the side link is located.
-        :param side_link_type: The record model wrapper of the forward side links.
-        :return: A dict[SideLink, ModelType]. If an input model doesn't have a forward side link of the given type
-            pointing to it, then it will not be in the resulting dictionary.
-        """
-        to_side_link: dict[WrappedRecordModel, WrappedType] = RecordHandler\
-            .map_to_forward_side_link(models, field_name, side_link_type)
-        by_side_link: dict[WrappedType, WrappedRecordModel] = {}
-        for record, side_link in to_side_link.items():
-            if side_link is None:
-                continue
-            if side_link in by_side_link:
-                raise SapioException(f"Side link {side_link.data_type_name} {side_link.record_id} encountered more "
-                                     f"than once in models list.")
-            by_side_link[side_link] = record
-        return by_side_link
-
     @staticmethod
     def map_to_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: str,
-                                  side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, list[WrappedType]]:
+                                  side_link_type: type[WrappedType]) -> dict[RecordModel, list[WrappedRecordModel]]:
         """
         Map a list of record models to a list reverse side links of a given type. The reverse side links must already
         be loaded.
@@ -622,29 +457,6 @@ class RecordHandler:
             return_dict[model] = model.get_reverse_side_link(field_name, side_link_type)
         return return_dict
 
-    @staticmethod
-    def map_to_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: str,
-                                 side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, WrappedType]:
-        """
-        Map a list of record models to the reverse side link of a given type. If a given record has more than one
-        reverse side link of this type, an exception is thrown. The reverse side links must already be loaded.
-
-        :param models: A list of record models.
-        :param field_name: The field name on the side linked model where the side link to the given record models is
-            located.
-        :param side_link_type: The record model wrapper of the reverse side links.
-        :return: A dict[ModelType, SideLink]. If an input model doesn't have reverse side links of the given type,
-            then it will map to None.
-        """
-        return_dict: dict[WrappedRecordModel, WrappedType] = {}
-        for model in models:
-            links: list[WrappedType] = model.get_reverse_side_link(field_name, side_link_type)
-            if len(links) > 1:
-                raise SapioException(f"Model {model.data_type_name} {model.record_id} has more than one reverse link "
-                                     f"of type {side_link_type.get_wrapper_data_type_name()}.")
-            return_dict[model] = links[0] if links else None
-        return return_dict
-
     @staticmethod
     def map_by_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: str,
                                   side_link_type: type[WrappedType]) -> dict[WrappedType, list[WrappedRecordModel]]:
@@ -660,41 +472,14 @@ class RecordHandler:
         :return: A dict[SideLink, list[ModelType]]. If an input model doesn't have reverse side links of the given type
             pointing to it, then it will not be in the resulting dictionary.
         """
-        to_side_links: dict[WrappedRecordModel, list[WrappedType]] = RecordHandler\
+        to_side_links: dict[RecordModel, list[WrappedType]] = RecordHandler\
             .map_to_reverse_side_links(models, field_name, side_link_type)
-        by_side_links: dict[WrappedType, list[WrappedRecordModel]] = {}
+        by_side_links: dict[WrappedType, list[RecordModel]] = {}
         for record, side_links in to_side_links.items():
             for side_link in side_links:
                 by_side_links.setdefault(side_link, []).append(record)
         return by_side_links
 
-    @staticmethod
-    def map_by_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: str,
-                                 side_link_type: type[WrappedType]) -> dict[WrappedType, WrappedRecordModel]:
-        """
-        Take a list of record models and map them by their reverse side link. Essentially an inversion of
-        map_to_reverse_side_link. If two records share the same reverse side link, an exception is thrown.
-        The reverse side links must already be loaded.
-
-        :param models: A list of record models.
-        :param field_name: The field name on the side linked model where the side link to the given record models is
-            located.
-        :param side_link_type: The record model wrapper of the reverse side links.
-        :return: A dict[SideLink, ModelType]. If an input model doesn't have a reverse side link of the given type
-            pointing to it, then it will not be in the resulting dictionary.
-        """
-        to_side_link: dict[WrappedRecordModel, WrappedType] = RecordHandler\
-            .map_to_reverse_side_link(models, field_name, side_link_type)
-        by_side_link: dict[WrappedType, WrappedRecordModel] = {}
-        for record, side_link in to_side_link.items():
-            if side_link is None:
-                continue
-            if side_link in by_side_link:
-                raise SapioException(f"Side link {side_link.data_type_name} {side_link.record_id} encountered more "
-                                     f"than once in models list.")
-            by_side_link[side_link] = record
-        return by_side_link
-
     @staticmethod
     def map_by_id(models: Iterable[SapioRecord]) -> dict[int, SapioRecord]:
         """
@@ -905,7 +690,7 @@ class RecordHandler:
         relationship path must already be loaded.
 
         The path is "flattened" by only following the first record at each step. Useful for traversing 1-to-Many-to-1
-        relationships (e.g. a sample which is aliquoted to a number of samples, then those aliquots are pooled back
+        relationships (e.g. a sample with is aliquoted to a number of samples, then those aliquots are pooled back
         together into a single sample).
 
         Currently, the relationship path may only contain parent/child nodes.
@@ -934,28 +719,10 @@ class RecordHandler:
             ret_dict.update({model: self.inst_man.wrap(current[0], wrapper_type) if current else None})
         return ret_dict
 
-    def __find_model(self, wrapper_type: type[WrappedType], primary_identifier: str, id_value: Any,
-                     secondary_identifiers: FieldMap | None = None) -> WrappedType | None:
-        """
-        Find a record from the system that matches the given field values. The primary identifier and value is used
-        to query for the record, then the secondary identifiers may be optionally provided to further filter the
-        returned results. If no record is found with these filters, returns None.
-        """
-        # Query for all records that match the primary identifier.
-        results: list[WrappedType] = self.query_models(wrapper_type, primary_identifier, [id_value])
-
-        # Find the one record, if any, that matches the secondary identifiers.
-        unique_record: WrappedType | None = None
-        for result in results:
-            matches_all: bool = True
-            for field, value in secondary_identifiers.items():
-                if result.get_field_value(field) != value:
-                    matches_all = False
-                    break
-            if matches_all:
-                # If a previous record in the results already matched all identifiers, then throw an exception.
-                if unique_record is not None:
-                    raise SapioException(f"More than one record of type {wrapper_type.get_wrapper_data_type_name()} "
-                                         f"encountered in system that matches all provided identifiers.")
-                unique_record = result
-        return unique_record
+    def __exhaust_query_pages(self, data_type_name: str, field: str, value_list: list[Any],
+                              paging_criteria: DataRecordPojoPageCriteria | None,
+                              page_limit: int | None) \
+            -> tuple[list[DataRecord], DataRecordPojoPageCriteria | None]:
+        pager = QueryDataRecordsAutoPager(data_type_name, field, value_list, self.user, paging_criteria)
+        pager.max_page = page_limit
+        return pager.get_all_at_once(), pager.next_page_criteria

sapiopycommons/webhook/webhook_handlers.py

@@ -47,7 +47,6 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
         # Wrap the execution of each webhook in a try/catch. If an exception occurs, handle any special sapiopycommons
         # exceptions. Otherwise, return a generic message stating that an error occurred.
         try:
-            self.initialize(context)
             return self.execute(context)
         except SapioUserErrorException as e:
             return self.handle_user_error_exception(e)
@@ -58,13 +57,6 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
         except Exception as e:
             return self.handle_unexpected_exception(e)
 
-    def initialize(self, context: SapioWebhookContext) -> None:
-        """
-        A function that can be optionally overridden by your webhooks to initialize additional instance variables,
-        or set up whatever else you wish to set up before the execute function is ran. Default behavior does nothing.
-        """
-        pass
-
     @abstractmethod
     def execute(self, context: SapioWebhookContext) -> SapioWebhookResult:
         """
@@ -99,8 +91,7 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
         if result is not None:
             return result
         self.log_error(traceback.format_exc())
-        if self.can_send_client_callback():
-            DataMgmtServer.get_client_callback(self.context.user).display_error(e.args[0])
+        DataMgmtServer.get_client_callback(self.context.user).display_error(e.args[0])
         return SapioWebhookResult(False)
 
     def handle_unexpected_exception(self, e: Exception) -> SapioWebhookResult:
@@ -246,51 +237,3 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
         :return: True if this endpoint was invoked as a scheduled action.
         """
         return self.context.end_point_type == WebhookEndpointType.SCHEDULEDPLUGIN
-
-    def is_action_button_field(self) -> bool:
-        """
-        :return: True if this endpoint was invoked as an action button field.
-        """
-        return self.context.end_point_type == WebhookEndpointType.ACTIONDATAFIELD
-
-    def is_action_text_field(self) -> bool:
-        """
-        :return: True if this endpoint was invoked as an action text field.
-        """
-        return self.context.end_point_type == WebhookEndpointType.ACTION_TEXT_FIELD
-
-    def is_custom(self) -> bool:
-        """
-        :return: True if this endpoint was invoked from a custom point, such as a custom queue.
-        """
-        return self.context.end_point_type == WebhookEndpointType.CUSTOM
-
-    def is_calendar_event_click_handler(self) -> bool:
-        """
-        :return: True if this endpoint was invoked from a calendar event click handler.
-        """
-        return self.context.end_point_type == WebhookEndpointType.CALENDAR_EVENT_CLICK_HANDLER
-
-    def is_eln_menu_grabber(self) -> bool:
-        """
-        :return: True if this endpoint was invoked as a notebook entry grabber.
-        """
-        return self.context.end_point_type == WebhookEndpointType.NOTEBOOKEXPERIMENTGRABBER
-
-    def is_conversation_bot(self) -> bool:
-        """
-        :return: True if this endpoint was invoked as from a conversation bot.
-        """
-        return self.context.end_point_type == WebhookEndpointType.CONVERSATION_BOT
-
-    def is_multi_data_type_table_toolbar(self) -> bool:
-        """
-        :return: True if this endpoint was invoked as a multi data type table toolbar button.
-        """
-        return self.context.end_point_type == WebhookEndpointType.REPORTTOOLBAR
-
-    def can_send_client_callback(self) -> bool:
-        """
-        :return: Whether client callbacks and directives can be sent from this webhook's endpoint type.
-        """
-        return self.context.is_client_callback_available

{sapiopycommons-2024.8.27a312.dist-info → sapiopycommons-2024.8.28a313.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.8.27a312
+Version: 2024.8.28a313
 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,8 +17,7 @@ Classifier: Programming Language :: Python :: 3.10
 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>=2024.5.24.210
+Requires-Dist: sapiopylib>=2023.12.13.174
 Description-Content-Type: text/markdown
 
 
@@ -51,7 +50,6 @@ This license does not provide any rights to use any other copyrighted artifacts
 ## Dependencies
 The following dependencies are required for this package:
 - [sapiopylib - The official Sapio Informatics Platform Python API package.](https://pypi.org/project/sapiopylib/)
-- [databind - Databind is a library inspired by jackson-databind to de-/serialize Python dataclasses.](https://pypi.org/project/databind/)
 
 ## Getting Help
 If you have a support contract with Sapio Sciences, please use our [technical support channels](https://sapio-sciences.atlassian.net/servicedesk/customer/portals).

{sapiopycommons-2024.8.27a312.dist-info → sapiopycommons-2024.8.28a313.dist-info}/RECORD

@@ -1,43 +1,38 @@
 sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/callbacks/callback_util.py,sha256=caeIWCHvK33jDs3TRskpJv0kDe7W8NPK4MyJPjgztwo,58012
-sapiopycommons/chem/IndigoMolecules.py,sha256=QqFDi9CKERj6sn_ZwVcS2xZq4imlkaTeCrpq1iNcEJA,1992
-sapiopycommons/chem/Molecules.py,sha256=t80IsQBPJ9mwE8ZxnWomAGrZDhdsOuPvLaTPb_N6jGU,8639
+sapiopycommons/callbacks/callback_util.py,sha256=D6whWxYWvs5rXOG2Slpi1icC18SLKmG9-MP9f0YDDNE,43256
+sapiopycommons/chem/IndigoMolecules.py,sha256=ukZcX6TMEgkNdD1L1GnH3tp5rGplFNPlGoChAHXbsxw,1945
+sapiopycommons/chem/Molecules.py,sha256=tOkn3fg4QizgqjkRLuvRdVy0JpTD3QEOSvZPxmIyT4c,8607
 sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/datatype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/datatype/attachment_util.py,sha256=YlnMprj5IGBbAZDLG2khS1P7JIYTw_NYfpJAfRZfP3M,3219
 sapiopycommons/eln/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/eln/experiment_handler.py,sha256=v1pG4qtZb8OSNWfKtFo6NjnEkReqnu5R9i_hqWh_xxg,57198
-sapiopycommons/eln/experiment_report_util.py,sha256=FTLw-6SLAMeoWTOO-qhGROE9g54pZdyoQJIhiIzlwGw,7848
 sapiopycommons/eln/plate_designer.py,sha256=FYJfhhNq8hdfuXgDYOYHy6g0m2zNwQXZWF_MTPzElDg,7184
 sapiopycommons/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/files/complex_data_loader.py,sha256=XSJOl676mIklJo78v07-70u1b015a5DI4sqZPI3C-Tw,1475
-sapiopycommons/files/file_bridge.py,sha256=GI3-gWFzcL0q0c8jKOxTevbzJqtUpiElmkXfTnMsaOo,6224
-sapiopycommons/files/file_bridge_handler.py,sha256=MU2wZR4VY606yx6Bnv8-LzG3mGCeuXeRBn914WNRFCo,13601
+sapiopycommons/files/file_bridge.py,sha256=6yjUi0ejypb1nvcEvn21EuquB-SmEjB-fCZiMaNZg7Q,5757
 sapiopycommons/files/file_data_handler.py,sha256=3-guAdhJdeJWAFq1a27ijspkO7uMMZ6CapMCD_6o4jA,36746
-sapiopycommons/files/file_util.py,sha256=44mzhn3M_QltoncBB-ooX7_yO6u5k-XU_bzUXHGxUiw,26299
-sapiopycommons/files/file_validator.py,sha256=BhXB2XnoNEzdBXuwul1s2RNoj-3ZoiMmephUCU_0o3Y,28113
+sapiopycommons/files/file_util.py,sha256=92SzwRif4dOcGqZ9ri90QeC20NOCenT8DxQjdSH5Uyc,25556
+sapiopycommons/files/file_validator.py,sha256=5DUI_h0WB1AvfoPgx8En3-sC5xlzm5Z2deoSf9qviKQ,24499
 sapiopycommons/files/file_writer.py,sha256=5u_iZXTQvuUU7ceHZr8Q001_tvgJhOqBwAnB_pxcAbQ,16027
 sapiopycommons/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/general/accession_service.py,sha256=HYgyOsH_UaoRnoury-c2yTW8SeG4OtjLemdpCzoV4R8,13484
 sapiopycommons/general/aliases.py,sha256=i6af5o2oVFGNcyk7GkvTWXQs0H9xTbFKc_GIah8NKVU,3594
-sapiopycommons/general/custom_report_util.py,sha256=cLgIR5Fn3M9uyAtgfTYRv3JRk2SKNevnsb_R5zidSYs,15557
+sapiopycommons/general/custom_report_util.py,sha256=Yrq-Ize1M1jh9g3BmQT9Egedufi3Nl9xNmgNI_LGiho,4828
 sapiopycommons/general/exceptions.py,sha256=DOlLKnpCatxQF-lVCToa8ryJgusWLvip6N_1ALN00QE,1679
 sapiopycommons/general/popup_util.py,sha256=-mN5IgYPrLrOEHJ4CHPi2rec4_WAN6X0yMxHwD5h3Bs,30126
 sapiopycommons/general/storage_util.py,sha256=ovmK_jN7v09BoX07XxwShpBUC5WYQOM7dbKV_VeLXJU,8892
 sapiopycommons/general/time_util.py,sha256=jiJUh7jc1ZRCOem880S3HaLPZ4RboBtSl4_U9sqAQuM,7290
-sapiopycommons/multimodal/multimodal.py,sha256=A1QsC8QTPmgZyPr7KtMbPRedn2Ie4WIErodUvQ9otgU,6724
-sapiopycommons/multimodal/multimodal_data.py,sha256=zqgYHO-ULaPKV0POFWZVY9N-Sfm1RQWwdsfwFxe5DjI,15038
 sapiopycommons/processtracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/processtracking/endpoints.py,sha256=g5h_uCVByqacYm9zWAz8TyAdRsGfaO2o0b5RSJdOaSA,10926
 sapiopycommons/recordmodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/recordmodel/record_handler.py,sha256=AyK1H3x-g1eu1Mt9XD1h57yRrZp_TJjZlEaQ2kPP4Dc,54432
+sapiopycommons/recordmodel/record_handler.py,sha256=VYUJ0bgZbyc6-XYRKvsxrpWHLdCwxzhv13Ce2tZpAQQ,39348
 sapiopycommons/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/rules/eln_rule_handler.py,sha256=qfkBZtck0KK1i9s9Xe2UZqkzQOgPCzDxRkhxE8Si1xk,10671
 sapiopycommons/rules/on_save_rule_handler.py,sha256=JY9F30IcHwFVdgPAMQtTYuRastV1jeezhVktyrzNASU,10763
 sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/webhook/webhook_handlers.py,sha256=ibpBY3Sk3Eij919bIdW0awzlogYoQSWYDDOg--NwsQE,13431
-sapiopycommons-2024.8.27a312.dist-info/METADATA,sha256=l7W9c2MXyyCiy-ef9TZL0Xdp9-ZcQsLjDPI_nsQNet4,3176
-sapiopycommons-2024.8.27a312.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sapiopycommons-2024.8.27a312.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2024.8.27a312.dist-info/RECORD,,
+sapiopycommons/webhook/webhook_handlers.py,sha256=K_K7CEAMZ-bNb2LCIKdt0CxHsBKkwSBzfnp0JSdGJUM,11102
+sapiopycommons-2024.8.28a313.dist-info/METADATA,sha256=xb9YgxmbGyTKDDaq4vOrxEk5wNz-8KQ_-6WPBgMFexg,3009
+sapiopycommons-2024.8.28a313.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+sapiopycommons-2024.8.28a313.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2024.8.28a313.dist-info/RECORD,,