devcycle-python-server-sdk 3.3.6__py3-none-any.whl → 3.5.0__py3-none-any.whl

devcycle_python_sdk/VERSION.txt

@@ -1 +1 @@
-3.3.6
+3.5.0

devcycle_python_sdk/__init__.py

@@ -1,5 +1,6 @@
 # Simplify imports for the SDK entry point objects
 
 from devcycle_python_sdk.options import DevCycleCloudOptions, DevCycleLocalOptions
+from devcycle_python_sdk.devcycle_client import AbstractDevCycleClient
 from devcycle_python_sdk.cloud_client import DevCycleCloudClient
 from devcycle_python_sdk.local_client import DevCycleLocalClient

devcycle_python_sdk/cloud_client.py

@@ -3,7 +3,7 @@ import platform
 
 from typing import Any, Dict
 
-from devcycle_python_sdk import DevCycleCloudOptions
+from devcycle_python_sdk import DevCycleCloudOptions, AbstractDevCycleClient
 from devcycle_python_sdk.api.bucketing_client import BucketingAPIClient
 from devcycle_python_sdk.exceptions import (
     NotFoundError,
@@ -14,11 +14,18 @@ from devcycle_python_sdk.models.event import DevCycleEvent
 from devcycle_python_sdk.models.variable import Variable
 from devcycle_python_sdk.models.feature import Feature
 from devcycle_python_sdk.util.version import sdk_version
+from devcycle_python_sdk.open_feature_provider.provider import DevCycleProvider
+
+from openfeature.provider import AbstractProvider
 
 logger = logging.getLogger(__name__)
 
 
-class DevCycleCloudClient:
+class DevCycleCloudClient(AbstractDevCycleClient):
+    """
+    The DevCycle Python SDK that utilizes the DevCycle Bucketing API for feature and variable evaluation
+    """
+
     options: DevCycleCloudOptions
     platform: str
     platform_version: str
@@ -37,6 +44,13 @@ class DevCycleCloudClient:
         self.sdk_version = sdk_version()
         self.sdk_type = "server"
         self.bucketing_api = BucketingAPIClient(sdk_key, self.options)
+        self._openfeature_provider = DevCycleProvider(self)
+
+    def get_sdk_platform(self) -> str:
+        return "Cloud"
+
+    def get_openfeature_provider(self) -> AbstractProvider:
+        return self._openfeature_provider
 
     def _add_platform_data_to_user(self, user: DevCycleUser) -> DevCycleUser:
         user.platform = self.platform
@@ -45,6 +59,9 @@ class DevCycleCloudClient:
         user.sdkType = self.sdk_type
         return user
 
+    def is_initialized(self) -> bool:
+        return True
+
     def variable_value(self, user: DevCycleUser, key: str, default_value: Any) -> Any:
         """
         Evaluates a variable for a user and returns the value.  If the user is not bucketed into the variable, the default value will be returned

devcycle_python_sdk/devcycle_client.py

@@ -0,0 +1,40 @@
+import typing
+from abc import abstractmethod
+
+from devcycle_python_sdk.models.user import DevCycleUser
+from devcycle_python_sdk.models.variable import Variable
+
+from openfeature.provider import AbstractProvider
+
+
+class AbstractDevCycleClient:
+    """
+    A common interface for all DevCycle Clients
+    """
+
+    @abstractmethod
+    def is_initialized(self) -> bool:
+        pass
+
+    @abstractmethod
+    def variable(
+        self, user: DevCycleUser, key: str, default_value: typing.Any
+    ) -> Variable:
+        pass
+
+    @abstractmethod
+    def variable_value(
+        self, user: DevCycleUser, key: str, default_value: typing.Any
+    ) -> typing.Any:
+        pass
+
+    @abstractmethod
+    def get_openfeature_provider(self) -> AbstractProvider:
+        """
+        Returns the OpenFeature provider for this client
+        """
+        pass
+
+    @abstractmethod
+    def get_sdk_platform(self) -> str:
+        pass

devcycle_python_sdk/local_client.py

@@ -3,7 +3,7 @@ import logging
 from numbers import Real
 from typing import Any, Dict, Union
 
-from devcycle_python_sdk import DevCycleLocalOptions
+from devcycle_python_sdk import DevCycleLocalOptions, AbstractDevCycleClient
 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
@@ -14,11 +14,17 @@ from devcycle_python_sdk.models.feature import Feature
 from devcycle_python_sdk.models.platform_data import default_platform_data
 from devcycle_python_sdk.models.user import DevCycleUser
 from devcycle_python_sdk.models.variable import Variable
+from devcycle_python_sdk.open_feature_provider.provider import DevCycleProvider
+from openfeature.provider import AbstractProvider
 
 logger = logging.getLogger(__name__)
 
 
-class DevCycleLocalClient:
+class DevCycleLocalClient(AbstractDevCycleClient):
+    """
+    The DevCycle Python SDK that utilizes the local bucketing library for feature and variable evaluation
+    """
+
     def __init__(self, sdk_key: str, options: DevCycleLocalOptions):
         _validate_sdk_key(sdk_key)
         self._sdk_key = sdk_key
@@ -42,6 +48,14 @@ class DevCycleLocalClient:
             sdk_key, self.options, self.local_bucketing
         )
 
+        self._openfeature_provider = DevCycleProvider(self)
+
+    def get_sdk_platform(self) -> str:
+        return "Local"
+
+    def get_openfeature_provider(self) -> AbstractProvider:
+        return self._openfeature_provider
+
     def is_initialized(self) -> bool:
         return self.config_manager.is_initialized()
 

devcycle_python_sdk/models/bucketed_config.py

@@ -55,6 +55,7 @@ class OptInSettings:
 class ProjectSettings:
     edge_db: Optional[EdgeDBSettings]
     opt_in: Optional[OptInSettings]
+    disable_passthrough_rollouts: Optional[bool]
 
     @classmethod
     def from_json(cls, data: dict) -> "ProjectSettings":
@@ -63,6 +64,7 @@ class ProjectSettings:
             if "edgeDB" in data
             else None,
             opt_in=OptInSettings.from_json(data["optIn"]) if "optIn" in data else None,
+            disable_passthrough_rollouts=data.get("disablePassthroughRollouts", False),
         )
 
 

devcycle_python_sdk/models/user.py

@@ -1,7 +1,9 @@
 # ruff: noqa: N815
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Dict, Optional
+from typing import Dict, Optional, Any
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import TargetingKeyMissingError, InvalidContextError
 
 
 @dataclass(order=False)
@@ -13,9 +15,9 @@ class DevCycleUser:
     country: Optional[str] = None
     appVersion: Optional[str] = None
     appBuild: Optional[str] = None
-    customData: Optional[Dict[str, str]] = None
+    customData: Optional[Dict[str, Any]] = None
     createdDate: datetime = field(default_factory=lambda: datetime.utcnow())
-    privateCustomData: Optional[Dict[str, str]] = None
+    privateCustomData: Optional[Dict[str, Any]] = None
     lastSeenDate: Optional[datetime] = None
     platform: Optional[str] = None
     platformVersion: Optional[str] = None
@@ -74,3 +76,84 @@ class DevCycleUser:
             sdkType=data.get("sdkType"),
             sdkVersion=data.get("sdkVersion"),
         )
+
+    @staticmethod
+    def _set_custom_value(custom_data: Dict[str, Any], key: str, value: Optional[Any]):
+        """
+        Sets a custom value in the custom data dictionary.  Custom data properties can
+        only be strings, numbers, or booleans.  Nested dictionaries and lists are
+        not permitted.
+
+        Invalid values will generate an error
+        """
+        if key and (value is None or isinstance(value, (str, int, float, bool))):
+            custom_data[key] = value
+        else:
+            raise InvalidContextError(
+                "Custom property values must be strings, numbers, booleans or None"
+            )
+
+    @staticmethod
+    def create_user_from_context(
+        context: Optional[EvaluationContext],
+    ) -> "DevCycleUser":
+        """
+        Builds a DevCycleUser instance from the evaluation context. Will raise a TargetingKeyMissingError if
+        the context does not contain a valid targeting key or user_id attribute
+
+        :param context: The evaluation context to build the user from
+        :return: A DevCycleUser instance
+        """
+        user_id = None
+
+        if context:
+            if context.targeting_key:
+                user_id = context.targeting_key
+            elif context.attributes and "user_id" in context.attributes.keys():
+                user_id = context.attributes["user_id"]
+
+        if not user_id or not isinstance(user_id, str):
+            raise TargetingKeyMissingError(
+                "DevCycle: Evaluation context does not contain a valid targeting key or user_id attribute"
+            )
+
+        user = DevCycleUser(user_id=user_id)
+        custom_data: Dict[str, Any] = {}
+        private_custom_data: Dict[str, Any] = {}
+        if context and context.attributes:
+            for key, value in context.attributes.items():
+                if key == "user_id":
+                    continue
+
+                if value:
+                    if key == "email" and isinstance(value, str):
+                        user.email = value
+                    elif key == "name" and isinstance(value, str):
+                        user.name = value
+                    elif key == "language" and isinstance(value, str):
+                        user.language = value
+                    elif key == "country" and isinstance(value, str):
+                        user.country = value
+                    elif key == "appVersion" and isinstance(value, str):
+                        user.appVersion = value
+                    elif key == "appBuild" and isinstance(value, str):
+                        user.appBuild = value
+                    elif key == "deviceModel" and isinstance(value, str):
+                        user.deviceModel = value
+                    elif key == "customData" and isinstance(value, dict):
+                        for k, v in value.items():
+                            DevCycleUser._set_custom_value(custom_data, k, v)
+                    elif key == "privateCustomData" and isinstance(value, dict):
+                        for k, v in value.items():
+                            DevCycleUser._set_custom_value(private_custom_data, k, v)
+                    else:
+                        # unrecognized keys are just added to public custom data
+                        DevCycleUser._set_custom_value(custom_data, key, value)
+
+        if custom_data:
+            user.customData = custom_data
+
+        if private_custom_data:
+            user.privateCustomData = private_custom_data
+
+        return user

devcycle_python_sdk/open_feature_provider/provider.py

@@ -0,0 +1,123 @@
+import logging
+
+from typing import Any, Optional, Union, List
+
+from devcycle_python_sdk import AbstractDevCycleClient
+from devcycle_python_sdk.models.user import DevCycleUser
+
+from openfeature.provider import AbstractProvider
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.exception import ErrorCode, InvalidContextError, TypeMismatchError
+from openfeature.hook import Hook
+from openfeature.provider.metadata import Metadata
+
+logger = logging.getLogger(__name__)
+
+
+class DevCycleProvider(AbstractProvider):
+    """
+    Openfeature provider wrapper for the DevCycle SDK.
+
+    Can be initialized with either a DevCycleLocalClient or DevCycleCloudClient instance.
+    """
+
+    def __init__(self, devcycle_client: AbstractDevCycleClient):
+        self.client = devcycle_client
+        self.meta_data = Metadata(name=f"DevCycle {self.client.get_sdk_platform()}")
+
+    def get_metadata(self) -> Metadata:
+        return self.meta_data
+
+    def get_provider_hooks(self) -> List[Hook]:
+        return []
+
+    def _resolve(
+        self,
+        flag_key: str,
+        default_value: Any,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[Any]:
+        if self.client.is_initialized():
+            try:
+                user: DevCycleUser = DevCycleUser.create_user_from_context(
+                    evaluation_context
+                )
+
+                variable = self.client.variable(
+                    key=flag_key, user=user, default_value=default_value
+                )
+
+                if variable is None:
+                    # this technically should never happen
+                    # as the DevCycle client should at least return a default Variable instance
+                    return FlagResolutionDetails(
+                        value=default_value,
+                        reason=Reason.DEFAULT,
+                    )
+                else:
+                    return FlagResolutionDetails(
+                        value=variable.value,
+                        reason=Reason.DEFAULT
+                        if variable.isDefaulted
+                        else Reason.TARGETING_MATCH,
+                    )
+            except ValueError as e:
+                # occurs if the key or default value is None
+                raise InvalidContextError(str(e))
+        else:
+            return FlagResolutionDetails(
+                value=default_value,
+                reason=Reason.ERROR,
+                error_code=ErrorCode.PROVIDER_NOT_READY,
+            )
+
+    def resolve_boolean_details(
+        self,
+        flag_key: str,
+        default_value: bool,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        flag_key: str,
+        default_value: str,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        flag_key: str,
+        default_value: int,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        flag_key: str,
+        default_value: float,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        flag_key: str,
+        default_value: Union[dict, list],
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[Union[dict, list]]:
+        if not isinstance(default_value, dict):
+            raise TypeMismatchError("Default value must be a flat dictionary")
+
+        if default_value:
+            for k, v in default_value.items():
+                if not isinstance(v, (str, int, float, bool)) or v is None:
+                    raise TypeMismatchError(
+                        "Default value must be a flat dictionary containing only strings, numbers, booleans or None values"
+                    )
+
+        return self._resolve(flag_key, default_value, evaluation_context)

{devcycle_python_server_sdk-3.3.6.dist-info → devcycle_python_server_sdk-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devcycle-python-server-sdk
-Version: 3.3.6
+Version: 3.5.0
 Summary: DevCycle Python SDK
 Home-page: https://github.com/devcycleHQ/python-server-sdk
 Author: UNKNOWN
@@ -13,6 +13,7 @@ Requires-Dist: urllib3 >=1.15.1
 Requires-Dist: requests ~=2.31.0
 Requires-Dist: wasmtime ==9.0.0
 Requires-Dist: protobuf >=4.23.3
+Requires-Dist: openfeature-sdk >=0.7.0
 
 The DevCycle Python SDK used for feature management.
 

{devcycle_python_server_sdk-3.3.6.dist-info → devcycle_python_server_sdk-3.5.0.dist-info}/RECORD

@@ -1,9 +1,10 @@
-devcycle_python_sdk/VERSION.txt,sha256=NnbsD-Jmzgwy0kLCa3npOIpV_H1Uvl9iyKC5uFowDYw,6
-devcycle_python_sdk/__init__.py,sha256=vOoglQ8L7RsHTp-GSa8g7k2AAPrR_obhiDSC09LpG8w,265
-devcycle_python_sdk/bucketing-lib.release.wasm,sha256=oNVNiF5h5YO4kejqbdogK44DVgWgwn5UJZ7KUsR9aZA,200891
-devcycle_python_sdk/cloud_client.py,sha256=wkDNwz8GFfnJybD1e96Lr41SY_2saQUTMD5gByFIbIg,6766
+devcycle_python_sdk/VERSION.txt,sha256=dhIMHyxDEcIVTCKmtY4A5BHg6-dq-uDa9gjZGWxh8RQ,6
+devcycle_python_sdk/__init__.py,sha256=30TcYb9PbvVi97gwk16omCGG1UoUI9lmmU7xpvxNMvc,336
+devcycle_python_sdk/bucketing-lib.release.wasm,sha256=yrNDrAxZS1h9VlTzsdOrNLP4ngnM04PmKxcWop1yrt4,202623
+devcycle_python_sdk/cloud_client.py,sha256=UMfXvXwO4v3pZW9ZA52ivxPH1Lp4Goy5gpV_s0qCpxQ,7352
+devcycle_python_sdk/devcycle_client.py,sha256=W5MeOslkXjTqZtoSy_Bbbug8gVoicjxshpKjDteEr6E,917
 devcycle_python_sdk/exceptions.py,sha256=Et7fS8pEFbHkFY86T2pJoEUstwjh4_rzhJxVH8fzAns,1053
-devcycle_python_sdk/local_client.py,sha256=h5NrP4-x26cz-yla7OUy4SL7VJgplUFH8Fj0jTqz2Os,8845
+devcycle_python_sdk/local_client.py,sha256=5PFEUmBs-QsgaiXWBQfhhjcN2TbB64JH3iVwpJteG7o,9373
 devcycle_python_sdk/options.py,sha256=Ejr6HbdyqzZajFVkEqWLk5XLfdtqCIkvsyWaRt_lgwU,4575
 devcycle_python_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devcycle_python_sdk/api/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -16,13 +17,15 @@ devcycle_python_sdk/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 devcycle_python_sdk/managers/config_manager.py,sha256=_-1kWwyyAcwVF_DibXjnehXi3Qj6HR8orYfgNfgWJOc,3248
 devcycle_python_sdk/managers/event_queue_manager.py,sha256=06TcdlRoB89C7vGH1UTnnoDFsSnT71tPwf0gn1NK-W0,8071
 devcycle_python_sdk/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devcycle_python_sdk/models/bucketed_config.py,sha256=rSKpxMTF-IbUVQ9gAWrWnb9Q9YF94ATqEFWNWuoQntk,3814
+devcycle_python_sdk/models/bucketed_config.py,sha256=76bdF7pgUdIAn2y8YPs3AO7Qa2eyJQ_jf4QhG3IERaE,3951
 devcycle_python_sdk/models/error_response.py,sha256=r_dRUDAbral9UGaMYcnBsZOr9Hmkyi1SQbhGmZilgpA,442
 devcycle_python_sdk/models/event.py,sha256=-6bhKp72mAgaoSxvhS__G4vvfQ9Psj83fc0Igelzw3o,3713
 devcycle_python_sdk/models/feature.py,sha256=m3wxxIjC5jxhKpPLI4RcsBaNLuy-zsMqoAgc8ySPe0I,852
 devcycle_python_sdk/models/platform_data.py,sha256=kIFevH5trsxI32qp7BW6glUCpipgpaVBKGqJWzQd5Xo,783
-devcycle_python_sdk/models/user.py,sha256=BGMtVM6shDX7rUfGfBbI55IUEsQ_4qrnmtwTqOcB-8A,2616
+devcycle_python_sdk/models/user.py,sha256=57d_n8Yy8g-zsGzVF0hmSf4McPtFPJJ0LLY_ql75FWk,6266
 devcycle_python_sdk/models/variable.py,sha256=qp00SyCNyfYiMlTwnDSDJ4ZetRF35JHTbYZQOBxFIqY,1711
+devcycle_python_sdk/open_feature_provider/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devcycle_python_sdk/open_feature_provider/provider.py,sha256=FjNxmyKrnUO4ma4c-Z39qWigLVC_P-L_Nly0mycA1Vc,4475
 devcycle_python_sdk/protobuf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devcycle_python_sdk/protobuf/utils.py,sha256=zi-kVx6yvgS2c04cUobLd2IDc_ZqKkWduay9YcpjoGc,4684
 devcycle_python_sdk/protobuf/variableForUserParams_pb2.py,sha256=Zf4-8n67UnulC0Sz90aqLYsXCFEgywOqfiSHuXZomLk,4244
@@ -31,15 +34,16 @@ devcycle_python_sdk/util/strings.py,sha256=gH0Xm3gIXNqn6hczKPk10Jn5_9knuD7OB5MrB
 devcycle_python_sdk/util/version.py,sha256=Cz7Us_EuXP-T8GI47g2WHYdBJj_zKo-5y545IDHJAjI,253
 example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 example/cloud_client_example.py,sha256=YD8ZsTv3dPYfbFUKraRpRT0VsJGrPwjm8ZCuA5H54yI,2463
-example/local_bucketing_client_example.py,sha256=zSJsllQ5aSvUTj-VFvt0w7pVTMRW6z-gTj9R7ZNPlyE,2797
+example/local_bucketing_client_example.py,sha256=TaIfy3VnW9fXii9NPYs5UOuP4fLKruXMjnZApveqzl4,2796
+example/openfeature_example.py,sha256=kO6F-Xk20l6CPiMfIxSRreshEGmHMFHRg3zbeLXa3AI,2410
 test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/test_cloud_client.py,sha256=zjk302m7qKMCQryolkc1WKLFmbGWUxA0VtHlZk0rY-0,11442
-test/test_local_client.py,sha256=mEBhq0gnHzjE-i_w4hMrmfhoHDJvCXGt3G8lx0EA9OE,12671
+test/test_local_client.py,sha256=Ds6VIfLcaefboyvGrhQTGsdJj_DGB4IVnR2_16xDpSY,13022
 test/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/api/test_bucketing_client.py,sha256=M2mjACowLvbsIjXdP-w8-fwY02xqv1X1r_h9v-pXa7A,7739
 test/api/test_config_client.py,sha256=oZMBlXGw4UHb5-rSNF_ARTrAjvbvkbFgb8GAK4ExR14,4413
 test/api/test_event_client.py,sha256=v4Xoum-PdywfczrfMV1llM5vrIJoqHybzxPLVokh09g,3310
-test/api/test_local_bucketing.py,sha256=E7alurvIScT0nilcuY2xGLCXzwxHrNWPBGdWxG6bR5A,15156
+test/api/test_local_bucketing.py,sha256=lPL3ThZcGG-8-67jFxRvGrwL8NB6-sM5qGJb0p2O__Q,15254
 test/fixture/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/fixture/data.py,sha256=6ReLxWPMhCDbJ5Ex24_iR0PJNjKzPFV1I9j_v0FVbBU,1462
 test/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,12 +51,16 @@ test/managers/test_config_manager.py,sha256=_MtvyxK06xpBzzEsN1zsLdYrk3DsPsbCmSj7
 test/managers/test_event_queue_manager.py,sha256=KquHBuYiDdoVStm5Ga9mIB-wvmJnChiFRBNC8sMKaxQ,11053
 test/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/models/test_bucketed_config.py,sha256=8wCEyxaHxY21nl7ZbiFzp-IzZQBZIPIVPPzeREjumQk,858
+test/models/test_user.py,sha256=ZNTBSKLDrqrsqZuaw5AHtc_FW4empSTaeNPZHZaFlI4,6736
+test/openfeature_test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/openfeature_test/test_provider.py,sha256=UPxAD5e7NvpIhmqNFCrTY_yrKrMyYxBc2xuMAgdSGvw,7653
+test/openfeature_test/test_provider_local_sdk.py,sha256=5NjfUDalW4F7Oe8n1740VO7l5OIBEOldnSryM98uO2w,4426
 test/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/util/test_strings.py,sha256=T5H5U0af7_ld1yJC8IdDmay_Mx-iJQ5Fi5fbvKcAc7A,862
 test/util/test_utils.py,sha256=tVBJm_qnqg-4PssLpXIxqlk0JehuiAIPs4zpi2oNVnY,6671
-test/util/test_version.py,sha256=lx0HFefK_I5D35bmjEc7t5_6oYB4LBWnG-zxqCz1lV4,343
-devcycle_python_server_sdk-3.3.6.dist-info/LICENSE,sha256=tHQMqu-Jic2UpMGqb-vNFbGygysl8IG4l1clnnh0OFo,1071
-devcycle_python_server_sdk-3.3.6.dist-info/METADATA,sha256=r-YR9iEwUiLS5koBavumhlUhjc41IZ8X4di9iYUiwmw,471
-devcycle_python_server_sdk-3.3.6.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-devcycle_python_server_sdk-3.3.6.dist-info/top_level.txt,sha256=34f8zDzihAHoH7siAFlmscyO_QLNWWq9HApFlwtYL4k,33
-devcycle_python_server_sdk-3.3.6.dist-info/RECORD,,
+test/util/test_version.py,sha256=3Xg0_84m0bdHXz6pxd2Z85Oz9DoUC1T0Ol_WqEH_jac,335
+devcycle_python_server_sdk-3.5.0.dist-info/LICENSE,sha256=tHQMqu-Jic2UpMGqb-vNFbGygysl8IG4l1clnnh0OFo,1071
+devcycle_python_server_sdk-3.5.0.dist-info/METADATA,sha256=IAUJWGuZDWtOoCfJ6Tj6aKURxJODAtUuutO1g94hLho,510
+devcycle_python_server_sdk-3.5.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+devcycle_python_server_sdk-3.5.0.dist-info/top_level.txt,sha256=34f8zDzihAHoH7siAFlmscyO_QLNWWq9HApFlwtYL4k,33
+devcycle_python_server_sdk-3.5.0.dist-info/RECORD,,

{devcycle_python_server_sdk-3.3.6.dist-info → devcycle_python_server_sdk-3.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

example/local_bucketing_client_example.py

@@ -7,7 +7,7 @@ from devcycle_python_sdk import DevCycleLocalClient, DevCycleLocalOptions
 from devcycle_python_sdk.models.user import DevCycleUser
 from devcycle_python_sdk.models.event import DevCycleEvent, EventType
 
-VARIABLE_KEY = "test-boolean-variable"
+VARIABLE_KEY = "python-example-tests"
 
 logger = logging.getLogger(__name__)
 

example/openfeature_example.py

@@ -0,0 +1,77 @@
+import logging
+import time
+import os
+
+from devcycle_python_sdk import DevCycleLocalClient, DevCycleLocalOptions
+
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+
+FLAG_KEY = "test-boolean-variable"
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """
+    Sample usage of the DevCycle OpenFeature Provider along with the Python Server SDK using Local Bucketing.
+    """
+    logging.basicConfig(level="INFO", format="%(levelname)s: %(message)s")
+
+    # create an instance of the DevCycle Client object
+    server_sdk_key = os.environ["DEVCYCLE_SERVER_SDK_KEY"]
+    devcycle_client = DevCycleLocalClient(server_sdk_key, DevCycleLocalOptions())
+
+    # Wait for DevCycle to initialize and load the configuration
+    for i in range(10):
+        if devcycle_client.is_initialized():
+            break
+        logger.info("Waiting for DevCycle to initialize...")
+        time.sleep(0.5)
+    else:
+        logger.error("DevCycle failed to initialize")
+        exit(1)
+
+    # set the provider for OpenFeature
+    api.set_provider(devcycle_client.get_openfeature_provider())
+
+    # get the OpenFeature client
+    open_feature_client = api.get_client()
+
+    # create the request context for the user
+    context = EvaluationContext(
+        targeting_key="test-1234",
+        attributes={
+            "email": "test-user@domain.com",
+            "name": "Test User",
+            "language": "en",
+            "country": "CA",
+            "appVersion": "1.0.11",
+            "appBuild": 1000,
+            "customData": {"custom": "data"},
+            "privateCustomData": {"private": "data"},
+        },
+    )
+
+    # Look up the value of the flag
+    if open_feature_client.get_boolean_value(FLAG_KEY, False, context):
+        logger.info(f"Variable {FLAG_KEY} is enabled")
+    else:
+        logger.info(f"Variable {FLAG_KEY} is not enabled")
+
+    # Fetch a JSON object variable
+    json_object = open_feature_client.get_object_value(
+        "test-json-variable", {"default": "value"}, context
+    )
+    logger.info(f"JSON Object Value: {json_object}")
+
+    # Retrieve a string variable along with resolution details
+    details = open_feature_client.get_string_details("doesnt-exist", "default", context)
+    logger.info(f"String Value: {details.value}")
+    logger.info(f"Eval Reason: {details.reason}")
+
+    devcycle_client.close()
+
+
+if __name__ == "__main__":
+    main()

test/api/test_local_bucketing.py

@@ -5,10 +5,7 @@ import unittest
 from devcycle_python_sdk.api.local_bucketing import LocalBucketing, WASMAbortError
 from devcycle_python_sdk.models.bucketed_config import (
     Environment,
-    EdgeDBSettings,
     FeatureVariation,
-    OptInColors,
-    OptInSettings,
     Project,
     ProjectSettings,
 )
@@ -197,27 +194,29 @@ class LocalBucketingTest(unittest.TestCase):
                 defaultValue=None,
                 evalReason=None,
             ),
+            "float-var": Variable(
+                _id="61200363125123fca69d3a7a",
+                key="float-var",
+                type="Number",
+                value=3.14159,
+                isDefaulted=None,
+                defaultValue=None,
+                evalReason=None,
+            ),
         }
 
         self.assertIsNotNone(result)
         self.assertEqual(result.user, user)
         self.assertEqual(
-            result.project,
             Project(
                 id="61f97628ff4afcb6d057dbf0",
                 key="emma-project",
                 a0_organization="org_tPyJN5dvNNirKar7",
                 settings=ProjectSettings(
-                    edge_db=EdgeDBSettings(enabled=False),
-                    opt_in=OptInSettings(
-                        enabled=True,
-                        title="EarlyAccess",
-                        description="Getearlyaccesstobetafeaturesbelow!",
-                        image_url="",
-                        colors=OptInColors(primary="#531cd9", secondary="#16dec0"),
-                    ),
+                    edge_db=None, opt_in=None, disable_passthrough_rollouts=False
                 ),
             ),
+            result.project,
         )
         self.assertEqual(
             result.environment,
@@ -250,6 +249,10 @@ class LocalBucketingTest(unittest.TestCase):
                     feature="62fbf6566f1ba302829f9e32",
                     variation="62fbf6566f1ba302829f9e39",
                 ),
+                "float-var": FeatureVariation(
+                    feature="62fbf6566f1ba302829f9e32",
+                    variation="62fbf6566f1ba302829f9e39",
+                ),
             },
         )
         self.assertEqual(

test/models/test_user.py

@@ -0,0 +1,188 @@
+import logging
+import unittest
+
+from devcycle_python_sdk.models.user import DevCycleUser
+
+from openfeature.provider import EvaluationContext
+from openfeature.exception import TargetingKeyMissingError, InvalidContextError
+
+
+logger = logging.getLogger(__name__)
+
+
+class DevCycleUserTest(unittest.TestCase):
+    def test_create_user_from_context_no_context(self):
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(None)
+
+    def test_create_user_from_context_no_user_id(self):
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(
+                EvaluationContext(targeting_key=None, attributes={})
+            )
+
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(
+                EvaluationContext(targeting_key=None, attributes=None)
+            )
+
+        with self.assertRaises(TargetingKeyMissingError):
+            DevCycleUser.create_user_from_context(
+                EvaluationContext(targeting_key=None, attributes={"user_id": None})
+            )
+
+    def test_create_user_from_context_only_user_id(self):
+        test_user_id = "12345"
+        context = EvaluationContext(targeting_key=test_user_id, attributes=None)
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        context = EvaluationContext(
+            targeting_key=None, attributes={"user_id": test_user_id}
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        # ensure that targeting_key takes precedence over user_id
+        context = EvaluationContext(
+            targeting_key=test_user_id, attributes={"user_id": "99999"}
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+    def test_create_user_from_context_with_attributes(self):
+        test_user_id = "12345"
+        context = EvaluationContext(
+            targeting_key=test_user_id,
+            attributes={
+                "user_id": "1234",
+                "email": "someone@example.com",
+                "name": "John Doe",
+                "language": "en",
+                "country": "US",
+                "appVersion": "1.0.0",
+                "appBuild": "1",
+                "deviceModel": "iPhone X21",
+            },
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+        self.assertEqual(user.email, context.attributes["email"])
+        self.assertEqual(user.name, context.attributes["name"])
+        self.assertEqual(user.language, context.attributes["language"])
+        self.assertEqual(user.country, context.attributes["country"])
+        self.assertEqual(user.appVersion, context.attributes["appVersion"])
+        self.assertEqual(user.appBuild, context.attributes["appBuild"])
+        self.assertEqual(user.deviceModel, context.attributes["deviceModel"])
+
+    def test_create_user_from_context_with_custom_data(self):
+        test_user_id = "12345"
+        context = EvaluationContext(
+            targeting_key=test_user_id,
+            attributes={
+                "customData": {
+                    "strValue": "hello",
+                    "intValue": 123,
+                    "floatValue": 3.1456,
+                    "boolValue": True,
+                },
+                "privateCustomData": {
+                    "strValue": "world",
+                    "intValue": 789,
+                    "floatValue": 0.0001,
+                    "BoolValue": False,
+                },
+            },
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        self.assertEqual(
+            user.customData,
+            {
+                "strValue": "hello",
+                "intValue": 123,
+                "floatValue": 3.1456,
+                "boolValue": True,
+            },
+        )
+        self.assertEqual(
+            user.privateCustomData,
+            {
+                "strValue": "world",
+                "intValue": 789,
+                "floatValue": 0.0001,
+                "BoolValue": False,
+            },
+        )
+
+    def test_create_user_from_context_with_unknown_data_fields(self):
+        test_user_id = "12345"
+        context = EvaluationContext(
+            targeting_key=test_user_id,
+            attributes={
+                "strValue": "hello",
+                "intValue": 123,
+                "floatValue": 3.1456,
+                "boolValue": True,
+            },
+        )
+        user = DevCycleUser.create_user_from_context(context)
+        self.assertIsNotNone(user)
+        self.assertEqual(user.user_id, test_user_id)
+
+        # the fields should get reassigned to custom_data
+        self.assertEqual(
+            user.customData,
+            {
+                "strValue": "hello",
+                "intValue": 123,
+                "floatValue": 3.1456,
+                "boolValue": True,
+            },
+        )
+        self.assertEqual(user.privateCustomData, None)
+
+    def test_set_custom_value(self):
+        custom_data = {}
+        with self.assertRaises(InvalidContextError):
+            DevCycleUser._set_custom_value(custom_data, None, None)
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", None)
+        self.assertDictEqual(custom_data, {"key1": None})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", "value1")
+        self.assertDictEqual(custom_data, {"key1": "value1"})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", 1)
+        self.assertDictEqual(custom_data, {"key1": 1})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", 3.1456)
+        self.assertDictEqual(custom_data, {"key1": 3.1456})
+
+        custom_data = {}
+        DevCycleUser._set_custom_value(custom_data, "key1", True)
+        self.assertDictEqual(custom_data, {"key1": True})
+
+        custom_data = {}
+        with self.assertRaises(InvalidContextError):
+            DevCycleUser._set_custom_value(custom_data, "map_data", {"hello": "world"})
+
+        custom_data = {}
+        with self.assertRaises(InvalidContextError):
+            DevCycleUser._set_custom_value(
+                custom_data, "list_data", ["one", "two", "three"]
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

test/openfeature_test/test_provider.py

@@ -0,0 +1,219 @@
+import logging
+import unittest
+from unittest.mock import MagicMock
+
+from openfeature.provider import EvaluationContext
+from openfeature.flag_evaluation import Reason
+from openfeature.exception import (
+    ErrorCode,
+    TargetingKeyMissingError,
+    InvalidContextError,
+    TypeMismatchError,
+)
+
+from devcycle_python_sdk.models.variable import Variable, TypeEnum
+
+from devcycle_python_sdk.open_feature_provider.provider import (
+    DevCycleProvider,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class DevCycleProviderTest(unittest.TestCase):
+    def setUp(self):
+        self.client = MagicMock()
+        self.client.is_initialized.return_value = True
+        self.provider = DevCycleProvider(self.client)
+
+    def test_resolve_details_client_not_ready(self):
+        self.client.is_initialized.return_value = False
+
+        details = self.provider._resolve(
+            "test-flag", False, EvaluationContext("test-user")
+        )
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, False)
+        self.assertEqual(details.reason, Reason.ERROR)
+        self.assertEqual(details.error_code, ErrorCode.PROVIDER_NOT_READY)
+
+    def test_resolve_details_client_no_user_in_context(self):
+        context = EvaluationContext(targeting_key=None, attributes={})
+
+        with self.assertRaises(TargetingKeyMissingError):
+            self.provider._resolve("test-flag", False, context)
+
+    def test_resolve_details_no_key(self):
+        self.client.variable.side_effect = ValueError("test error")
+        context = EvaluationContext(targeting_key="user-1234")
+        with self.assertRaises(InvalidContextError):
+            self.provider._resolve(None, False, context)
+
+    def test_resolve_details_no_default_value(self):
+        self.client.variable.side_effect = ValueError("test error")
+        context = EvaluationContext(targeting_key="user-1234")
+        with self.assertRaises(InvalidContextError):
+            self.provider._resolve("test-flag", None, context)
+
+    def test_resolve_details_client_returns_none(self):
+        self.client.variable.return_value = None
+        context = EvaluationContext(targeting_key="user-1234")
+
+        details = self.provider._resolve("test-flag", False, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, False)
+        self.assertEqual(details.reason, Reason.DEFAULT)
+
+    def test_resolve_details_client_returns_default_variable(self):
+        self.client.variable.return_value = Variable.create_default_variable(
+            key="test-flag", default_value=False
+        )
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider._resolve("test-flag", False, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, False)
+        self.assertEqual(details.reason, Reason.DEFAULT)
+
+    def test_resolve_boolean_details(self):
+        key = "test-flag"
+        variable_value = True
+        default_value = False
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.BOOLEAN,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_boolean_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_string_details(self):
+        key = "test-flag"
+        variable_value = "some string"
+        default_value = "default string"
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_string_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, variable_value)
+        self.assertIsInstance(details.value, str)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_integer_details(self):
+        key = "test-flag"
+        variable_value = 12345
+        default_value = 0
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_integer_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertIsInstance(details.value, int)
+        self.assertEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_float_details(self):
+        key = "test-flag"
+        variable_value = 3.145
+        default_value = 0.0
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_float_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertIsInstance(details.value, float)
+        self.assertEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    def test_resolve_object_details_verify_default_value(self):
+        key = "test-flag"
+        context = EvaluationContext(targeting_key="user-1234")
+
+        # Only flat dictionaries are supported as objects
+        # lists, primitives and nested objects are not supported
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, [], context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, 1234, context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, 3.14, context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, False, context)
+
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(key, "some string", context)
+
+        # test dictionaries with nested objects
+        with self.assertRaises(TypeMismatchError):
+            self.provider.resolve_object_details(
+                key, {"nestedMap": {"someProp": "some value"}}, context
+            )
+
+    def test_resolve_object_details(self):
+        key = "test-flag"
+        variable_value = {"some": "value"}
+        default_value = {}
+
+        self.client.variable.return_value = Variable(
+            _id=None,
+            value=variable_value,
+            key=key,
+            type=TypeEnum.STRING,
+            isDefaulted=False,
+            defaultValue=False,
+        )
+
+        context = EvaluationContext(targeting_key="user-1234")
+        details = self.provider.resolve_object_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertIsInstance(details.value, dict)
+        self.assertDictEqual(details.value, variable_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/openfeature_test/test_provider_local_sdk.py

@@ -0,0 +1,136 @@
+import logging
+import time
+import unittest
+
+import responses
+
+from devcycle_python_sdk import DevCycleLocalClient, DevCycleLocalOptions
+from test.fixture.data import small_config_json
+
+from openfeature.provider import EvaluationContext
+from openfeature.flag_evaluation import Reason
+
+logger = logging.getLogger(__name__)
+
+
+class DevCycleProviderWithLocalSDKTest(unittest.TestCase):
+    """
+    Tests the DevCycleProvider with actual data from the Local SDK client to confirm data translations work
+    """
+
+    def setUp(self) -> None:
+        self.sdk_key = "dvc_server_949e4962-c624-4d20-a1ea-7f2501b2ba79"
+        self.test_config_json = small_config_json()
+        self.test_etag = "2f71454e-3279-4ca7-a8e7-802ce97bef43"
+
+        config_url = "http://localhost/config/v1/server/" + self.sdk_key + ".json"
+
+        responses.add(
+            responses.GET,
+            config_url,
+            headers={"ETag": self.test_etag},
+            json=self.test_config_json,
+            status=200,
+        )
+
+        self.options = DevCycleLocalOptions(
+            config_polling_interval_ms=5000,
+            config_cdn_uri="http://localhost/",
+            disable_custom_event_logging=True,
+            disable_automatic_event_logging=True,
+        )
+        self.client = None
+
+    def tearDown(self) -> None:
+        if self.client:
+            self.client.close()
+        responses.reset()
+
+    def setup_client(self):
+        self.client = DevCycleLocalClient(self.sdk_key, self.options)
+        while not self.client.is_initialized():
+            time.sleep(0.05)
+
+    @responses.activate
+    def test_resolve_boolean_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "a-cool-new-feature"
+        expected_value = True
+        default_value = False
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_boolean_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_integer_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "num-var"
+        expected_value = 12345
+        default_value = 0
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_integer_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_float_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "float-var"
+        expected_value = 3.14159
+        default_value = 0.0001
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_float_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_string_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "string-var"
+        expected_value = "variationOn"
+        default_value = "default_value"
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_string_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)
+
+    @responses.activate
+    def test_resolve_object_details(self):
+        self.setup_client()
+        provider = self.client.get_openfeature_provider()
+
+        key = "json-var"
+        expected_value = {
+            "displayText": "This variation is on",
+            "showDialog": True,
+            "maxUsers": 100,
+        }
+        default_value = {"default": "value"}
+
+        context = EvaluationContext(targeting_key="1234")
+        details = provider.resolve_string_details(key, default_value, context)
+
+        self.assertIsNotNone(details)
+        self.assertEqual(details.value, expected_value)
+        self.assertEqual(details.reason, Reason.TARGETING_MATCH)

test/test_local_client.py

@@ -217,6 +217,7 @@ class DevCycleLocalClientTest(unittest.TestCase):
             ("string-var", "default_value", "variationOn", TypeEnum.STRING),
             ("a-cool-new-feature", False, True, TypeEnum.BOOLEAN),
             ("num-var", 0, 12345, TypeEnum.NUMBER),
+            ("float-var", 0, 3.14159, TypeEnum.NUMBER),
             (
                 "json-var",
                 {"default": "value"},
@@ -333,6 +334,15 @@ class DevCycleLocalClientTest(unittest.TestCase):
                 defaultValue=None,
                 evalReason=None,
             ),
+            "float-var": Variable(
+                _id="61200363125123fca69d3a7a",
+                key="float-var",
+                type="Number",
+                value=3.14159,
+                isDefaulted=None,
+                defaultValue=None,
+                evalReason=None,
+            ),
         }
         self.assertEqual(result, expected_variables)
 

test/util/test_version.py

@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
 class VersionTest(unittest.TestCase):
     def test_sdk_version(self):
         version = sdk_version()
-        self.assertRegexpMatches(version, r"^\d+\.\d+\.\d+$")
+        self.assertRegex(version, r"^\d+\.\d+\.\d+$")
 
 
 if __name__ == "__main__":