replace exception raising with error flag resolution

Signed-off-by: gruebel <[email protected]>

Author: gruebel

openfeature/client.py

@@ -446,12 +446,12 @@ def _establish_hooks_and_provider(
 
     def _assert_provider_status(
         self,
-    ) -> None:
+    ) -> typing.Optional[OpenFeatureError]:
         status = self.get_provider_status()
         if status == ProviderStatus.NOT_READY:
-            raise ProviderNotReadyError()
+            return ProviderNotReadyError()
         if status == ProviderStatus.FATAL:
-            raise ProviderFatalError()
+            return ProviderFatalError()
         return None
 
     def _before_hooks_and_merge_context(
@@ -511,7 +511,22 @@ async def evaluate_flag_details_async(
         )
 
         try:
-            self._assert_provider_status()
+            if provider_err := self._assert_provider_status():
+                error_hooks(
+                    flag_type,
+                    hook_context,
+                    provider_err,
+                    reversed_merged_hooks,
+                    hook_hints,
+                )
+                details = FlagEvaluationDetails(
+                    flag_key=flag_key,
+                    value=default_value,
+                    reason=Reason.ERROR,
+                    error_code=provider_err.error_code,
+                    error_message=provider_err.error_message,
+                )
+                return details
 
             merged_context = self._before_hooks_and_merge_context(
                 flag_type,
@@ -521,34 +536,39 @@ async def evaluate_flag_details_async(
                 evaluation_context,
             )
 
-            flag_evaluation = await self._create_provider_evaluation_async(
+            details = await self._create_provider_evaluation_async(
                 provider,
                 flag_type,
                 flag_key,
                 default_value,
                 merged_context,
             )
+            if err := details.get_exception():
+                error_hooks(
+                    flag_type, hook_context, err, reversed_merged_hooks, hook_hints
+                )
+                return details
 
             after_hooks(
                 flag_type,
                 hook_context,
-                flag_evaluation,
+                details,
                 reversed_merged_hooks,
                 hook_hints,
             )
 
-            return flag_evaluation
+            return details
 
         except OpenFeatureError as err:
             error_hooks(flag_type, hook_context, err, reversed_merged_hooks, hook_hints)
-            flag_evaluation = FlagEvaluationDetails(
+            details = FlagEvaluationDetails(
                 flag_key=flag_key,
                 value=default_value,
                 reason=Reason.ERROR,
                 error_code=err.error_code,
                 error_message=err.error_message,
             )
-            return flag_evaluation
+            return details
         # Catch any type of exception here since the user can provide any exception
         # in the error hooks
         except Exception as err:  # pragma: no cover
@@ -559,20 +579,20 @@ async def evaluate_flag_details_async(
             error_hooks(flag_type, hook_context, err, reversed_merged_hooks, hook_hints)
 
             error_message = getattr(err, "error_message", str(err))
-            flag_evaluation = FlagEvaluationDetails(
+            details = FlagEvaluationDetails(
                 flag_key=flag_key,
                 value=default_value,
                 reason=Reason.ERROR,
                 error_code=ErrorCode.GENERAL,
                 error_message=error_message,
             )
-            return flag_evaluation
+            return details
 
         finally:
             after_all_hooks(
                 flag_type,
                 hook_context,
-                flag_evaluation,
+                details,
                 reversed_merged_hooks,
                 hook_hints,
             )
@@ -607,7 +627,22 @@ def evaluate_flag_details(
         )
 
         try:
-            self._assert_provider_status()
+            if provider_err := self._assert_provider_status():
+                error_hooks(
+                    flag_type,
+                    hook_context,
+                    provider_err,
+                    reversed_merged_hooks,
+                    hook_hints,
+                )
+                flag_evaluation = FlagEvaluationDetails(
+                    flag_key=flag_key,
+                    value=default_value,
+                    reason=Reason.ERROR,
+                    error_code=provider_err.error_code,
+                    error_message=provider_err.error_message,
+                )
+                return flag_evaluation
 
             merged_context = self._before_hooks_and_merge_context(
                 flag_type,
@@ -624,6 +659,11 @@ def evaluate_flag_details(
                 default_value,
                 merged_context,
             )
+            if err := flag_evaluation.get_exception():
+                error_hooks(
+                    flag_type, hook_context, err, reversed_merged_hooks, hook_hints
+                )
+                return flag_evaluation
 
             after_hooks(
                 flag_type,
@@ -693,27 +733,33 @@ async def _create_provider_evaluation_async(
         }
         get_details_callable = get_details_callables_async.get(flag_type)
         if not get_details_callable:
-            raise GeneralError(error_message="Unknown flag type")
+            return FlagEvaluationDetails(
+                flag_key=flag_key,
+                value=default_value,
+                reason=Reason.ERROR,
+                error_code=ErrorCode.GENERAL,
+                error_message="Unknown flag type",
+            )
 
         resolution = await get_details_callable(
             flag_key=flag_key,
             default_value=default_value,
             evaluation_context=evaluation_context,
         )
-        resolution.raise_for_error()
+        if resolution.error_code:
+            return resolution.to_flag_evaluation_details(flag_key)
 
         # we need to check the get_args to be compatible with union types.
-        _typecheck_flag_value(resolution.value, flag_type)
+        if err := _typecheck_flag_value(value=resolution.value, flag_type=flag_type):
+            return FlagEvaluationDetails(
+                flag_key=flag_key,
+                value=resolution.value,
+                reason=Reason.ERROR,
+                error_code=err.error_code,
+                error_message=err.error_message,
+            )
 
-        return FlagEvaluationDetails(
-            flag_key=flag_key,
-            value=resolution.value,
-            variant=resolution.variant,
-            flag_metadata=resolution.flag_metadata or {},
-            reason=resolution.reason,
-            error_code=resolution.error_code,
-            error_message=resolution.error_message,
-        )
+        return resolution.to_flag_evaluation_details(flag_key)
 
     def _create_provider_evaluation(
         self,
@@ -743,27 +789,33 @@ def _create_provider_evaluation(
 
         get_details_callable = get_details_callables.get(flag_type)
         if not get_details_callable:
-            raise GeneralError(error_message="Unknown flag type")
+            return FlagEvaluationDetails(
+                flag_key=flag_key,
+                value=default_value,
+                reason=Reason.ERROR,
+                error_code=ErrorCode.GENERAL,
+                error_message="Unknown flag type",
+            )
 
         resolution = get_details_callable(
             flag_key=flag_key,
             default_value=default_value,
             evaluation_context=evaluation_context,
         )
-        resolution.raise_for_error()
+        if resolution.error_code:
+            return resolution.to_flag_evaluation_details(flag_key)
 
         # we need to check the get_args to be compatible with union types.
-        _typecheck_flag_value(resolution.value, flag_type)
+        if err := _typecheck_flag_value(value=resolution.value, flag_type=flag_type):
+            return FlagEvaluationDetails(
+                flag_key=flag_key,
+                value=resolution.value,
+                reason=Reason.ERROR,
+                error_code=err.error_code,
+                error_message=err.error_message,
+            )
 
-        return FlagEvaluationDetails(
-            flag_key=flag_key,
-            value=resolution.value,
-            variant=resolution.variant,
-            flag_metadata=resolution.flag_metadata or {},
-            reason=resolution.reason,
-            error_code=resolution.error_code,
-            error_message=resolution.error_message,
-        )
+        return resolution.to_flag_evaluation_details(flag_key)
 
     def add_handler(self, event: ProviderEvent, handler: EventHandler) -> None:
         _event_support.add_client_handler(self, event, handler)
@@ -772,7 +824,9 @@ def remove_handler(self, event: ProviderEvent, handler: EventHandler) -> None:
         _event_support.remove_client_handler(self, event, handler)
 
 
-def _typecheck_flag_value(value: typing.Any, flag_type: FlagType) -> None:
+def _typecheck_flag_value(
+    value: typing.Any, flag_type: FlagType
+) -> typing.Optional[OpenFeatureError]:
     type_map: TypeMap = {
         FlagType.BOOLEAN: bool,
         FlagType.STRING: str,
@@ -782,6 +836,7 @@ def _typecheck_flag_value(value: typing.Any, flag_type: FlagType) -> None:
     }
     _type = type_map.get(flag_type)
     if not _type:
-        raise GeneralError(error_message="Unknown flag type")
+        return GeneralError(error_message="Unknown flag type")
     if not isinstance(value, _type):
-        raise TypeMismatchError(f"Expected type {_type} but got {type(value)}")
+        return TypeMismatchError(f"Expected type {_type} but got {type(value)}")
+    return None

openfeature/flag_evaluation.py

@@ -4,7 +4,7 @@
 from dataclasses import dataclass, field
 
 from openfeature._backports.strenum import StrEnum
-from openfeature.exception import ErrorCode
+from openfeature.exception import ErrorCode, OpenFeatureError
 
 if typing.TYPE_CHECKING:  # pragma: no cover
     # resolves a circular dependency in type annotations
@@ -56,6 +56,11 @@ class FlagEvaluationDetails(typing.Generic[T_co]):
     error_code: typing.Optional[ErrorCode] = None
     error_message: typing.Optional[str] = None
 
+    def get_exception(self) -> typing.Optional[OpenFeatureError]:
+        if self.error_code:
+            return ErrorCode.to_exception(self.error_code, self.error_message or "")
+        return None
+
 
 @dataclass
 class FlagEvaluationOptions:
@@ -79,3 +84,14 @@ def raise_for_error(self) -> None:
         if self.error_code:
             raise ErrorCode.to_exception(self.error_code, self.error_message or "")
         return None
+
+    def to_flag_evaluation_details(self, flag_key: str) -> FlagEvaluationDetails[U_co]:
+        return FlagEvaluationDetails(
+            flag_key=flag_key,
+            value=self.value,
+            variant=self.variant,
+            flag_metadata=self.flag_metadata,
+            reason=self.reason,
+            error_code=self.error_code,
+            error_message=self.error_message,
+        )