chore: added local client implementation for hooks

jsalaber · jsalaber · commit 29f432d30384 · 2025-06-27T12:26:28.000-04:00
diff --git a/devcycle_python_sdk/cloud_client.py b/devcycle_python_sdk/cloud_client.py
@@ -9,7 +9,11 @@
     NotFoundError,
     CloudClientUnauthorizedError,
 )
-from devcycle_python_sdk.managers.eval_hooks_manager import EvalHooksManager, BeforeHookError, AfterHookError
+from devcycle_python_sdk.managers.eval_hooks_manager import (
+    EvalHooksManager,
+    BeforeHookError,
+    AfterHookError,
+)
 from devcycle_python_sdk.models.eval_hook import EvalHook
 from devcycle_python_sdk.models.eval_hook_context import HookContext
 from devcycle_python_sdk.models.user import DevCycleUser
@@ -48,7 +52,9 @@ def __init__(self, sdk_key: str, options: DevCycleCloudOptions):
         self.sdk_type = "server"
         self.bucketing_api = BucketingAPIClient(sdk_key, self.options)
         self._openfeature_provider = DevCycleProvider(self)
-        self.eval_hooks_manager = EvalHooksManager(None if options is None else options.eval_hooks)
+        self.eval_hooks_manager = EvalHooksManager(
+            None if options is None else options.eval_hooks
+        )
 
     def get_sdk_platform(self) -> str:
         return "Cloud"
@@ -93,8 +99,8 @@ def variable(self, user: DevCycleUser, key: str, default_value: Any) -> Variable
 
         context = HookContext(key, user, default_value)
         variable = Variable.create_default_variable(
-                key=key, default_value=default_value
-            )
+            key=key, default_value=default_value
+        )
 
         try:
             before_hook_error = None
@@ -105,7 +111,7 @@ def variable(self, user: DevCycleUser, key: str, default_value: Any) -> Variable
             variable = self.bucketing_api.variable(key, context.user)
             if before_hook_error is None:
                 self.eval_hooks_manager.run_after(context, variable)
-            else :
+            else:
                 raise before_hook_error
         except CloudClientUnauthorizedError as e:
             logger.warning("DevCycle: SDK key is invalid, unable to make cloud request")
diff --git a/devcycle_python_sdk/local_client.py b/devcycle_python_sdk/local_client.py
@@ -8,8 +8,15 @@
 from devcycle_python_sdk.api.local_bucketing import LocalBucketing
 from devcycle_python_sdk.exceptions import VariableTypeMismatchError
 from devcycle_python_sdk.managers.config_manager import EnvironmentConfigManager
+from devcycle_python_sdk.managers.eval_hooks_manager import (
+    EvalHooksManager,
+    BeforeHookError,
+    AfterHookError,
+)
 from devcycle_python_sdk.managers.event_queue_manager import EventQueueManager
 from devcycle_python_sdk.models.bucketed_config import BucketedConfig
+from devcycle_python_sdk.models.eval_hook import EvalHook
+from devcycle_python_sdk.models.eval_hook_context import HookContext
 from devcycle_python_sdk.models.event import DevCycleEvent, EventType
 from devcycle_python_sdk.models.feature import Feature
 from devcycle_python_sdk.models.platform_data import default_platform_data
@@ -51,6 +58,7 @@ def __init__(self, sdk_key: str, options: DevCycleLocalOptions):
         )
 
         self._openfeature_provider: Optional[DevCycleProvider] = None
+        self.eval_hooks_manager = EvalHooksManager(self.options.eval_hooks)
 
     def get_sdk_platform(self) -> str:
         return "Local"
@@ -133,18 +141,44 @@ def variable(self, user: DevCycleUser, key: str, default_value: Any) -> Variable
                 )
             return Variable.create_default_variable(key, default_value)
 
+        context = HookContext(key, user, default_value)
+        variable = Variable.create_default_variable(
+            key=key, default_value=default_value
+        )
+
         try:
+            before_hook_error = None
+            try:
+                context = self.eval_hooks_manager.run_before(context)
+            except BeforeHookError as e:
+                before_hook_error = e
             variable = self.local_bucketing.get_variable_for_user_protobuf(
                 user, key, default_value
             )
-            if variable:
-                return variable
+            if variable is None:
+                variable = Variable.create_default_variable(
+                    key=key, default_value=default_value
+                )
+
+            if before_hook_error is None:
+                self.eval_hooks_manager.run_after(context, variable)
+            else:
+                raise before_hook_error
         except VariableTypeMismatchError:
             logger.debug("DevCycle: Variable type mismatch, returning default value")
+            return variable
+        except BeforeHookError as e:
+            self.eval_hooks_manager.run_error(context, e)
+            return variable
+        except AfterHookError as e:
+            self.eval_hooks_manager.run_error(context, e)
+            return variable
         except Exception as e:
             logger.warning(f"DevCycle: Error retrieving variable for user: {e}")
-
-        return Variable.create_default_variable(key, default_value)
+            return variable
+        finally:
+            self.eval_hooks_manager.run_finally(context, variable)
+        return variable
 
     def _generate_bucketed_config(self, user: DevCycleUser) -> BucketedConfig:
         """
@@ -234,6 +268,12 @@ def close(self) -> None:
         self.config_manager.close()
         self.event_queue_manager.close()
 
+    def add_hook(self, eval_hook: EvalHook) -> None:
+        self.eval_hooks_manager.add_hook(eval_hook)
+
+    def clear_hooks(self) -> None:
+        self.eval_hooks_manager.clear_hooks()
+
 
 def _validate_sdk_key(sdk_key: str) -> None:
     if sdk_key is None or len(sdk_key) == 0:
diff --git a/devcycle_python_sdk/managers/eval_hooks_manager.py b/devcycle_python_sdk/managers/eval_hooks_manager.py
@@ -8,6 +8,7 @@
 
 class BeforeHookError(Exception):
     """Exception raised when a before hook fails"""
+
     def __init__(self, message: str, original_error: Exception = None):
         self.message = message
         self.original_error = original_error
@@ -16,6 +17,7 @@ def __init__(self, message: str, original_error: Exception = None):
 
 class AfterHookError(Exception):
     """Exception raised when an after hook fails"""
+
     def __init__(self, message: str, original_error: Exception = None):
         self.message = message
         self.original_error = original_error
@@ -73,4 +75,3 @@ def run_error(self, context: HookContext, error: Exception) -> None:
                     hook.error(context, error)
                 except Exception as e:
                     logger.error(f"Error running error hook: {e}")
-
diff --git a/devcycle_python_sdk/models/eval_hook.py b/devcycle_python_sdk/models/eval_hook.py
@@ -3,13 +3,14 @@
 from devcycle_python_sdk.models.eval_hook_context import HookContext
 from devcycle_python_sdk.models.variable import Variable
 
+
 class EvalHook:
     def __init__(
         self,
         before: Callable[[HookContext], Optional[HookContext]] = None,
         after: Callable[[HookContext, Variable], None] = None,
         on_finally: Callable[[HookContext, Optional[Variable]], None] = None,
-        error: Callable[[HookContext, Exception], None] = None
+        error: Callable[[HookContext, Exception], None] = None,
     ):
         self.before = before
         self.after = after
diff --git a/test/test_cloud_client.py b/test/test_cloud_client.py
@@ -289,19 +289,29 @@ def test_hooks(self, mock_variable_call):
             _id="123", key="strKey", value=999, type=TypeEnum.NUMBER
         )
         # Test adding hooks
-        hook_called = {"before": False, "after": False, "finally": False, "error": False}
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
 
         def before_hook(context):
             hook_called["before"] = True
             return context
+
         def after_hook(context, variable):
             hook_called["after"] = True
+
         def finally_hook(context, variable):
             hook_called["finally"] = True
+
         def error_hook(context, error):
             hook_called["error"] = True
 
-        self.test_client.add_hook(EvalHook(before_hook, after_hook, finally_hook, error_hook))
+        self.test_client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
 
         # Test hooks called during variable evaluation
         variable = self.test_client.variable(self.test_user, "strKey", 42)
@@ -319,19 +329,29 @@ def test_hook_exceptions(self, mock_variable_call):
             _id="123", key="strKey", value=999, type=TypeEnum.NUMBER
         )
         # Test adding hooks
-        hook_called = {"before": False, "after": False, "finally": False, "error": False}
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
 
         def before_hook(context):
             hook_called["before"] = True
             raise Exception("Before hook failed")
+
         def after_hook(context, variable):
             hook_called["after"] = True
+
         def finally_hook(context, variable):
             hook_called["finally"] = True
+
         def error_hook(context, error):
             hook_called["error"] = True
 
-        self.test_client.add_hook(EvalHook(before_hook, after_hook, finally_hook, error_hook))
+        self.test_client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
 
         # Test hooks called during variable evaluation
         variable = self.test_client.variable(self.test_user, "strKey", 42)
@@ -343,5 +363,6 @@ def error_hook(context, error):
         self.assertTrue(hook_called["finally"])
         self.assertTrue(hook_called["error"])
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/test_local_client.py b/test/test_local_client.py
@@ -9,6 +9,7 @@
 from devcycle_python_sdk import DevCycleLocalClient, DevCycleLocalOptions
 from devcycle_python_sdk.local_client import _validate_user, _validate_sdk_key
 from devcycle_python_sdk.exceptions import MalformedConfigError
+from devcycle_python_sdk.models.eval_hook import EvalHook
 from devcycle_python_sdk.models.event import DevCycleEvent
 from devcycle_python_sdk.models.feature import Feature
 from devcycle_python_sdk.api.local_bucketing import LocalBucketing
@@ -361,6 +362,80 @@ def test_all_variables_exception(self, _):
         result = self.client.all_variables(user)
         self.assertEqual(result, {})
 
+    def test_hooks(self):
+        self.setup_client()
+        # Test adding hooks
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
+
+        def before_hook(context):
+            hook_called["before"] = True
+            return context
+
+        def after_hook(context, variable):
+            hook_called["after"] = True
+
+        def finally_hook(context, variable):
+            hook_called["finally"] = True
+
+        def error_hook(context, error):
+            hook_called["error"] = True
+
+        self.client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
+
+        # Test hooks called during variable evaluation
+        variable = self.client.variable(self.test_user, "strKey", 42)
+        self.assertTrue(variable.value == 999)
+        self.assertFalse(variable.isDefaulted)
+
+        self.assertTrue(hook_called["before"])
+        self.assertTrue(hook_called["after"])
+        self.assertTrue(hook_called["finally"])
+        self.assertFalse(hook_called["error"])
+
+    def test_hook_exceptions(self):
+        self.setup_client()
+        # Test adding hooks
+        hook_called = {
+            "before": False,
+            "after": False,
+            "finally": False,
+            "error": False,
+        }
+
+        def before_hook(context):
+            hook_called["before"] = True
+            raise Exception("Before hook failed")
+
+        def after_hook(context, variable):
+            hook_called["after"] = True
+
+        def finally_hook(context, variable):
+            hook_called["finally"] = True
+
+        def error_hook(context, error):
+            hook_called["error"] = True
+
+        self.client.add_hook(
+            EvalHook(before_hook, after_hook, finally_hook, error_hook)
+        )
+
+        # Test hooks called during variable evaluation
+        variable = self.client.variable(self.test_user, "strKey", 42)
+        self.assertTrue(variable.value == 999)
+        self.assertFalse(variable.isDefaulted)
+
+        self.assertTrue(hook_called["before"])
+        self.assertFalse(hook_called["after"])
+        self.assertTrue(hook_called["finally"])
+        self.assertTrue(hook_called["error"])
+
 
 def _benchmark_variable_call(client: DevCycleLocalClient, user: DevCycleUser, key: str):
     return client.variable(user, key, "default_value")
