Merge pull request #1 from splitio/new_sdk_version

chillaq · web-flow · commit 9f306068defd · 2025-10-28T09:21:20.000-07:00
new sdk version
diff --git a/CHANGES.txt b/CHANGES.txt
@@ -1,2 +1,4 @@
 0.0.1
 - First release. Up to date with spec 0.5.1 and python sdk 0.0.6
+0.1.0
+- Up to date with spec 0.8.0 and python sdk 0.8.1. Using split client 10.2.0
diff --git a/README.md b/README.md
@@ -10,27 +10,27 @@ This SDK is compatible with Python 3 and higher.
 ## Getting started
 ### Pip Installation 
 ```python
-pip install split-openfeature==0.0.1
+pip install split-openfeature==1.0.0
 ```
 ### Configure it
 Below is a simple example that describes using the Split Provider. Please see the [OpenFeature Documentation](https://docs.openfeature.dev/docs/reference/concepts/evaluation-api) for details on how to use the OpenFeature SDK.
 
 ```python
-from open_feature import open_feature_api
+from openfeature import api
 from split_openfeature import SplitProvider
 
-open_feature_api.set_provider(SplitProvider(api_key="YOUR_API_KEY"))
+api.set_provider(SplitProvider(api_key="YOUR_API_KEY"))
 ```
 
 If you are more familiar with Split or want access to other initialization options, you can provide a Split `client` to the constructor. See the [Split Java SDK Documentation](https://help.split.io/hc/en-us/articles/360020405151-Java-SDK) for more information.
 ```python
-from open_feature import open_feature_api
+from openfeature import api
 from split_openfeature import SplitProvider
 from splitio import get_factory
 
 factory = get_factory("YOUR_API_KEY", config=config_file)
 factory.block_until_ready(5)
-open_feature_api.set_provider(SplitProvider(client=factory.client()))
+api.set_provider(SplitProvider(client=factory.client()))
 ```
 where config_file is the Split config file you want to use
 
@@ -39,10 +39,10 @@ After the initial setup you can use OpenFeature according to their [documentatio
 
 One important note is that the Split Provider **requires a targeting key** to be set. Often times this should be set when evaluating the value of a flag by [setting an EvaluationContext](https://docs.openfeature.dev/docs/reference/concepts/evaluation-context) which contains the targeting key. An example flag evaluation is
 ```python
-from open_feature import open_feature_api
-from open_feature.evaluation_context.evaluation_context import EvaluationContext
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
 
-client = open_feature_api.get_client("CLIENT_NAME")
+client = api.get_client("CLIENT_NAME")
 
 context = EvaluationContext(targeting_key="TARGETING_KEY")
 value = client.get_boolean_value("FLAG_NAME", False, context)
@@ -54,10 +54,8 @@ client.context = context
 ```
 or at the OpenFeatureAPI level 
 ```python
-from open_feature.open_feature_evaluation_context import set_api_evaluation_context
-
 context = EvaluationContext(targeting_key="TARGETING_KEY")
-set_api_evaluation_context(context)
+api.set_evaluation_context(context)
 ````
 If the context was set at the client or api level, it is not required to provide it during flag evaluation.
 
diff --git a/requirements.txt b/requirements.txt
@@ -1,2 +1,2 @@
-openfeature_sdk==0.0.6
-splitio_client==9.1.3
+openfeature_sdk==0.8.1
+splitio_client==10.2.0
diff --git a/setup.py b/setup.py
@@ -5,7 +5,7 @@
 
 setuptools.setup(
     name="split_openfeature",
-    version="0.0.1",
+    version="0.1.0",
     author="Robert Grassian",
     author_email="robert.grassian@split.io",
     description="The official Python Split Provider for OpenFeature",
diff --git a/split_openfeature/split_provider.py b/split_openfeature/split_provider.py
@@ -1,19 +1,17 @@
 import typing
 from json import JSONDecodeError
 
-from open_feature.hooks.hook import Hook
-from open_feature.provider import provider
-from open_feature.evaluation_context.evaluation_context import EvaluationContext
-from open_feature.exception import exceptions
-from open_feature.exception.error_code import ErrorCode
-from open_feature.flag_evaluation.reason import Reason
-from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails
+from openfeature.hook import Hook
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import ErrorCode, GeneralError, ParseError, OpenFeatureError, TargetingKeyMissingError
+from openfeature.flag_evaluation import Reason, FlagResolutionDetails
+from openfeature.provider import AbstractProvider, Metadata
 from splitio import get_factory
 from splitio.exceptions import TimeoutException
 import json
 
 
-class SplitProvider(provider.AbstractProvider):
+class SplitProvider(AbstractProvider):
 
     def __init__(self, api_key="", client=None):
         if api_key == "" and client is None:
@@ -23,13 +21,13 @@ def __init__(self, api_key="", client=None):
             try:
                 factory.block_until_ready(1)
             except TimeoutException:
-                raise exceptions.GeneralError("Error occurred initializing the client.")
+                raise GeneralError("Error occurred initializing the client.")
             self.split_client = factory.client()
         else:
             self.split_client = client
 
-    def get_metadata(self) -> provider.Metadata:
-        return provider.Metadata("Split")
+    def get_metadata(self) -> Metadata:
+        return Metadata("Split")
 
     def get_provider_hooks(self) -> typing.List[Hook]:
         return []
@@ -39,93 +37,93 @@ def resolve_boolean_details(self, flag_key: str, default_value: bool,
         try:
             evaluated = self.evaluate_treatment(flag_key, evaluation_context)
             if SplitProvider.no_treatment(evaluated):
-                return SplitProvider.construct_provider_evaluation(flag_key, default_value, evaluated, Reason.DEFAULT,
-                                                                   ErrorCode.FLAG_NOT_FOUND)
+                return SplitProvider.construct_flag_resolution(default_value, evaluated, Reason.DEFAULT,
+                                                               ErrorCode.FLAG_NOT_FOUND)
             evaluated_lower = evaluated.lower()
             if evaluated_lower in ["true", "on"]:
                 value = True
             elif evaluated_lower in ["false", "off"]:
                 value = False
             else:
-                raise exceptions.ParseError("Could not convert treatment to boolean")
-            return SplitProvider.construct_provider_evaluation(flag_key, value, evaluated)
-        except exceptions.OpenFeatureError:
+                raise ParseError("Could not convert treatment to boolean")
+            return SplitProvider.construct_flag_resolution(value, evaluated)
+        except OpenFeatureError:
             raise
         except Exception:
-            raise exceptions.GeneralError("Error getting boolean evaluation")
+            raise GeneralError("Error getting boolean evaluation")
 
     def resolve_string_details(self, flag_key: str, default_value: str,
                                evaluation_context: EvaluationContext = EvaluationContext()):
         try:
             evaluated = self.evaluate_treatment(flag_key, evaluation_context)
             if SplitProvider.no_treatment(evaluated):
-                return SplitProvider.construct_provider_evaluation(flag_key, default_value, evaluated, Reason.DEFAULT,
-                                                                   ErrorCode.FLAG_NOT_FOUND)
-            return SplitProvider.construct_provider_evaluation(flag_key, evaluated, evaluated)
-        except exceptions.OpenFeatureError:
+                return SplitProvider.construct_flag_resolution(default_value, evaluated, Reason.DEFAULT,
+                                                               ErrorCode.FLAG_NOT_FOUND)
+            return SplitProvider.construct_flag_resolution(evaluated, evaluated)
+        except OpenFeatureError:
             raise
         except Exception:
-            raise exceptions.GeneralError("Error getting boolean evaluation")
+            raise GeneralError("Error getting boolean evaluation")
 
     def resolve_integer_details(self, flag_key: str, default_value: int,
                                 evaluation_context: EvaluationContext = EvaluationContext()):
         try:
             evaluated = self.evaluate_treatment(flag_key, evaluation_context)
             if SplitProvider.no_treatment(evaluated):
-                return SplitProvider.construct_provider_evaluation(flag_key, default_value, evaluated, Reason.DEFAULT,
-                                                                   ErrorCode.FLAG_NOT_FOUND)
+                return SplitProvider.construct_flag_resolution(default_value, evaluated, Reason.DEFAULT,
+                                                               ErrorCode.FLAG_NOT_FOUND)
             try:
                 value = int(evaluated)
             except ValueError:
-                raise exceptions.ParseError("Could not convert treatment to integer")
-            return SplitProvider.construct_provider_evaluation(flag_key, value, evaluated)
-        except exceptions.OpenFeatureError:
+                raise ParseError("Could not convert treatment to integer")
+            return SplitProvider.construct_flag_resolution(value, evaluated)
+        except OpenFeatureError:
             raise
         except Exception:
-            raise exceptions.GeneralError("Error getting boolean evaluation")
+            raise GeneralError("Error getting boolean evaluation")
 
     def resolve_float_details(self, flag_key: str, default_value: float,
                               evaluation_context: EvaluationContext = EvaluationContext()):
         try:
             evaluated = self.evaluate_treatment(flag_key, evaluation_context)
             if SplitProvider.no_treatment(evaluated):
-                return SplitProvider.construct_provider_evaluation(flag_key, default_value, evaluated, Reason.DEFAULT,
-                                                                   ErrorCode.FLAG_NOT_FOUND)
+                return SplitProvider.construct_flag_resolution(default_value, evaluated, Reason.DEFAULT,
+                                                               ErrorCode.FLAG_NOT_FOUND)
             try:
                 value = float(evaluated)
             except ValueError:
-                raise exceptions.ParseError("Could not convert treatment to float")
-            return SplitProvider.construct_provider_evaluation(flag_key, value, evaluated)
-        except exceptions.OpenFeatureError:
+                raise ParseError("Could not convert treatment to float")
+            return SplitProvider.construct_flag_resolution(value, evaluated)
+        except OpenFeatureError:
             raise
         except Exception:
-            raise exceptions.GeneralError("Error getting boolean evaluation")
+            raise GeneralError("Error getting boolean evaluation")
 
     def resolve_object_details(self, flag_key: str, default_value: dict,
                                evaluation_context: EvaluationContext = EvaluationContext()):
         try:
             evaluated = self.evaluate_treatment(flag_key, evaluation_context)
             if SplitProvider.no_treatment(evaluated):
-                return SplitProvider.construct_provider_evaluation(flag_key, default_value, evaluated, Reason.DEFAULT,
-                                                                   ErrorCode.FLAG_NOT_FOUND)
+                return SplitProvider.construct_flag_resolution(default_value, evaluated, Reason.DEFAULT,
+                                                               ErrorCode.FLAG_NOT_FOUND)
             value = json.loads(evaluated)
-            return SplitProvider.construct_provider_evaluation(flag_key, value, evaluated)
+            return SplitProvider.construct_flag_resolution(value, evaluated)
         except JSONDecodeError:
-            raise exceptions.ParseError("Could not convert treatment to dict")
-        except exceptions.OpenFeatureError:
+            raise ParseError("Could not convert treatment to dict")
+        except OpenFeatureError:
             raise
         except Exception:
-            raise exceptions.GeneralError("Error getting boolean evaluation")
+            raise GeneralError("Error getting boolean evaluation")
 
     # *** --- Helpers --- ***
 
     def evaluate_treatment(self, key: str, evaluation_context: EvaluationContext):
         if evaluation_context is None:
-            raise exceptions.GeneralError("Evaluation Context must be provided for the Split Provider")
+            raise GeneralError("Evaluation Context must be provided for the Split Provider")
 
         targeting_key = evaluation_context.targeting_key
         if not targeting_key:
-            raise exceptions.TargetingKeyMissingError("Missing targeting key")
+            raise TargetingKeyMissingError("Missing targeting key")
 
         attributes = SplitProvider.transform_context(evaluation_context)
         return self.split_client.get_treatment(targeting_key, key, attributes)
@@ -139,7 +137,6 @@ def no_treatment(treatment: str):
         return not treatment or treatment == "control"
 
     @staticmethod
-    def construct_provider_evaluation(key: str, value, variant: str, reason: Reason = Reason.TARGETING_MATCH,
-                                      error_code: ErrorCode = None):
-        return FlagEvaluationDetails(flag_key=key, value=value, reason=reason,
-                                     error_code=error_code, variant=variant)
+    def construct_flag_resolution(value, variant: str, reason: Reason = Reason.TARGETING_MATCH,
+                                  error_code: ErrorCode = None):
+        return FlagResolutionDetails(value=value, error_code=error_code, reason=reason, variant=variant)
diff --git a/tests/test_client.py b/tests/test_client.py
@@ -1,8 +1,8 @@
 import pytest
-from open_feature import open_feature_api
-from open_feature.evaluation_context.evaluation_context import EvaluationContext
-from open_feature.exception.error_code import ErrorCode
-from open_feature.flag_evaluation.reason import Reason
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import ErrorCode
+from openfeature.flag_evaluation import Reason
 from splitio import get_factory
 from split_openfeature import SplitProvider
 
@@ -18,17 +18,18 @@ class TestClient(object):
 
     @pytest.fixture
     def provider(self):
-        factory = get_factory("localhost", config={"splitFile": "split.yaml"})
-        factory.block_until_ready(5)
-        return SplitProvider(client=factory.client())
+        split_factory = get_factory("localhost", config={"splitFile": "split.yaml"})
+        split_factory.block_until_ready(5)
+        split_client = split_factory.client()
+        return SplitProvider(client=split_client)
 
     @pytest.fixture
     def set_provider(self, provider):
-        open_feature_api.set_provider(provider)
+        api.set_provider(provider)
 
     @pytest.fixture
     def client(self, set_provider):
-        return open_feature_api.get_client("Split Client")
+        return api.get_client()
 
     @pytest.fixture(autouse=True)
     def targeting_key(self, client):
@@ -108,7 +109,7 @@ def test_obj_split(self, client):
         assert result == {"key": "value"}
 
     def test_get_metadata(self):
-        assert open_feature_api.get_provider().get_metadata().name == "Split"
+        assert api.get_provider_metadata().name == "Split"
 
     def test_boolean_details(self, client):
         details = client.get_boolean_details(self.some_other_feature, True)
diff --git a/tests/test_split_provider.py b/tests/test_split_provider.py
@@ -1,8 +1,7 @@
 from pytest import fail
 from mock import MagicMock
-from open_feature.exception import exceptions
-from open_feature.exception.error_code import ErrorCode
-from open_feature.evaluation_context.evaluation_context import EvaluationContext
+from openfeature.exception import ErrorCode, OpenFeatureError
+from openfeature.evaluation_context import EvaluationContext
 from split_openfeature import SplitProvider
 
 
@@ -75,7 +74,7 @@ def test_boolean_error(self):
         try:
             self.provider.resolve_boolean_details(self.flag_name, False, self.eval_context)
             fail("Should have thrown an error casting string to boolean")
-        except exceptions.OpenFeatureError as e:
+        except OpenFeatureError as e:
             assert e.error_code == ErrorCode.PARSE_ERROR
         except Exception:
             fail("Unexpected exception occurred")
@@ -150,7 +149,7 @@ def test_int_error(self):
         try:
             self.provider.resolve_integer_details(self.flag_name, 100, self.eval_context)
             fail("Should have thrown an exception casting string to num")
-        except exceptions.OpenFeatureError as e:
+        except OpenFeatureError as e:
             assert e.error_code == ErrorCode.PARSE_ERROR
         except Exception:
             fail("Unexpected exception occurred")
@@ -159,7 +158,7 @@ def test_int_error(self):
         try:
             self.provider.resolve_integer_details(self.flag_name, 100, self.eval_context)
             fail("Should have thrown an exception casting string to int")
-        except exceptions.OpenFeatureError as e:
+        except OpenFeatureError as e:
             assert e.error_code == ErrorCode.PARSE_ERROR
         except Exception:
             fail("Unexpected exception occurred")
@@ -207,7 +206,7 @@ def test_float_error(self):
         try:
             self.provider.resolve_float_details(self.flag_name, 100.5, self.eval_context)
             fail("Should have thrown an exception casting string to float")
-        except exceptions.OpenFeatureError as e:
+        except OpenFeatureError as e:
             assert e.error_code == ErrorCode.PARSE_ERROR
         except Exception:
             fail("Unexpected exception occurred")
@@ -255,7 +254,7 @@ def test_obj_error(self):
         try:
             self.provider.resolve_object_details(self.flag_name, {"foo": "bar"}, self.eval_context)
             fail("Should have thrown an exception casting string to an object")
-        except exceptions.OpenFeatureError as e:
+        except OpenFeatureError as e:
             assert e.error_code == ErrorCode.PARSE_ERROR
         except Exception:
             fail("Unexpected exception occurred")

-Original file line number
+Diff line change
@@ @@ -1,2 +1,4 @@ @@
 .0.1
 - First release. Up to date with spec 0.5.1 and python sdk 0.0.6
 +0.1.0
 +- Up to date with spec 0.8.0 and python sdk 0.8.1. Using split client 10.2.0