ensure flag_evaluation variable is present, add flag_evaluation to afterhooks and update readme with async doco

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

Author: leohoare

README.md

@@ -109,6 +109,7 @@ print("Value: " + str(flag_value))
 | ✅      | [Eventing](#eventing)                                               | React to state changes in the provider or flag management system.                                                                     |
 | ✅      | [Shutdown](#shutdown)                                               | Gracefully clean up a provider during application shutdown.                                                                           |
 | ✅      | [Transaction Context Propagation](#transaction-context-propagation) | Set a specific [evaluation context](/docs/reference/concepts/evaluation-context) for a transaction (e.g. an HTTP request or a thread) |
+| ✅      | [Asynchronous Feature Retrieval](#asynchronous-feature-retrieval)   | Evaluate flags in an asychronous context.                                                                                                 |
 | ✅      | [Extending](#extending)                                             | Extend OpenFeature with custom providers and hooks.                                                                                   |
 
 <sub>Implemented: ✅ | In-progress: ⚠️ | Not implemented yet: ❌</sub>
@@ -316,6 +317,26 @@ async def some_endpoint():
     return create_response()
 ```
 
+### Asynchronous Feature Retrieval 
+
+The OpenFeature API supports asynchronous calls, enabling non-blocking feature evaluations for improved performance, especially useful in concurrent or latency-sensitive scenarios. If a provider *hasn't* implemented asynchronous calls, the client can still be used asynchronously, but calls will be blocking (synchronous). 
+
+```python
+import asyncio
+from openfeature import api
+from openfeature.provider.in_memory_provider import InMemoryFlag, InMemoryProvider
+
+my_flags = { "v2_enabled": InMemoryFlag("on", {"on": True, "off": False}) }
+api.set_provider(InMemoryProvider(my_flags))
+client = api.get_client()
+flag_value = await client.get_boolean_value_async("v2_enabled", False) # API calls are suffixed by _async
+
+print("Value: " + str(flag_value))
+```
+
+See the [develop a provider](#develop-a-provider) for how to support asynchronous functionality in providers.
+
+
 ### Shutdown
 
 The OpenFeature API provides a shutdown function to perform a cleanup of all registered providers. This should only be called when your application is in the process of shutting down.

openfeature/client.py

@@ -556,12 +556,13 @@ async def evaluate_flag_details_async(
                 hook_hints,
             )
             if error_code:
-                return FlagEvaluationDetails(
+                flag_evaluation = FlagEvaluationDetails(
                     flag_key=flag_key,
                     value=default_value,
                     reason=Reason.ERROR,
                     error_code=error_code,
                 )
+                return flag_evaluation
 
             merged_context = self._before_hooks_and_merge_context(
                 flag_type,
@@ -591,14 +592,14 @@ async def evaluate_flag_details_async(
 
         except OpenFeatureError as err:
             error_hooks(flag_type, hook_context, err, reversed_merged_hooks, hook_hints)
-
-            return FlagEvaluationDetails(
+            flag_evaluation = FlagEvaluationDetails(
                 flag_key=flag_key,
                 value=default_value,
                 reason=Reason.ERROR,
                 error_code=err.error_code,
                 error_message=err.error_message,
             )
+            return flag_evaluation
         # Catch any type of exception here since the user can provide any exception
         # in the error hooks
         except Exception as err:  # pragma: no cover
@@ -609,16 +610,23 @@ 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))
-            return FlagEvaluationDetails(
+            flag_evaluation = FlagEvaluationDetails(
                 flag_key=flag_key,
                 value=default_value,
                 reason=Reason.ERROR,
                 error_code=ErrorCode.GENERAL,
                 error_message=error_message,
             )
+            return flag_evaluation
 
         finally:
-            after_all_hooks(flag_type, hook_context, reversed_merged_hooks, hook_hints)
+            after_all_hooks(
+                flag_type,
+                hook_context,
+                flag_evaluation,
+                reversed_merged_hooks,
+                hook_hints,
+            )
 
     def evaluate_flag_details(
         self,
@@ -657,12 +665,13 @@ def evaluate_flag_details(
                 hook_hints,
             )
             if error_code:
-                return FlagEvaluationDetails(
+                flag_evaluation = FlagEvaluationDetails(
                     flag_key=flag_key,
                     value=default_value,
                     reason=Reason.ERROR,
                     error_code=error_code,
                 )
+                return flag_evaluation
 
             merged_context = self._before_hooks_and_merge_context(
                 flag_type,