sapiopycommons 2024.11.7a354__py3-none-any.whl → 2024.11.8a359__py3-none-any.whl

sapiopycommons/rules/eln_rule_handler.py

@@ -1,15 +1,10 @@
-from __future__ import annotations
-
-from weakref import WeakValueDictionary
-
-from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
+from sapiopylib.rest.pojo.webhook.VeloxRules import VeloxRuleType, VeloxRuleParser
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.general.aliases import FieldMap, AliasUtil, DataTypeIdentifier
+from sapiopycommons.general.aliases import FieldMap
 from sapiopycommons.general.exceptions import SapioException
 
 
@@ -17,6 +12,7 @@ from sapiopycommons.general.exceptions import SapioException
 class ElnRuleHandler:
     """
     A class which helps with the parsing and navigation of the ELN rule result map of a webhook context.
+    TODO: Add functionality around the VeloxRuleType of the rule results.
     """
     __context: SapioWebhookContext
     """The context that this handler is working from."""
@@ -38,25 +34,7 @@ class ElnRuleHandler:
     """A mapping of entry name to the lists of field maps for that entry, each grouping of field maps being mapped by
     its data type."""
 
-    __instances: WeakValueDictionary[SapioUser, ElnRuleHandler] = WeakValueDictionary()
-    __initialized: bool
-
-    def __new__(cls, context: SapioWebhookContext):
-        if context.velox_eln_rule_result_map is None:
-            raise SapioException("No Velox ELN rule result map in context for ElnRuleHandler to parse.")
-        user = context if isinstance(context, SapioUser) else context.user
-        obj = cls.__instances.get(user)
-        if not obj:
-            obj = object.__new__(cls)
-            obj.__initialized = False
-            cls.__instances[user] = obj
-        return obj
-
     def __init__(self, context: SapioWebhookContext):
-        if self.__initialized:
-            return
-        self.__initialized = True
-
         if context.velox_eln_rule_result_map is None:
             raise SapioException("No Velox ELN rule result map in context for ElnRuleHandler to parse.")
         self.__context = context
@@ -86,8 +64,13 @@ class ElnRuleHandler:
                         # Get the data type of this record. If this is an ELN type, ignore the digits.
                         data_type: str = record.data_type_name
                         # PR-46331: Ensure that all ELN types are converted to their base data type name.
-                        if ElnBaseDataType.is_eln_type(data_type):
-                            data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
+                        # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
+                        if data_type.startswith("ELNExperiment_"):
+                            data_type = "ELNExperiment"
+                        elif data_type.startswith("ELNExperimentDetail_"):
+                            data_type = "ELNExperimentDetail"
+                        elif data_type.startswith("ELNSampleDetail_"):
+                            data_type = "ELNSampleDetail"
                         # Update the list of records of this type that exist so far globally.
                         self.__records.setdefault(data_type, set()).add(record)
                         # Do the same for the list of records of this type for this specific entry.
@@ -102,9 +85,19 @@ class ElnRuleHandler:
             entry_dict: dict[str, dict[int, FieldMap]] = {}
             for record_result in entry_results:
                 for result in record_result.velox_type_rule_field_map_result_list:
-                    data_type: str = result.velox_type_pojo.data_type_name
-                    if ElnBaseDataType.is_eln_type(data_type):
-                        data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
+                    # TODO: sapiopylib currently has a bug where this velox_type_pojo variable is stored as a dict instead
+                    #  of as the intended VeloxRuleType object. Parse that dict as a VeloxRuleType before use.
+                    velox_type: VeloxRuleType | dict = result.velox_type_pojo
+                    if isinstance(velox_type, dict):
+                        velox_type: VeloxRuleType = VeloxRuleParser.parse_velox_rule_type(velox_type)
+                    data_type: str = velox_type.data_type_name
+                    # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
+                    if data_type.startswith("ELNExperiment_"):
+                        data_type = "ELNExperiment"
+                    elif data_type.startswith("ELNExperimentDetail_"):
+                        data_type = "ELNExperimentDetail"
+                    elif data_type.startswith("ELNSampleDetail_"):
+                        data_type = "ELNSampleDetail"
                     for field_map in result.field_map_list:
                         rec_id: int = field_map.get("RecordId")
                         self.__field_maps.setdefault(data_type, {}).update({rec_id: field_map})
@@ -125,7 +118,7 @@ class ElnRuleHandler:
         """
         return list(self.__entry_to_field_maps.keys())
 
-    def get_records(self, data_type: DataTypeIdentifier, entry: str | None = None) -> list[DataRecord]:
+    def get_records(self, data_type: str, entry: str | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of an entry name. If the given data type or entry does not exist in the context,
@@ -136,12 +129,11 @@ class ElnRuleHandler:
             type from every entry. If an entry is provided, but it does not exist in the context, returns an empty list.
         :return: The records from the context that match the input parameters.
         """
-        data_type: str = AliasUtil.to_data_type_name(data_type)
         records: dict[str, set[DataRecord]] = self.__entry_to_records.get(entry, {}) if entry else self.__records
         return list(records.get(data_type, []))
 
     # FR-46701: Add functions to the rule handlers for accessing the field maps of inaccessible records in the context.
-    def get_field_maps(self, data_type: DataTypeIdentifier, entry: str | None = None) -> list[FieldMap]:
+    def get_field_maps(self, data_type: str, entry: str | None = None) -> list[FieldMap]:
         """
         Get field maps from the cached context with the given data type. Capable of being filtered to searching within
         the context of an entry name. If the given data type or entry does not exist in the context,
@@ -157,7 +149,6 @@ class ElnRuleHandler:
             list.
         :return: The field maps from the context that match the input parameters.
         """
-        data_type: str = AliasUtil.to_data_type_name(data_type)
         field_maps: dict[str, dict[int, FieldMap]] = self.__entry_to_field_maps.get(entry, {}) if entry else self.__field_maps
         return list(field_maps.get(data_type, {}).values())
 

sapiopycommons/rules/on_save_rule_handler.py

@@ -1,15 +1,10 @@
-from __future__ import annotations
-
-from weakref import WeakValueDictionary
-
-from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
+from sapiopylib.rest.pojo.webhook.VeloxRules import VeloxRuleType, VeloxRuleParser
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.general.aliases import FieldMap, DataTypeIdentifier, AliasUtil
+from sapiopycommons.general.aliases import FieldMap
 from sapiopycommons.general.exceptions import SapioException
 
 
@@ -17,6 +12,7 @@ from sapiopycommons.general.exceptions import SapioException
 class OnSaveRuleHandler:
     """
     A class which helps with the parsing and navigation of the on save rule result map of a webhook context.
+    TODO: Add functionality around the VeloxRuleType of the rule results.
     """
     __context: SapioWebhookContext
     """The context that this handler is working from."""
@@ -38,25 +34,7 @@ class OnSaveRuleHandler:
     """A mapping of record IDs of records in the context.data_record_list to the field maps related to that
     record, each grouping of field maps being mapped by its data type."""
 
-    __instances: WeakValueDictionary[SapioUser, OnSaveRuleHandler] = WeakValueDictionary()
-    __initialized: bool
-
-    def __new__(cls, context: SapioWebhookContext):
-        if context.velox_on_save_result_map is None:
-            raise SapioException("No Velox on save rule result map in context for OnSaveRuleHandler to parse.")
-        user = context if isinstance(context, SapioUser) else context.user
-        obj = cls.__instances.get(user)
-        if not obj:
-            obj = object.__new__(cls)
-            obj.__initialized = False
-            cls.__instances[user] = obj
-        return obj
-
     def __init__(self, context: SapioWebhookContext):
-        if self.__initialized:
-            return
-        self.__initialized = True
-
         if context.velox_on_save_result_map is None:
             raise SapioException("No Velox on save rule result map in context for OnSaveRuleHandler to parse.")
         self.__context = context
@@ -73,6 +51,9 @@ class OnSaveRuleHandler:
         self.__base_id_to_records = {}
         # Each record ID in the context has a list of results for that record.
         for record_id, rule_results in self.__context.velox_on_save_result_map.items():
+            # TODO: Record IDs are currently being stored in the map as strings instead of ints. This can be removed
+            #  once sapiopylib is fixed.
+            record_id = int(record_id)
             # Keep track of the records for this specific record ID.
             id_dict: dict[str, set[DataRecord]] = {}
             # The list of results for a record consist of a list of data records and a VeloxType that specifies
@@ -83,8 +64,13 @@ class OnSaveRuleHandler:
                     # Get the data type of this record. If this is an ELN type, ignore the digits.
                     data_type: str = record.data_type_name
                     # PR-46331: Ensure that all ELN types are converted to their base data type name.
-                    if ElnBaseDataType.is_eln_type(data_type):
-                        data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
+                    # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
+                    if data_type.startswith("ELNExperiment_"):
+                        data_type = "ELNExperiment"
+                    elif data_type.startswith("ELNExperimentDetail_"):
+                        data_type = "ELNExperimentDetail"
+                    elif data_type.startswith("ELNSampleDetail_"):
+                        data_type = "ELNSampleDetail"
                     # Update the list of records of this type that exist so far globally.
                     self.__records.setdefault(data_type, set()).add(record)
                     # Do the same for the list of records of this type that relate to this record ID.
@@ -96,11 +82,24 @@ class OnSaveRuleHandler:
         self.__base_id_to_field_maps = {}
         # Repeat the same thing for the field map results.
         for record_id, rule_results in self.__context.velox_on_save_field_map_result_map.items():
+            # TODO: Record IDs are currently being stored in the map as strings instead of ints. This can be removed
+            #  once sapiopylib is fixed.
+            record_id = int(record_id)
             id_dict: dict[str, dict[int, FieldMap]] = {}
             for record_result in rule_results:
-                data_type: str = record_result.velox_type_pojo.data_type_name
-                if ElnBaseDataType.is_eln_type(data_type):
-                    data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
+                # TODO: sapiopylib currently has a bug where this velox_type_pojo variable is stored as a dict instead
+                #  of as the intended VeloxRuleType object. Parse that dict as a VeloxRuleType before use.
+                velox_type: VeloxRuleType | dict = record_result.velox_type_pojo
+                if isinstance(velox_type, dict):
+                    velox_type: VeloxRuleType = VeloxRuleParser.parse_velox_rule_type(velox_type)
+                data_type: str = velox_type.data_type_name
+                # TODO: Use ElnBaseDataType.is_eln_type when it is no longer bugged in sapiopylib.
+                if data_type.startswith("ELNExperiment_"):
+                    data_type = "ELNExperiment"
+                elif data_type.startswith("ELNExperimentDetail_"):
+                    data_type = "ELNExperimentDetail"
+                elif data_type.startswith("ELNSampleDetail_"):
+                    data_type = "ELNSampleDetail"
                 for field_map in record_result.field_map_list:
                     rec_id: int = field_map.get("RecordId")
                     self.__field_maps.setdefault(data_type, {}).update({rec_id: field_map})
@@ -121,7 +120,7 @@ class OnSaveRuleHandler:
         """
         return list(self.__base_id_to_field_maps.keys())
 
-    def get_records(self, data_type: DataTypeIdentifier, record_id: int | None = None) -> list[DataRecord]:
+    def get_records(self, data_type: str, record_id: int | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of a record ID. If the given data type or record ID does not exist in the context,
@@ -132,12 +131,11 @@ class OnSaveRuleHandler:
             data type from every ID. If an ID is provided, but it does not exist in the context, returns an empty list.
         :return: The records from the context that match the input parameters.
         """
-        data_type: str = AliasUtil.to_data_type_name(data_type)
         records: dict[str, set[DataRecord]] = self.__base_id_to_records.get(record_id, {}) if record_id else self.__records
         return list(records.get(data_type, []))
 
     # FR-46701: Add functions to the rule handlers for accessing the field maps of inaccessible records in the context.
-    def get_field_maps(self, data_type: DataTypeIdentifier, record_id: int | None = None) -> list[FieldMap]:
+    def get_field_maps(self, data_type: str, record_id: int | None = None) -> list[FieldMap]:
         """
         Get field maps from the cached context with the given data type. Capable of being filtered to searching within
         the context of a record ID. If the given data type or record ID does not exist in the context,
@@ -153,7 +151,6 @@ class OnSaveRuleHandler:
             list.
         :return: The field maps from the context that match the input parameters.
         """
-        data_type: str = AliasUtil.to_data_type_name(data_type)
         field_maps: dict[str, dict[int, FieldMap]] = self.__base_id_to_field_maps.get(record_id, {}) if record_id else self.__field_maps
         return list(field_maps.get(data_type, {}).values())
 

sapiopycommons/webhook/webhook_handlers.py

@@ -4,25 +4,16 @@ from logging import Logger
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
-from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.WebhookService import AbstractWebhookHandler
-from sapiopylib.rest.pojo.Message import VeloxLogMessage, VeloxLogLevel
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.pojo.webhook.WebhookEnums import WebhookEndpointType
 from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
-from sapiopylib.rest.utils.DataTypeCacheManager import DataTypeCacheManager
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager, \
     RecordModelRelationshipManager
 from sapiopylib.rest.utils.recordmodel.ancestry import RecordModelAncestorManager
 
-from sapiopycommons.callbacks.callback_util import CallbackUtil
-from sapiopycommons.eln.experiment_handler import ExperimentHandler
 from sapiopycommons.general.exceptions import SapioUserErrorException, SapioCriticalErrorException, \
-    SapioUserCancelledException, SapioException, SapioDialogTimeoutException
-from sapiopycommons.general.sapio_links import SapioNavigationLinker
-from sapiopycommons.recordmodel.record_handler import RecordHandler
-from sapiopycommons.rules.eln_rule_handler import ElnRuleHandler
-from sapiopycommons.rules.on_save_rule_handler import OnSaveRuleHandler
+    SapioUserCancelledException
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -34,7 +25,6 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
     """
     logger: Logger
 
-    user: SapioUser
     context: SapioWebhookContext
 
     dr_man: DataRecordManager
@@ -44,64 +34,29 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
     # FR-46329: Add the ancestor manager to CommonsWebhookHandler.
     an_man: RecordModelAncestorManager
 
-    dt_cache: DataTypeCacheManager
-    rec_handler: RecordHandler
-    callback: CallbackUtil
-    exp_handler: ExperimentHandler | None
-    rule_handler: OnSaveRuleHandler | ElnRuleHandler | None
-
     def run(self, context: SapioWebhookContext) -> SapioWebhookResult:
-        self.user = context.user
         self.context = context
-
-        self.logger = self.user.logger
+        self.logger = context.user.logger
 
         self.dr_man = context.data_record_manager
-        self.rec_man = RecordModelManager(self.user)
+        self.rec_man = RecordModelManager(context.user)
         self.inst_man = self.rec_man.instance_manager
         self.rel_man = self.rec_man.relationship_manager
         self.an_man = RecordModelAncestorManager(self.rec_man)
 
-        self.dt_cache = DataTypeCacheManager(self.user)
-        self.rec_handler = RecordHandler(context)
-        self.callback = CallbackUtil(context)
-        if context.eln_experiment is not None:
-            self.exp_handler = ExperimentHandler(context)
-        else:
-            self.exp_handler = None
-        if self.is_on_save_rule():
-            self.rule_handler = OnSaveRuleHandler(context)
-        elif self.is_eln_rule():
-            self.rule_handler = ElnRuleHandler(context)
-        else:
-            self.rule_handler = None
-
         # 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)
-            result = self.execute(context)
-            if result is None:
-                raise SapioException("Your execute function returned a None result! Don't forget your return statement!")
-            return result
+            return self.execute(context)
         except SapioUserErrorException as e:
             return self.handle_user_error_exception(e)
         except SapioCriticalErrorException as e:
             return self.handle_critical_error_exception(e)
         except SapioUserCancelledException as e:
             return self.handle_user_cancelled_exception(e)
-        except SapioDialogTimeoutException as e:
-            return self.handle_dialog_timeout_exception(e)
         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:
         """
@@ -113,12 +68,11 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
     # the run method and into their own functions.
     def handle_user_error_exception(self, e: SapioUserErrorException) -> SapioWebhookResult:
         """
-        Handle a SapioUserErrorException.
-
-        Default behavior returns a false result and the error message as display text in a webhook result.
+        Handle a SapioUserErrorException. Default behavior returns the error message as display text in a webhook
+        result.
 
         :param e: The exception that was raised.
-        :return: A SapioWebhookResult to end the webhook session with.
+        :return: A SapioWebhookResult reporting the exception to the user.
         """
         result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
@@ -128,83 +82,45 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
 
     def handle_critical_error_exception(self, e: SapioCriticalErrorException) -> SapioWebhookResult:
         """
-        Handle a SapioCriticalErrorException.
-
-        Default behavior makes a display_error client callback with the error message and returns a false result.
+        Handle a SapioCriticalErrorException. Default behavior makes a display_error client callback.
 
         :param e: The exception that was raised.
-        :return: A SapioWebhookResult to end the webhook session with.
+        :return: A SapioWebhookResult reporting the exception to the user.
         """
         result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
             return result
         self.log_error(traceback.format_exc())
-        # This error can be thrown by endpoints that can't send client callbacks. If that happens, fall back onto
-        # sending display text instead.
-        if self.can_send_client_callback():
-            self.callback.display_error(e.args[0])
-        else:
-            return SapioWebhookResult(False, e.args[0])
+        DataMgmtServer.get_client_callback(self.context.user).display_error(e.args[0])
         return SapioWebhookResult(False)
 
-    def handle_user_cancelled_exception(self, e: SapioUserCancelledException) -> SapioWebhookResult:
-        """
-        Handle a SapioUserCancelledException.
-
-        Default behavior simply ends the webhook session with a true result (since the user cancelling is a valid
-        action).
-
-        :param e: The exception that was raised.
-        :return: A SapioWebhookResult to end the webhook session with.
-        """
-        result: SapioWebhookResult | None = self.handle_any_exception(e)
-        if result is not None:
-            return result
-        return SapioWebhookResult(True)
-
-    def handle_dialog_timeout_exception(self, e: SapioDialogTimeoutException) -> SapioWebhookResult:
+    def handle_unexpected_exception(self, e: Exception) -> SapioWebhookResult:
         """
-        Handle a SapioDialogTimeoutException.
-
-        Default behavior displays an OK popup notifying the user that the dialog has timed out and returns a false
-        webhook result.
+        Handle a generic exception which isn't a SapioUserErrorException or SapioCriticalErrorException. Default
+        behavior returns a generic error message as display text informing the user to contact Sapio support.
 
         :param e: The exception that was raised.
-        :return: A SapioWebhookResult to end the webhook session with.
+        :return: A SapioWebhookResult reporting the exception to the user.
         """
         result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
             return result
-        # This dialog could time out too! Ignore it if it does.
-        # No need to check can_send_client_callback() here, as this exception should only be thrown by endpoints that
-        # are capable of sending callbacks.
-        try:
-            self.callback.ok_dialog("Notice", "You have remained idle for too long and this dialog has timed out. "
-                                              "Close and re-initiate it to continue.")
-        except SapioDialogTimeoutException:
-            pass
-        return SapioWebhookResult(False)
+        self.log_error(traceback.format_exc())
+        return SapioWebhookResult(False, display_text="Unexpected error occurred during webhook execution. "
+                                                      "Please contact Sapio support.")
 
-    def handle_unexpected_exception(self, e: Exception) -> SapioWebhookResult:
+    def handle_user_cancelled_exception(self, e: SapioUserCancelledException) -> SapioWebhookResult:
         """
-        Handle a generic exception which isn't one of the handled Sapio exceptions.
-
-        Default behavior returns a false webhook result with a generic error message as display text informing the user
-        to contact Sapio support. Additionally, the stace trace of the exception that was thrown is logged to the
-        execution log for the webhook call in the system.
+        Handle a SapioUserCancelledException. Default behavior returns "User Cancelled" as display text in a webhook
+        result.
 
         :param e: The exception that was raised.
-        :return: A SapioWebhookResult to end the webhook session with.
+        :return: A SapioWebhookResult with display text saying the user cancelled the request.
         """
         result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
             return result
-        msg: str = traceback.format_exc()
-        self.log_error(msg)
-        # FR-47079: Also log all unexpected exception messages to the webhook execution log within the platform.
-        self.log_error_to_webhook_execution_log(msg)
-        return SapioWebhookResult(False, display_text="Unexpected error occurred during webhook execution. "
-                                                      "Please contact Sapio support.")
+        return SapioWebhookResult(False, display_text="User cancelled.")
 
     # noinspection PyMethodMayBeStatic,PyUnusedLocal
     def handle_any_exception(self, e: Exception) -> SapioWebhookResult | None:
@@ -214,65 +130,38 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
 
         :param e: The exception that was raised.
         :return: An optional SapioWebhookResult. May return a custom message to the client that wouldn't have been
-            sent by one of the normal exception handlers, or may return None if no result needs returned. It a result is
-            returned, then the default behavior of other exception handlers is skipped.
+            sent by one of the normal exception handlers, or may return None if no result needs returned.
         """
         return None
 
     def log_info(self, msg: str) -> None:
         """
-        Write an info message to the webhook server log. Log destination is stdout. This message will be prepended with
-        the user's username and the experiment ID of the experiment they are in, if any.
+        Write an info message to the log. Log destination is stdout. This message will be prepended with the user's
+        username and the experiment ID of the experiment they are in, if any.
         """
-        self.logger.info(self._format_log(msg, "log_info call"))
+        exp_id = None
+        if self.context.eln_experiment is not None:
+            exp_id = self.context.eln_experiment.notebook_experiment_id
+        # CR-46333: Add the user's group to the logging message.
+        user = self.context.user
+        username = user.username
+        group_name = user.session_additional_data.current_group_name
+        self.logger.info(f"(User: {username}, Group: {group_name}, Experiment: {exp_id}):\n{msg}")
 
     def log_error(self, msg: str) -> None:
         """
-        Write an error message to the webhook server log. Log destination is stderr. This message will be prepended with
-        the user's username and the experiment ID of the experiment they are in, if any.
-        """
-        # PR-46209: Use logger.error instead of logger.info when logging errors.
-        self.logger.error(self._format_log(msg, "log_error call"))
-
-    def log_error_to_webhook_execution_log(self, msg: str) -> None:
-        """
-        Write an error message to the platform's webhook execution log. This can be reviewed by navigating to the
-        webhook configuration where the webhook that called this function is defined and clicking the "View Log"
-        button. From there, select one of the rows for the webhook executions and click "Download Log" from the right
-        side table.
+        Write an error message to the log. Log destination is stderr. This message will be prepended with the user's
+        username and the experiment ID of the experiment they are in, if any.
         """
-        messenger = DataMgmtServer.get_messenger(self.user)
-        messenger.log_message(VeloxLogMessage(message=self._format_log(msg, "Error occurred during webhook execution."),
-                                              log_level=VeloxLogLevel.ERROR,
-                                              originating_class=self.__class__.__name__))
-
-    def _format_log(self, msg: str, prefix: str | None = None) -> str:
-        """
-        Given a message to log, populate it with some metadata about this particular webhook execution, including
-        the group of the user and the invocation type of the webhook call.
-        """
-        # If we're able to, provide a link to the location that the error occurred at.
-        navigator = SapioNavigationLinker(self.context)
+        exp_id = None
         if self.context.eln_experiment is not None:
-            link = navigator.experiment(self.context.eln_experiment)
-        elif self.context.data_record and not self.context.data_record_list:
-            link = navigator.data_record(self.context.data_record)
-        elif self.context.base_data_record:
-            link = navigator.data_record(self.context.base_data_record)
-        else:
-            link = None
-
-        message: str = ""
-        if prefix:
-            message += prefix + "\n"
-        message += f"Webhook invocation type: {self.context.end_point_type.display_name}\n"
-        message += f"Username: {self.user.username}\n"
+            exp_id = self.context.eln_experiment.notebook_experiment_id
         # CR-46333: Add the user's group to the logging message.
-        message += f"User group: {self.user.session_additional_data.current_group_name}\n"
-        if link:
-            message += f"User location: {link}\n"
-        message += msg
-        return message
+        user = self.context.user
+        username = user.username
+        group_name = user.session_additional_data.current_group_name
+        # PR-46209: Use logger.error instead of logger.info when logging errors.
+        self.logger.error(f"(User: {username}, Group: {group_name}, Experiment: {exp_id}):\n{msg}")
 
     def is_main_toolbar(self) -> bool:
         """
@@ -348,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.11.7a354.dist-info → sapiopycommons-2024.11.8a359.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.11.7a354
+Version: 2024.11.8a359
 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).