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

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_config_client.py

@@ -2,6 +2,9 @@ import logging
 import unittest
 import uuid
 from http import HTTPStatus
+from datetime import datetime
+from email.utils import formatdate
+from time import mktime
 
 import requests
 import responses
@@ -36,6 +39,9 @@ class ConfigAPIClientTest(unittest.TestCase):
 
         options = DevCycleLocalOptions(config_retry_delay_ms=0)
         self.test_client = ConfigAPIClient(self.sdk_key, options)
+        now = datetime.now()
+        stamp = mktime(now.timetuple())
+        self.test_lastmodified = formatdate(timeval=stamp, localtime=False, usegmt=True)
         self.test_etag = str(uuid.uuid4())
         self.test_config_json: dict = small_config_json()
 
@@ -45,14 +51,20 @@ class ConfigAPIClientTest(unittest.TestCase):
     @responses.activate
     def test_get_config(self):
         new_etag = str(uuid.uuid4())
+        now = datetime.now()
+        stamp = mktime(now.timetuple())
+        new_lastmodified = formatdate(timeval=stamp, localtime=False, usegmt=True)
         responses.add(
             responses.GET,
             self.config_url,
-            headers={"ETag": new_etag},
+            headers={"ETag": new_etag, "Last-Modified": new_lastmodified},
             json=self.test_config_json,
         )
-        result, etag = self.test_client.get_config(config_etag=self.test_etag)
+        result, etag, lastmodified = self.test_client.get_config(
+            config_etag=self.test_etag, last_modified=self.test_lastmodified
+        )
         self.assertDictEqual(result, self.test_config_json)
+        self.assertEqual(lastmodified, new_lastmodified)
         self.assertEqual(etag, new_etag)
 
     @responses.activate(registry=OrderedRegistry)
@@ -68,7 +80,9 @@ class ConfigAPIClientTest(unittest.TestCase):
             headers={"ETag": self.test_etag},
             json=self.test_config_json,
         )
-        result, etag = self.test_client.get_config(config_etag=self.test_etag)
+        result, etag, lastmodified = self.test_client.get_config(
+            config_etag=self.test_etag
+        )
 
         self.assertDictEqual(result, self.test_config_json)
         self.assertEqual(etag, self.test_etag)
@@ -83,10 +97,12 @@ class ConfigAPIClientTest(unittest.TestCase):
         responses.add(
             responses.GET,
             self.config_url,
-            headers={"ETag": self.test_etag},
+            headers={"ETag": self.test_etag, "Last-Modified": self.test_lastmodified},
             json=self.test_config_json,
         )
-        result, etag = self.test_client.get_config(config_etag=self.test_etag)
+        result, etag, last_modified = self.test_client.get_config(
+            config_etag=self.test_etag
+        )
         self.assertDictEqual(result, self.test_config_json)
         self.assertEqual(etag, self.test_etag)
 
@@ -131,6 +147,8 @@ class ConfigAPIClientTest(unittest.TestCase):
             status=HTTPStatus.NOT_MODIFIED,
         )
 
-        new_config, new_etag = self.test_client.get_config(config_etag=self.test_etag)
+        new_config, new_etag, last_modified = self.test_client.get_config(
+            config_etag=self.test_etag
+        )
         self.assertIsNone(new_config)
         self.assertEqual(new_etag, self.test_etag)

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/managers/test_config_manager.py

@@ -1,8 +1,11 @@
-import logging
 import json
+import logging
 import time
-import uuid
 import unittest
+import uuid
+from datetime import datetime
+from email.utils import formatdate
+from time import mktime
 from unittest.mock import patch, MagicMock
 
 from devcycle_python_sdk import DevCycleLocalOptions
@@ -18,20 +21,27 @@ class EnvironmentConfigManagerTest(unittest.TestCase):
         self.test_local_bucketing = MagicMock()
         self.test_options = DevCycleLocalOptions(config_polling_interval_ms=500)
 
+        now = datetime.now()
+        stamp = mktime(now.timetuple())
+        self.test_lastmodified = formatdate(timeval=stamp, localtime=False, usegmt=True)
         self.test_etag = str(uuid.uuid4())
         self.test_config_json = small_config_json()
         self.test_config_string = json.dumps(self.test_config_json)
 
     @patch("devcycle_python_sdk.api.config_client.ConfigAPIClient.get_config")
     def test_init(self, mock_get_config):
-        mock_get_config.return_value = (self.test_config_json, self.test_etag)
+        mock_get_config.return_value = (
+            self.test_config_json,
+            self.test_etag,
+            self.test_lastmodified,
+        )
         config_manager = EnvironmentConfigManager(
             self.sdk_key, self.test_options, self.test_local_bucketing
         )
 
         # sleep to allow polling thread to load the config
         time.sleep(0.1)
-        mock_get_config.assert_called_once_with(config_etag=None)
+        mock_get_config.assert_called_once_with(config_etag=None, last_modified=None)
 
         self.assertTrue(config_manager._polling_enabled)
         self.assertTrue(config_manager.is_alive())
@@ -45,7 +55,11 @@ class EnvironmentConfigManagerTest(unittest.TestCase):
 
     @patch("devcycle_python_sdk.api.config_client.ConfigAPIClient.get_config")
     def test_init_with_client_callback(self, mock_get_config):
-        mock_get_config.return_value = (self.test_config_json, self.test_etag)
+        mock_get_config.return_value = (
+            self.test_config_json,
+            self.test_etag,
+            self.test_lastmodified,
+        )
 
         mock_callback = MagicMock()
 
@@ -55,7 +69,7 @@ class EnvironmentConfigManagerTest(unittest.TestCase):
             self.sdk_key, self.test_options, self.test_local_bucketing
         )
         time.sleep(0.1)
-        mock_get_config.assert_called_once_with(config_etag=None)
+        mock_get_config.assert_called_once_with(config_etag=None, last_modified=None)
         self.assertEqual(config_manager._config_etag, self.test_etag)
         self.assertDictEqual(config_manager._config, self.test_config_json)
         self.test_local_bucketing.store_config.assert_called_once_with(
@@ -66,7 +80,11 @@ class EnvironmentConfigManagerTest(unittest.TestCase):
 
     @patch("devcycle_python_sdk.api.config_client.ConfigAPIClient.get_config")
     def test_init_with_client_callback_with_error(self, mock_get_config):
-        mock_get_config.return_value = (self.test_config_json, self.test_etag)
+        mock_get_config.return_value = (
+            self.test_config_json,
+            self.test_etag,
+            self.test_lastmodified,
+        )
         mock_callback = MagicMock()
         mock_callback.side_effect = Exception(
             "Badly written callback generates an exception"
@@ -79,7 +97,7 @@ class EnvironmentConfigManagerTest(unittest.TestCase):
         )
         # the callback error should not negatively impact initialization of the config manager
         time.sleep(0.1)
-        mock_get_config.assert_called_once_with(config_etag=None)
+        mock_get_config.assert_called_once_with(config_etag=None, last_modified=None)
         self.assertEqual(config_manager._config_etag, self.test_etag)
         self.assertDictEqual(config_manager._config, self.test_config_json)
         self.test_local_bucketing.store_config.assert_called_once_with(
@@ -105,7 +123,11 @@ class EnvironmentConfigManagerTest(unittest.TestCase):
 
     @patch("devcycle_python_sdk.api.config_client.ConfigAPIClient.get_config")
     def test_get_config_unchanged(self, mock_get_config):
-        mock_get_config.return_value = (self.test_config_json, self.test_etag)
+        mock_get_config.return_value = (
+            self.test_config_json,
+            self.test_etag,
+            self.test_lastmodified,
+        )
 
         self.test_options.config_polling_interval_ms = 200
         config_manager = EnvironmentConfigManager(
@@ -117,7 +139,7 @@ class EnvironmentConfigManagerTest(unittest.TestCase):
         config_manager.close()
 
         self.test_local_bucketing.store_config.reset_mock()
-        mock_get_config.return_value = (None, config_manager._config_etag)
+        mock_get_config.return_value = (None, config_manager._config_etag, None)
 
         # trigger refresh of the config directly
         config_manager._get_config()

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()