launchdarkly
diff --git a/‎.circleci/config.yml‎
Lines changed: 5 additions & 8 deletions b/‎.circleci/config.yml‎
Lines changed: 5 additions & 8 deletions
diff --git a/‎.ldrelease/config.yml‎
Lines changed: 2 additions & 1 deletion b/‎.ldrelease/config.yml‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎.readthedocs.yml‎
Lines changed: 1 addition & 1 deletion b/‎.readthedocs.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Makefile‎
Lines changed: 6 additions & 2 deletions b/‎Makefile‎
Lines changed: 6 additions & 2 deletions
diff --git a/‎README.md‎
Lines changed: 1 addition & 1 deletion b/‎README.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎contract-tests/big_segment_store_fixture.py‎
Lines changed: 37 additions & 0 deletions b/‎contract-tests/big_segment_store_fixture.py‎
Lines changed: 37 additions & 0 deletions
diff --git a/‎contract-tests/client_entity.py‎
Lines changed: 81 additions & 18 deletions b/‎contract-tests/client_entity.py‎
Lines changed: 81 additions & 18 deletions
diff --git a/‎contract-tests/service.py‎
Lines changed: 35 additions & 22 deletions b/‎contract-tests/service.py‎
Lines changed: 35 additions & 22 deletions
diff --git a/‎docs/api-deprecated.rst‎
Lines changed: 0 additions & 12 deletions b/‎docs/api-deprecated.rst‎
Lines changed: 0 additions & 12 deletions
@@ -6,14 +6,6 @@ orbs:
 workflows:
   test:
     jobs:
-      - test-linux:
-          name: Python 3.5
-          docker-image: cimg/python:3.5
-          skip-sse-contract-tests: true  # the test service app has dependencies that aren't available in 3.5, which is EOL anyway
-          skip-contract-tests: true  # the test service app has dependencies that aren't available in 3.5, which is EOL anyway
-      - test-linux:
-          name: Python 3.6
-          docker-image: cimg/python:3.6
       - test-linux:
           name: Python 3.7
           docker-image: cimg/python:3.7
@@ -26,6 +18,9 @@ workflows:
       - test-linux:
           name: Python 3.10
           docker-image: cimg/python:3.10
+      - test-linux:
+          name: Python 3.11
+          docker-image: cimg/python:3.11
       - test-windows:
           name: Windows Python 3
           py3: true
@@ -57,6 +52,7 @@ jobs:
       - image: consul
     steps:
       - checkout
+      - run: python --version
       - run:
           name: install requirements
           command: |
@@ -142,6 +138,7 @@ jobs:
       - run:
           name: install Python 3
           command: choco install python --no-progress
+      - run: python --version
       - run:
           name: set up DynamoDB
           command: |
 
@@ -12,7 +12,8 @@ publications:
 
 branches:
   - name: main
-    description: 7.x
+    description: 8.x
+  - name: 7.x
   - name: 6.x
 
 jobs:
 
@@ -1,7 +1,7 @@
 version: 2
 
 python:
-  version: 3.5
+  version: 3.7
   install:
     - requirements: docs/requirements.txt
     - requirements: requirements.txt
 
@@ -18,6 +18,10 @@ docs:
 
 TEMP_TEST_OUTPUT=/tmp/contract-test-service.log
 
+# TEST_HARNESS_PARAMS can be set to add -skip parameters for any contract tests that cannot yet pass
+# TEST_HARNESS_PARAMS := $(TEST_HARNESS_PARAMS) \
+
+
 # port 8000 and 9000 is already used in the CI environment because we're
 # running a DynamoDB container and an SSE contract test
 PORT=10000
@@ -33,8 +37,8 @@ start-contract-test-service-bg:
 	@make start-contract-test-service >$(TEMP_TEST_OUTPUT) 2>&1 &
 
 run-contract-tests:
-	@curl -s https://raw.githubusercontent.com/launchdarkly/sdk-test-harness/v1.0.0/downloader/run.sh \
-      | VERSION=v1 PARAMS="-url http://localhost:$(PORT) -debug -stop-service-at-end $(TEST_HARNESS_PARAMS)" sh
+	curl -s https://raw.githubusercontent.com/launchdarkly/sdk-test-harness/v2/downloader/run.sh \
+      | VERSION=v2 PARAMS="-url http://localhost:$(PORT) -debug -stop-service-at-end $(TEST_HARNESS_PARAMS)" sh
 
 contract-tests: build-contract-tests start-contract-test-service-bg run-contract-tests
 
 
@@ -13,7 +13,7 @@
 
 ## Supported Python versions
 
-This version of the LaunchDarkly SDK is compatible with Python 3.5 through 3.10. It is tested with the most recent patch releases of those versions. Python versions 2.7 to 3.4 are no longer supported.
+This version of the LaunchDarkly SDK is compatible with Python 3.7 through 3.11. It is tested with the most recent patch releases of those versions. Python versions 2.7 to 3.6 are no longer supported.
 
 ## Getting started
 
 
@@ -0,0 +1,37 @@
+import json
+import os
+import sys
+from typing import Optional
+import urllib3
+
+# Import ldclient from parent directory
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+from ldclient.interfaces import BigSegmentStore, BigSegmentStoreMetadata
+
+
+http = urllib3.PoolManager()
+
+
+class BigSegmentStoreFixture(BigSegmentStore):
+    def __init__(self, callback_uri: str):
+        self._callback_uri = callback_uri
+    
+    def get_metadata(self) -> BigSegmentStoreMetadata:
+        resp_data = self._post_callback('/getMetadata', None)
+        return BigSegmentStoreMetadata(resp_data.get("lastUpToDate"))
+
+    def get_membership(self, context_hash: str) -> Optional[dict]:
+        resp_data = self._post_callback('/getMembership', {'contextHash': context_hash})
+        return resp_data.get("values")
+
+    def _post_callback(self, path: str, params: Optional[dict]) -> dict:
+        url = self._callback_uri + path
+        resp = http.request('POST', url,
+            body=None if params is None else json.dumps(params),
+            headers=None if params is None else {'Content-Type': 'application/json'})
+        if resp.status != 200:
+            raise Exception("HTTP error %d from callback to %s" % (resp.status, url))
+        return json.loads(resp.data.decode('utf-8'))
+
+    def stop(self):
+        pass
@@ -1,6 +1,12 @@
+import json
 import logging
 import os
 import sys
+from typing import Optional
+
+from big_segment_store_fixture import BigSegmentStoreFixture
+
+from ldclient.config import BigSegmentsConfig
 
 # Import ldclient from parent directory
 sys.path.insert(1, os.path.join(sys.path[0], '..'))
@@ -16,8 +22,7 @@ def __init__(self, tag, config):
             streaming = config["streaming"]
             if streaming.get("baseUri") is not None:
                 opts["stream_uri"] = streaming["baseUri"]
-            if streaming.get("initialRetryDelayMs") is not None:
-                opts["initial_reconnect_delay"] = streaming["initialRetryDelayMs"] / 1000.0
+            _set_optional_time_prop(streaming, "initialRetryDelayMs", opts, "initial_reconnect_delay")
 
         if config.get("events") is not None:
             events = config["events"]
@@ -28,13 +33,22 @@ def __init__(self, tag, config):
             opts["diagnostic_opt_out"] = not events.get("enableDiagnostics", False)
             opts["all_attributes_private"] = events.get("allAttributesPrivate", False)
             opts["private_attribute_names"] = events.get("globalPrivateAttributes", {})
-            if events.get("flushIntervalMs") is not None:
-                 opts["flush_interval"] = events["flushIntervalMs"] / 1000.0
-            if events.get("inlineUsers") is not None:
-                opts["inline_users_in_events"] = events["inlineUsers"]
+            _set_optional_time_prop(events, "flushIntervalMs", opts, "flush_interval")
         else:
             opts["send_events"] = False
 
+        if config.get("bigSegments") is not None:
+            big_params = config["bigSegments"]
+            big_config = {
+                "store": BigSegmentStoreFixture(big_params["callbackUri"])
+            }
+            if big_params.get("userCacheSize") is not None:
+                big_config["context_cache_size"] = big_params["userCacheSize"]
+            _set_optional_time_prop(big_params, "userCacheTimeMs", big_config, "context_cache_time")
+            _set_optional_time_prop(big_params, "statusPollIntervalMs", big_config, "status_poll_interval")
+            _set_optional_time_prop(big_params, "staleAfterMs", big_config, "stale_after")
+            opts["big_segments"] = BigSegmentsConfig(**big_config)
+        
         start_wait = config.get("startWaitTimeMs") or 5000
         config = Config(**opts)
 
@@ -43,41 +57,90 @@ def __init__(self, tag, config):
     def is_initializing(self) -> bool:
         return self.client.is_initialized()
 
-    def evaluate(self, params) -> dict:
+    def evaluate(self, params: dict) -> dict:
         response = {}
 
         if params.get("detail", False):
-            detail = self.client.variation_detail(params["flagKey"], params["user"], params["defaultValue"])
+            detail = self.client.variation_detail(params["flagKey"], params["context"], params["defaultValue"])
             response["value"] = detail.value
             response["variationIndex"] = detail.variation_index
             response["reason"] = detail.reason
         else:
-            response["value"] = self.client.variation(params["flagKey"], params["user"], params["defaultValue"])
+            response["value"] = self.client.variation(params["flagKey"], params["context"], params["defaultValue"])
 
         return response
 
-    def evaluate_all(self, params):
+    def evaluate_all(self, params: dict):
         opts = {}
         opts["client_side_only"] = params.get("clientSideOnly", False)
         opts["with_reasons"] = params.get("withReasons", False)
         opts["details_only_for_tracked_flags"] = params.get("detailsOnlyForTrackedFlags", False)
 
-        state = self.client.all_flags_state(params["user"], **opts)
+        state = self.client.all_flags_state(params["context"], **opts)
 
         return {"state": state.to_json_dict()}
 
-    def track(self, params):
-        self.client.track(params["eventKey"], params["user"], params["data"], params.get("metricValue", None))
-
-    def identify(self, params):
-        self.client.identify(params["user"])
+    def track(self, params: dict):
+        self.client.track(params["eventKey"], params["context"], params["data"], params.get("metricValue", None))
 
-    def alias(self, params):
-        self.client.alias(params["user"], params["previousUser"])
+    def identify(self, params: dict):
+        self.client.identify(params["context"])
 
     def flush(self):
         self.client.flush()
 
+    def secure_mode_hash(self, params: dict) -> dict:
+        return {"result": self.client.secure_mode_hash(params["context"])}
+    
+    def context_build(self, params: dict) -> dict:
+        if params.get("multi"):
+            b = Context.multi_builder()
+            for c in params.get("multi"):
+                b.add(self._context_build_single(c))
+            return self._context_response(b.build())
+        return self._context_response(self._context_build_single(params["single"]))
+    
+    def _context_build_single(self, params: dict) -> Context:
+        b = Context.builder(params["key"])
+        if "kind" in params:
+            b.kind(params["kind"])
+        if "name" in params:
+            b.name(params["name"])
+        if "anonymous" in params:
+            b.anonymous(params["anonymous"])
+        if "custom" in params:
+            for k, v in params.get("custom").items():
+                b.set(k, v)
+        if "private" in params:
+            for attr in params.get("private"):
+                b.private(attr)
+        return b.build()
+    
+    def context_convert(self, params: dict) -> dict:
+        input = params["input"]
+        try:
+            props = json.loads(input)
+            return self._context_response(Context.from_dict(props))
+        except Exception as e:
+            return {"error": str(e)}
+    
+    def _context_response(self, c: Context) -> dict:
+        if c.valid:
+            return {"output": c.to_json_string()}
+        return {"error": c.error}
+    
+    def get_big_segment_store_status(self) -> dict:
+        status = self.client.big_segment_store_status_provider.status
+        return {
+            "available": status.available,
+            "stale": status.stale
+        }
+
     def close(self):
         self.client.close()
         self.log.info('Test ended')
+
+def _set_optional_time_prop(params_in: dict, name_in: str, params_out: dict, name_out: str):
+    if params_in.get(name_in) is not None:
+        params_out[name_out] = params_in[name_in] / 1000.0
+    return None
@@ -12,6 +12,7 @@
 
 default_port = 8000
 
+
 # logging configuration
 dictConfig({
     'version': 1,
@@ -30,11 +31,10 @@
         'level': 'INFO',
         'handlers': ['console']
     },
-    'ldclient.util': {
-        'level': 'INFO',
-        'handlers': ['console']
-    },
     'loggers': {
+        'ldclient': {
+            'level': 'INFO', # change to 'DEBUG' to enable SDK debug logging
+        },
         'werkzeug': { 'level': 'ERROR' } # disable irrelevant Flask app logging
     }
 })
@@ -53,6 +53,7 @@ def handle_exception(e):
     if isinstance(e, HTTPException):
         return e
 
+    app.logger.exception(e)
     return str(e), 500
 
 @app.route('/', methods=['GET'])
@@ -63,6 +64,9 @@ def status():
             'all-flags-with-reasons',
             'all-flags-client-side-only',
             'all-flags-details-only-for-tracked-flags',
+            'big-segments',
+            'context-type',
+            'secure-mode-hash',
         ]
     }
     return (json.dumps(body), 200, {'Content-type': 'application/json'})
@@ -102,26 +106,35 @@ def post_client_command(id):
     if client is None:
         return ('', 404)
 
-    if params.get('command') == "evaluate":
-        response = client.evaluate(params.get("evaluate"))
-        return (json.dumps(response), 200)
-    elif params.get("command") == "evaluateAll":
-        response = client.evaluate_all(params.get("evaluateAll"))
-        return (json.dumps(response), 200)
-    elif params.get("command") == "customEvent":
-        client.track(params.get("customEvent"))
-        return ('', 201)
-    elif params.get("command") == "identifyEvent":
-        client.identify(params.get("identifyEvent"))
-        return ('', 201)
-    elif params.get("command") == "aliasEvent":
-        client.alias(params.get("aliasEvent"))
-        return ('', 201)
-    elif params.get('command') == "flushEvents":
+    command = params.get('command')
+    sub_params = params.get(command)
+
+    response = None
+
+    if command == "evaluate":
+        response = client.evaluate(sub_params)
+    elif command == "evaluateAll":
+        response = client.evaluate_all(sub_params)
+    elif command == "customEvent":
+        client.track(sub_params)
+    elif command == "identifyEvent":
+        client.identify(sub_params)
+    elif command == "flushEvents":
         client.flush()
+    elif command == "secureModeHash":
+        response = client.secure_mode_hash(sub_params)
+    elif command == "contextBuild":
+        response = client.context_build(sub_params)
+    elif command == "contextConvert":
+        response = client.context_convert(sub_params)
+    elif command == "getBigSegmentStoreStatus":
+        response = client.get_big_segment_store_status()
+    else:
+        return ('', 400)
+    
+    if response is None:
         return ('', 201)
-
-    return ('', 400)
+    return (json.dumps(response), 200)
 
 @app.route('/clients/<id>', methods=['DELETE'])
 def delete_client(id):