launchdarkly-openfeature-server 0.8.2__tar.gz → 0.9.0__tar.gz

{launchdarkly_openfeature_server-0.8.2 → launchdarkly_openfeature_server-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchdarkly-openfeature-server
-Version: 0.8.2
+Version: 0.9.0
 Summary: An OpenFeature provider for the LaunchDarkly Python server SDK
 License: Apache-2.0
 License-File: LICENSE
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: launchdarkly-server-sdk (>=9.17.0,<10)
+Requires-Dist: launchdarkly-server-sdk (>=9.18.3,<10)
 Requires-Dist: openfeature-sdk (>=0.9.0,<1)
 Project-URL: Documentation, https://launchdarkly-openfeature-python-sdk.readthedocs.io/en/latest/
 Project-URL: Repository, https://github.com/launchdarkly/openfeature-python-server
@@ -51,7 +51,7 @@ This provider is designed primarily for use in multi-user systems such as web se
 
 ## Supported Python versions
 
-This version of the LaunchDarkly provider works with Python 3.9 and above.
+This version of the LaunchDarkly provider works with Python 3.10 and above.
 
 ## Feature matrix
 
@@ -66,7 +66,7 @@ This matrix mirrors the [feature matrix of the OpenFeature SDK for Python](https
 | ✅      | Domains                         | Domains bind clients to providers in the OpenFeature SDK; a separate provider instance may be registered per domain.                                                                                                       |
 | ✅      | Eventing                        | LaunchDarkly data source status changes are emitted as `PROVIDER_READY`, `PROVIDER_STALE` and `PROVIDER_ERROR`, and only when the status changes; flag changes as `PROVIDER_CONFIGURATION_CHANGED` with the changed flag key.                              |
 | ✅      | Tracking                        | `track` sends a LaunchDarkly custom event for the evaluation context, with the tracking event value and remaining details attached.                                                                                        |
-| ✅      | Initialization                  | `initialize` reports whether the LaunchDarkly client became ready. The optional `start_wait` parameter bounds initialization; zero applies no timeout and waits until the data source becomes valid or permanently fails. |
+| ✅      | Initialization                  | `initialize` reports whether the LaunchDarkly client became ready. The optional `start_wait` parameter bounds initialization; `None` waits until the data source becomes valid or permanently fails. Since LaunchDarkly Python SDK 9.18.0 a rejected SDK key is retried rather than failing permanently, so `None` can wait indefinitely.                        |
 | ✅      | Shutdown                        | `shutdown` closes the LaunchDarkly client; a closed client cannot be restarted, so a new provider instance is required afterward.                                                                                          |
 | ✅      | Transaction Context Propagation | Provided by the OpenFeature SDK, which merges the transaction context into the evaluation context before the provider is called; no provider support is required.                                                          |
 | ✅      | Extending                       | The underlying LaunchDarkly client is available through the `client` property.                                                                                                                                            |
@@ -97,7 +97,9 @@ api.set_provider(openfeature_provider)
 # Refer to OpenFeature documentation for getting a client and performing evaluations.
 ```
 
-The optional `start_wait` parameter is the number of seconds to wait for a successful connection to LaunchDarkly, matching the same parameter of the LaunchDarkly SDK's `LDClient`, and defaulting to the same five seconds. A positive value bounds the whole of initialization: the provider constructor blocks for up to that long, and OpenFeature initialization then completes immediately, reporting a failed initialization if the client did not become ready in time. Zero does not block the constructor at all, and initialization then waits without a deadline for the data source to become valid or to fail permanently.
+The optional `start_wait` parameter is the number of seconds to wait for a successful connection to LaunchDarkly, matching the same parameter of the LaunchDarkly SDK's `LDClient`, and defaulting to the same five seconds. A positive value bounds the whole of initialization: the provider constructor blocks for up to that long, and OpenFeature initialization then completes immediately, reporting a failed initialization if the client did not become ready in time. Zero waits nowhere, so initialization fails unless the client is already ready, and the application learns when the client becomes usable from provider events. `None` requests waiting indefinitely: the constructor does not block, and initialization waits without a deadline for the data source to become valid or to fail permanently. Since LaunchDarkly Python SDK 9.18.0 a rejected SDK key is retried rather than treated as a permanent failure, so with `None`, initialization does not complete while the key is rejected.
+
+`api.set_provider` registers the provider without waiting for it to initialize, so the first evaluations may use fallback values while the LaunchDarkly client is still connecting. Use `api.set_provider_and_wait` instead when the application needs registration to block until initialization has succeeded or failed.
 
 Refer to the [SDK reference guide](https://docs.launchdarkly.com/sdk/server-side/python) for instructions on getting started with using the SDK.
 

{launchdarkly_openfeature_server-0.8.2 → launchdarkly_openfeature_server-0.9.0}/README.md

@@ -24,7 +24,7 @@ This provider is designed primarily for use in multi-user systems such as web se
 
 ## Supported Python versions
 
-This version of the LaunchDarkly provider works with Python 3.9 and above.
+This version of the LaunchDarkly provider works with Python 3.10 and above.
 
 ## Feature matrix
 
@@ -39,7 +39,7 @@ This matrix mirrors the [feature matrix of the OpenFeature SDK for Python](https
 | ✅      | Domains                         | Domains bind clients to providers in the OpenFeature SDK; a separate provider instance may be registered per domain.                                                                                                       |
 | ✅      | Eventing                        | LaunchDarkly data source status changes are emitted as `PROVIDER_READY`, `PROVIDER_STALE` and `PROVIDER_ERROR`, and only when the status changes; flag changes as `PROVIDER_CONFIGURATION_CHANGED` with the changed flag key.                              |
 | ✅      | Tracking                        | `track` sends a LaunchDarkly custom event for the evaluation context, with the tracking event value and remaining details attached.                                                                                        |
-| ✅      | Initialization                  | `initialize` reports whether the LaunchDarkly client became ready. The optional `start_wait` parameter bounds initialization; zero applies no timeout and waits until the data source becomes valid or permanently fails. |
+| ✅      | Initialization                  | `initialize` reports whether the LaunchDarkly client became ready. The optional `start_wait` parameter bounds initialization; `None` waits until the data source becomes valid or permanently fails. Since LaunchDarkly Python SDK 9.18.0 a rejected SDK key is retried rather than failing permanently, so `None` can wait indefinitely.                        |
 | ✅      | Shutdown                        | `shutdown` closes the LaunchDarkly client; a closed client cannot be restarted, so a new provider instance is required afterward.                                                                                          |
 | ✅      | Transaction Context Propagation | Provided by the OpenFeature SDK, which merges the transaction context into the evaluation context before the provider is called; no provider support is required.                                                          |
 | ✅      | Extending                       | The underlying LaunchDarkly client is available through the `client` property.                                                                                                                                            |
@@ -70,7 +70,9 @@ api.set_provider(openfeature_provider)
 # Refer to OpenFeature documentation for getting a client and performing evaluations.
 ```
 
-The optional `start_wait` parameter is the number of seconds to wait for a successful connection to LaunchDarkly, matching the same parameter of the LaunchDarkly SDK's `LDClient`, and defaulting to the same five seconds. A positive value bounds the whole of initialization: the provider constructor blocks for up to that long, and OpenFeature initialization then completes immediately, reporting a failed initialization if the client did not become ready in time. Zero does not block the constructor at all, and initialization then waits without a deadline for the data source to become valid or to fail permanently.
+The optional `start_wait` parameter is the number of seconds to wait for a successful connection to LaunchDarkly, matching the same parameter of the LaunchDarkly SDK's `LDClient`, and defaulting to the same five seconds. A positive value bounds the whole of initialization: the provider constructor blocks for up to that long, and OpenFeature initialization then completes immediately, reporting a failed initialization if the client did not become ready in time. Zero waits nowhere, so initialization fails unless the client is already ready, and the application learns when the client becomes usable from provider events. `None` requests waiting indefinitely: the constructor does not block, and initialization waits without a deadline for the data source to become valid or to fail permanently. Since LaunchDarkly Python SDK 9.18.0 a rejected SDK key is retried rather than treated as a permanent failure, so with `None`, initialization does not complete while the key is rejected.
+
+`api.set_provider` registers the provider without waiting for it to initialize, so the first evaluations may use fallback values while the LaunchDarkly client is still connecting. Use `api.set_provider_and_wait` instead when the application needs registration to block until initialization has succeeded or failed.
 
 Refer to the [SDK reference guide](https://docs.launchdarkly.com/sdk/server-side/python) for instructions on getting started with using the SDK.
 

{launchdarkly_openfeature_server-0.8.2 → launchdarkly_openfeature_server-0.9.0}/ld_openfeature/provider.py

@@ -10,7 +10,7 @@ from openfeature.exception import ErrorCode, ProviderNotReadyError
 from openfeature.flag_evaluation import FlagResolutionDetails, FlagType, FlagValueType, Reason
 from openfeature.hook import Hook
 from openfeature.provider.metadata import Metadata
-from openfeature.provider import AbstractProvider
+from openfeature.provider import AbstractProvider, ProviderStatus
 from openfeature.event import ProviderEventDetails
 from openfeature.track import TrackingEventDetails
 
@@ -26,7 +26,7 @@ logger = getLogger("launchdarkly-openfeature-server")
 
 
 class LaunchDarklyProvider(AbstractProvider):
-    def __init__(self, config: Config, start_wait: float = 5):
+    def __init__(self, config: Config, start_wait: Optional[float] = 5):
         """
         Create a provider backed by a LaunchDarkly client.
 
@@ -34,18 +34,20 @@ class LaunchDarklyProvider(AbstractProvider):
         :param start_wait: The number of seconds to wait for a successful connection to LaunchDarkly, matching
             the same parameter of :class:`ldclient.LDClient`. A positive value bounds the whole of initialization:
             this constructor blocks for up to that long, and ``initialize`` then completes immediately, reporting
-            a failed initialization if the client did not become ready in time. Zero does not block this
-            constructor at all, and ``initialize`` then waits without a deadline for the data source to become
-            valid or to fail permanently.
+            a failed initialization if the client did not become ready in time. Zero waits nowhere, so
+            ``initialize`` reports a failed initialization unless the client is already ready. ``None`` waits
+            only in ``initialize``, without a deadline, until the data source becomes valid or fails permanently.
         """
-        self.__client = LDClient(config.with_wrapper_information(WRAPPER_NAME, VERSION), start_wait)
+        self.__client = LDClient(config.with_wrapper_information(WRAPPER_NAME, VERSION),
+                                 0 if start_wait is None else start_wait)
         self.__start_wait = start_wait
+        self.__initialization_complete = False
+        self.__status_lock = threading.Lock()
+        self.__provider_status = ProviderStatus.NOT_READY
 
         self.__context_converter = EvaluationContextConverter()
         self.__details_converter = ResolutionDetailsConverter()
 
-        self.__status_lock = threading.Lock()
-        self.__last_emitted_state: Optional[DataSourceState] = None
 
     @property
     def client(self) -> LDClient:
@@ -56,39 +58,40 @@ class LaunchDarklyProvider(AbstractProvider):
         """
         return self.__client
 
-    def __is_new_status(self, state: DataSourceState) -> bool:
+    def __set_status(self, status: ProviderStatus) -> bool:
         """
-        Report whether a state changes the provider status. Several data source states can map to the same provider
-        status, and a repeated status is not a change an application can act on.
+        Record the provider status and report whether it changed, and whether the change should be emitted.
+
+        The OpenFeature client emits an event for the status change which completes initialization, so that
+        change is not emitted here. Changes after initialization has completed, including after it has failed,
+        are emitted.
         """
         with self.__status_lock:
-            if state == self.__last_emitted_state:
+            if status == self.__provider_status:
                 return False
-
-            self.__last_emitted_state = state
-            return True
+            self.__provider_status = status
+            return self.__initialization_complete
 
     def __handle_data_source_status(self, status: DataSourceStatus):
         state = status.state
         if state == DataSourceState.INITIALIZING:
             return
-
-        if not self.__is_new_status(state):
-            return
-
-        if state == DataSourceState.VALID:
-            self.emit_provider_ready(ProviderEventDetails())
+        elif state == DataSourceState.VALID:
+            if self.__set_status(ProviderStatus.READY):
+                self.emit_provider_ready(ProviderEventDetails())
         elif state == DataSourceState.OFF:
             error_message = self.__get_message(status,
                                                "the provider has encountered a permanent error or has been shutdown")
             # This is not reported as a fatal error. A fatal provider prevents the OpenFeature client
             # from evaluating flags at all, but the LaunchDarkly client can keep evaluating the flag
             # data it already has.
-            self.emit_provider_error(ProviderEventDetails(error_code=ErrorCode.GENERAL,
-                                                          message=error_message))
+            if self.__set_status(ProviderStatus.ERROR):
+                self.emit_provider_error(ProviderEventDetails(error_code=ErrorCode.GENERAL,
+                                                              message=error_message))
         elif state == DataSourceState.INTERRUPTED:
             error_message = self.__get_message(status, "encountered an unknown error")
-            self.emit_provider_stale(ProviderEventDetails(message=error_message))
+            if self.__set_status(ProviderStatus.STALE):
+                self.emit_provider_stale(ProviderEventDetails(message=error_message))
 
         # For now treat an unknown state as no change.
 
@@ -105,7 +108,11 @@ class LaunchDarklyProvider(AbstractProvider):
             elif status.state == DataSourceState.OFF:
                 ready_event.set()
 
-        # We listen just to handle the ready event. We do not emit events because the client emits them for us.
+        # We listen for status changes before checking the current state, so that a change in between is not
+        # missed. Emission is suppressed until initialization has completed, so the listeners stay registered
+        # even when initialization fails and the client later recovers.
+        self.__client.data_source_status_provider.add_listener(self.__handle_data_source_status)
+        self.__client.flag_tracker.add_listener(self.__handle_flag_change)
         self.__client.data_source_status_provider.add_listener(ready_handler)
 
         # Check for conditions that may have happened before we added the listener.
@@ -116,17 +123,22 @@ class LaunchDarklyProvider(AbstractProvider):
             ready_event.set()
 
         # With a start wait the client constructor has already waited, so the outcome is whatever it is now.
-        if self.__start_wait <= 0:
+        if self.__start_wait is None:
             ready_event.wait()
 
         self.__client.data_source_status_provider.remove_listener(ready_handler)
 
-        if not self.__client.is_initialized():
-            raise ProviderNotReadyError(error_message="launchdarkly client initialization failed")
+        # The OpenFeature client reports the outcome of initialization itself, so the provider records the
+        # resulting status without emitting an event for it. The outcome is read and recorded, and initialization
+        # is completed, under the lock, so a concurrent status change either precedes the outcome it is included
+        # in or is emitted.
+        with self.__status_lock:
+            initialized = self.__client.is_initialized()
+            self.__provider_status = ProviderStatus.READY if initialized else ProviderStatus.ERROR
+            self.__initialization_complete = True
 
-        # Listen to new status events and emit them.
-        self.__client.data_source_status_provider.add_listener(self.__handle_data_source_status)
-        self.__client.flag_tracker.add_listener(self.__handle_flag_change)
+        if not initialized:
+            raise ProviderNotReadyError(error_message="launchdarkly client initialization failed")
 
     def shutdown(self):
         self.__client.data_source_status_provider.remove_listener(self.__handle_data_source_status)

launchdarkly_openfeature_server-0.9.0/ld_openfeature/version.py

@@ -0,0 +1 @@
+VERSION = "0.9.0"  # x-release-please-version

{launchdarkly_openfeature_server-0.8.2 → launchdarkly_openfeature_server-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "launchdarkly-openfeature-server"
-version = "0.8.2"
+version = "0.9.0"
 description = "An OpenFeature provider for the LaunchDarkly Python server SDK"
 authors = ["LaunchDarkly <dev@launchdarkly.com>"]
 license = "Apache-2.0"
@@ -16,6 +16,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development",
     "Topic :: Software Development :: Libraries",
 ]
@@ -27,7 +28,7 @@ packages = [
 [tool.poetry.dependencies]
 python = "^3.10"
 openfeature-sdk = ">=0.9.0,<1"
-launchdarkly-server-sdk = ">=9.17.0,<10"
+launchdarkly-server-sdk = ">=9.18.3,<10"
 
 
 [tool.poetry.group.dev.dependencies]
@@ -44,7 +45,6 @@ optional = true
 [tool.poetry.group.docs.dependencies]
 sphinx = "^6.0.0"
 sphinx-rtd-theme = ">=1.3,<3.0"
-certifi = ">=2018.4.16"
 expiringdict = ">=1.1.4"
 pyrfc3339 = ">=1.0"
 jsonpickle = ">1.4.1"

launchdarkly_openfeature_server-0.8.2/ld_openfeature/version.py

@@ -1 +0,0 @@
-VERSION = "0.8.2"  # x-release-please-version