Merge pull request #5 from splitio/FME-10905-async-mode

chillaq · web-flow · commit 0f55db98946d · 2025-11-04T08:00:15.000-08:00
added support for async mode
diff --git a/split_openfeature/__init__.py b/split_openfeature/__init__.py
@@ -1,3 +1,3 @@
-from split_openfeature.split_provider import SplitProvider
+from split_openfeature.split_provider import SplitProvider, SplitProviderAsync
 from split_openfeature.split_client_wrapper import SplitClientWrapper
 
diff --git a/split_openfeature/split_client_wrapper.py b/split_openfeature/split_client_wrapper.py
@@ -1,5 +1,4 @@
-from splitio import get_factory
-from splitio.client.client import Client
+from splitio import get_factory, get_factory_async
 from splitio.exceptions import TimeoutException
 import logging
 
@@ -14,29 +13,50 @@ def __init__(self, initial_context):
         if not self._validate_context(initial_context):
             raise AttributeError()                
 
+        self._api_key = initial_context.get("SdkKey")
+        self._config = {}
+        if initial_context.get("ConfigOptions") != None:
+            self._config = initial_context.get("ConfigOptions")
+        
+        self._ready_block_time = 10
+        if initial_context.get("ReadyBlockTime") != None:
+            self._ready_block_time = initial_context.get("ReadyBlockTime")
+
+        if initial_context.get("ThreadingMode") != None:
+            self._threading_mode = initial_context.get("ThreadingMode")
+            if self._threading_mode == "asyncio":
+                self._initial_context = initial_context
+                return
+
         if initial_context.get("SplitClient") != None:
             self.split_client = initial_context.get("SplitClient")
             self._factory = self.split_client._factory
             return
-
-        api_key = initial_context.get("SdkKey")
-        config = {}
-        if initial_context.get("ConfigOptions") != None:
-            config = initial_context.get("ConfigOptions")
         
-        self._factory = get_factory(api_key, config=config)
-        ready_block_time = 10
-        if initial_context.get("ReadyBlockTime") != None:
-            ready_block_time = initial_context.get("ReadyBlockTime")
+        try:
+            self._factory = get_factory(self._api_key, config=self._config)
+            self._factory.block_until_ready(self._ready_block_time)
+            self.sdk_ready = True
+        except TimeoutException:
+            _LOGGER.debug("Split SDK timed out")
+            
+        self.split_client = self._factory.client()
+        
+    async def create(self):
+        if self._initial_context.get("SplitClient") != None:
+            self.split_client = self._initial_context.get("SplitClient")
+            self._factory = self.split_client._factory
+            return
         
         try:
-            self._factory.block_until_ready(ready_block_time)
+            self._factory = await get_factory_async(self._api_key, config=self._config)
+            await self._factory.block_until_ready(self._ready_block_time)
             self.sdk_ready = True
         except TimeoutException:
             _LOGGER.debug("Split SDK timed out")
             
         self.split_client = self._factory.client()
-
+        
     def is_sdk_ready(self):
         if self.sdk_ready:
             return True
@@ -48,6 +68,18 @@ def is_sdk_ready(self):
             _LOGGER.debug("Split SDK timed out")
         
         return self.sdk_ready
+
+    async def is_sdk_ready_async(self):
+        if self.sdk_ready:
+            return True
+        
+        try:
+            await self._factory.block_until_ready(0.1)
+            self.sdk_ready = True
+        except TimeoutException:
+            _LOGGER.debug("Split SDK timed out")
+        
+        return self.sdk_ready
         
     def _validate_context(self, initial_context):
         if initial_context != None and not isinstance(initial_context, dict):
diff --git a/split_openfeature/split_provider.py b/split_openfeature/split_provider.py
@@ -11,37 +11,14 @@
 
 _LOGGER = logging.getLogger(__name__)
 
-class SplitProvider(AbstractProvider):
-
-    def __init__(self, initial_context):
-        self._split_client_wrapper = SplitClientWrapper(initial_context)
+class SplitProviderBase(AbstractProvider):
 
     def get_metadata(self) -> Metadata:
         return Metadata("Split")
 
     def get_provider_hooks(self) -> typing.List[Hook]:
         return []
 
-    def resolve_boolean_details(self, flag_key: str, default_value: bool,
-                                evaluation_context: EvaluationContext = EvaluationContext()):
-        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
-
-    def resolve_string_details(self, flag_key: str, default_value: str,
-                               evaluation_context: EvaluationContext = EvaluationContext()):
-        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
-
-    def resolve_integer_details(self, flag_key: str, default_value: int,
-                                evaluation_context: EvaluationContext = EvaluationContext()):
-        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
-
-    def resolve_float_details(self, flag_key: str, default_value: float,
-                              evaluation_context: EvaluationContext = EvaluationContext()):
-        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
-
-    def resolve_object_details(self, flag_key: str, default_value: dict,
-                               evaluation_context: EvaluationContext = EvaluationContext()):
-        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
-
     def _evaluate_treatment(self, key: str, evaluation_context: EvaluationContext, default_value):
         if evaluation_context is None:
             raise GeneralError("Evaluation Context must be provided for the Split Provider")
@@ -54,9 +31,12 @@ def _evaluate_treatment(self, key: str, evaluation_context: EvaluationContext, d
         if not targeting_key:
             raise TargetingKeyMissingError("Missing targeting key")
 
+        attributes = SplitProvider.transform_context(evaluation_context)
+        evaluated = self._split_client_wrapper.split_client.get_treatment_with_config(targeting_key, key, attributes)
+        return self._process_treatment(evaluated, default_value)
+
+    def _process_treatment(self, evaluated, default_value):
         try:
-            attributes = SplitProvider.transform_context(evaluation_context)
-            evaluated = self._split_client_wrapper.split_client.get_treatment_with_config(targeting_key, key, attributes)
             treatment = None
             config = None
             if evaluated != None:
@@ -116,3 +96,111 @@ def construct_flag_resolution(value, variant, config, reason: Reason = Reason.TA
                                   error_code: ErrorCode = None):
         return FlagResolutionDetails(value=value, error_code=error_code, reason=reason, variant=variant, 
                                      flag_metadata={"config": config})
+
+    def resolve_boolean_details(self, flag_key: str, default_value: bool,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+    
+    def resolve_string_details(self, flag_key: str, default_value: str,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+
+    def resolve_integer_details(self, flag_key: str, default_value: int,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+
+    def resolve_float_details(self, flag_key: str, default_value: float,
+                              evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+
+    def resolve_object_details(self, flag_key: str, default_value: dict,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+
+    async def resolve_boolean_details_async(self, flag_key: str, default_value: bool,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+
+    async def resolve_string_details_async(self, flag_key: str, default_value: str,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+    async def resolve_integer_details_async(self, flag_key: str, default_value: int,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+    
+    async def resolve_float_details_async(self, flag_key: str, default_value: float,
+                              evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+
+    async def resolve_object_details_async(self, flag_key: str, default_value: dict,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        pass
+
+class SplitProvider(SplitProviderBase):
+    def __init__(self, initial_context):
+        self._split_client_wrapper = SplitClientWrapper(initial_context)
+
+    def resolve_boolean_details(self, flag_key: str, default_value: bool,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
+
+    def resolve_string_details(self, flag_key: str, default_value: str,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
+
+    def resolve_integer_details(self, flag_key: str, default_value: int,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
+
+    def resolve_float_details(self, flag_key: str, default_value: float,
+                              evaluation_context: EvaluationContext = EvaluationContext()):
+        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
+
+    def resolve_object_details(self, flag_key: str, default_value: dict,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        return self._evaluate_treatment(flag_key, evaluation_context, default_value)
+
+class SplitProviderAsync(SplitProviderBase):
+    def __init__(self, initial_context):
+        if isinstance(initial_context, dict):
+            initial_context["ThreadingMode"] = "asyncio"
+        self._split_client_wrapper = SplitClientWrapper(initial_context)
+
+    async def create(self):
+        await self._split_client_wrapper.create()
+        
+    async def resolve_boolean_details_async(self, flag_key: str, default_value: bool,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value)
+
+    async def resolve_string_details_async(self, flag_key: str, default_value: str,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value)
+
+    async def resolve_integer_details_async(self, flag_key: str, default_value: int,
+                                evaluation_context: EvaluationContext = EvaluationContext()):
+        return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value)
+
+    async def resolve_float_details_async(self, flag_key: str, default_value: float,
+                              evaluation_context: EvaluationContext = EvaluationContext()):
+        return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value)
+
+    async def resolve_object_details_async(self, flag_key: str, default_value: dict,
+                               evaluation_context: EvaluationContext = EvaluationContext()):
+        return await self._evaluate_treatment_async(flag_key, evaluation_context, default_value)
+
+    async def _evaluate_treatment_async(self, key: str, evaluation_context: EvaluationContext, default_value):
+        if evaluation_context is None:
+            raise GeneralError("Evaluation Context must be provided for the Split Provider")
+
+        if not await self._split_client_wrapper.is_sdk_ready_async():
+            return SplitProvider.construct_flag_resolution(default_value, None, None, Reason.ERROR,
+                                                               ErrorCode.PROVIDER_NOT_READY)
+        
+        targeting_key = evaluation_context.targeting_key
+        if not targeting_key:
+            raise TargetingKeyMissingError("Missing targeting key")
+
+        attributes = SplitProvider.transform_context(evaluation_context)
+        evaluated = await self._split_client_wrapper.split_client.get_treatment_with_config(targeting_key, key, attributes)
+        return self._process_treatment(evaluated, default_value)
diff --git a/tests/test_split_client_wrapper.py b/tests/test_split_client_wrapper.py
@@ -1,10 +1,10 @@
 import pytest
-from splitio import get_factory
-from split_openfeature import SplitClientWrapper
 import unittest
 
-class TestSplitClientWrapper(unittest.TestCase):
+from splitio import get_factory, get_factory_async
+from split_openfeature import SplitClientWrapper
 
+class TestSplitClientWrapper(unittest.TestCase):
     def test_using_external_splitclient(self):
         split_factory = get_factory("localhost", config={"splitFile": "split.yaml"})
         split_factory.block_until_ready(5)
@@ -19,7 +19,6 @@ def test_using_internal_splitclient(self):
         assert wrapper.is_sdk_ready()
         assert wrapper.sdk_ready == 1
 
-
     def test_sdk_not_ready(self):
         wrapper = SplitClientWrapper({"ReadyBlockTime": 0.1, "SdkKey": "api", "ConfigOptions": {}})        
         assert not wrapper.is_sdk_ready()
@@ -39,3 +38,28 @@ def test_no_params(self):
     def test_reqwuired_params(self):
         with self.assertRaises(AttributeError) as context:
             wrapper = SplitClientWrapper({"ConfigOptions": {}})
+
+class TestSplitClientWrapperAsync(object):
+    @pytest.mark.asyncio
+    async def test_using_external_splitclient_async(self):
+        split_factory = await get_factory_async("localhost", config={"splitFile": "split.yaml"})
+        await split_factory.block_until_ready(5)
+        split_client = split_factory.client()
+        wrapper = SplitClientWrapper({"SplitClient": split_client, "ThreadingMode": "asyncio"})
+        await wrapper.create()
+        assert wrapper.split_client != None
+        assert await wrapper.is_sdk_ready_async()
+
+    @pytest.mark.asyncio
+    async def test_using_internal_splitclient_async(self):
+        wrapper = SplitClientWrapper({"ReadyBlockTime": 1, "SdkKey": "localhost", "ConfigOptions": {"splitFile": "split.yaml"}, "ThreadingMode": "asyncio"})
+        await wrapper.create()
+        assert wrapper.split_client != None
+        assert await wrapper.is_sdk_ready_async()
+        assert wrapper.sdk_ready == True
+
+    @pytest.mark.asyncio
+    async def test_sdk_not_ready_async(self):
+        wrapper = SplitClientWrapper({"ReadyBlockTime": 0.1, "SdkKey": "api", "ConfigOptions": {}, "ThreadingMode": "asyncio"})        
+        await wrapper.create()
+        assert not await wrapper.is_sdk_ready_async()
diff --git a/tests/test_split_provider.py b/tests/test_split_provider.py

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`		`-from split_openfeature.split_provider import SplitProvider`
	`1`	`+from split_openfeature.split_provider import SplitProvider, SplitProviderAsync`
`2`	`2`	`from split_openfeature.split_client_wrapper import SplitClientWrapper`
`3`	`3`