configdirector-openfeature-server-provider 1.0.0__tar.gz

configdirector_openfeature_server_provider-1.0.0/.gitignore

@@ -0,0 +1,30 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+
+build/
+dist/
+
+.venv/
+venv/
+
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+coverage.xml
+htmlcov/
+
+# Sample apps and the profiling harness resolve the SDK from a local path, so their locks are
+# not portable.
+samples/*/*/uv.lock
+profiling/uv.lock
+.env
+
+.DS_Store
+.idea/
+*.swp
+.claude
+.vscode

configdirector_openfeature_server_provider-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ConfigDirector
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

configdirector_openfeature_server_provider-1.0.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.5
+Name: configdirector-openfeature-server-provider
+Version: 1.0.0
+Summary: OpenFeature server provider for ConfigDirector. ConfigDirector is a remote configuration and feature flag service.
+Project-URL: Homepage, https://www.configdirector.com
+Project-URL: Documentation, https://docs.configdirector.com/sdks/openfeature/python
+Project-URL: Repository, https://github.com/ConfigDirector/python-server-sdk
+Project-URL: Changelog, https://github.com/ConfigDirector/python-server-sdk/blob/main/configdirector-openfeature-server-provider/CHANGELOG.md
+Project-URL: Support, https://www.configdirector.com/support
+Author: ConfigDirector
+License-Expression: MIT
+License-File: LICENSE
+Keywords: config,configdirector,configuration,feature flag,feature switch,feature toggle,openfeature,openfeature provider,openfeature server provider,provider,remote config,remote configuration,server
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: configdirector-server-sdk<2,>=1.2
+Requires-Dist: openfeature-sdk<1,>=0.8.2
+Description-Content-Type: text/markdown
+
+# ConfigDirector OpenFeature Python Server Provider
+
+[![CI][ci-badge]][ci] [![PyPI][pypi-badge]][pypi]
+
+[OpenFeature](https://openfeature.dev) Python server provider for [ConfigDirector](https://www.configdirector.com), remote config and feature flags with typed values, JSON Schema validation, and safe renames of live flags. It wraps the [ConfigDirector Python server SDK](https://pypi.org/project/configdirector-server-sdk/) and requires Python 3.10 or newer.
+
+## Install
+
+```bash
+pip install configdirector-openfeature-server-provider
+```
+
+The OpenFeature Python SDK (`openfeature-sdk`) and the ConfigDirector Python server SDK come with it as dependencies.
+
+## Retrieve a value
+
+```python
+from configdirector_openfeature import ConfigDirectorProvider
+from openfeature import api
+
+# The server SDK key is a secret. Do not commit it to your source code.
+api.set_provider_and_wait(ConfigDirectorProvider("YOUR-SERVER-SDK-KEY"))
+client = api.get_client()
+
+new_checkout = client.get_boolean_value("new-checkout", False)
+```
+
+`set_provider_and_wait` needs `openfeature-sdk` 0.10 or newer. On an older version use `api.set_provider`, which waits for the provider to initialize there.
+
+The provider accepts the same `metadata`, `connection`, `logger`, `log_level`, and `telemetry` options as the server SDK's `create_client`.
+
+## Evaluation context
+
+The OpenFeature evaluation context maps onto the ConfigDirector context used by targeting rules:
+
+| OpenFeature | ConfigDirector |
+|---|---|
+| `targeting_key`, or failing that an `id` attribute | `id` |
+| `name` attribute | `name` |
+| `traits` attribute, a mapping | `traits` |
+| `anonymous` attribute, a boolean | `anonymous` |
+
+```python
+from openfeature.evaluation_context import EvaluationContext
+
+context = EvaluationContext("user-123", {"name": "Ada", "traits": {"plan": "pro"}})
+new_checkout = client.get_boolean_value("new-checkout", False, context)
+```
+
+## Evaluation details
+
+| Outcome | `reason` | `error_code` |
+|---|---|---|
+| A value was evaluated | `TARGETING_MATCH`, with the value's id as the `variant` | |
+| The config has no value | `DEFAULT` | |
+| No config has that key | `ERROR` | `FLAG_NOT_FOUND` |
+| The value does not match the requested type | `ERROR` | `TYPE_MISMATCH` |
+| No config state has been received yet | `ERROR` | `PROVIDER_NOT_READY` |
+
+If the first config state does not arrive within the configured timeout, initialization still completes and evaluations return their defaults. The provider keeps connecting, and emits `PROVIDER_READY` once config state arrives. It emits `PROVIDER_CONFIGURATION_CHANGED`, with the keys that changed, whenever configs are updated.
+
+## Documentation
+
+Refer to the [official documentation for the OpenFeature Python provider](https://docs.configdirector.com/sdks/openfeature/python).
+
+There is also [a quickstart guide for ConfigDirector and any of our SDKs](https://docs.configdirector.com/getting-started/quickstart).
+
+## Sample apps
+
+[`samples/configdirector-openfeature-server-provider/`](https://github.com/ConfigDirector/python-server-sdk/tree/main/samples/configdirector-openfeature-server-provider) holds small, runnable applications built on this provider. Start with [`flask`](https://github.com/ConfigDirector/python-server-sdk/tree/main/samples/configdirector-openfeature-server-provider/flask):
+
+```bash
+cd samples/configdirector-openfeature-server-provider/flask
+uv run flask --app app run --port 3600
+```
+
+## Getting Help
+
+- [Ask a question in Discussions](https://github.com/orgs/ConfigDirector/discussions)
+- [Contact support](https://www.configdirector.com/support)
+
+[//]: # "links"
+[ci-badge]: https://github.com/ConfigDirector/python-server-sdk/actions/workflows/ci.yml/badge.svg
+[ci]: https://github.com/ConfigDirector/python-server-sdk/actions/workflows/ci.yml
+[pypi-badge]: https://img.shields.io/pypi/v/configdirector-openfeature-server-provider
+[pypi]: https://pypi.org/project/configdirector-openfeature-server-provider/

configdirector_openfeature_server_provider-1.0.0/README.md

@@ -0,0 +1,86 @@
+# ConfigDirector OpenFeature Python Server Provider
+
+[![CI][ci-badge]][ci] [![PyPI][pypi-badge]][pypi]
+
+[OpenFeature](https://openfeature.dev) Python server provider for [ConfigDirector](https://www.configdirector.com), remote config and feature flags with typed values, JSON Schema validation, and safe renames of live flags. It wraps the [ConfigDirector Python server SDK](https://pypi.org/project/configdirector-server-sdk/) and requires Python 3.10 or newer.
+
+## Install
+
+```bash
+pip install configdirector-openfeature-server-provider
+```
+
+The OpenFeature Python SDK (`openfeature-sdk`) and the ConfigDirector Python server SDK come with it as dependencies.
+
+## Retrieve a value
+
+```python
+from configdirector_openfeature import ConfigDirectorProvider
+from openfeature import api
+
+# The server SDK key is a secret. Do not commit it to your source code.
+api.set_provider_and_wait(ConfigDirectorProvider("YOUR-SERVER-SDK-KEY"))
+client = api.get_client()
+
+new_checkout = client.get_boolean_value("new-checkout", False)
+```
+
+`set_provider_and_wait` needs `openfeature-sdk` 0.10 or newer. On an older version use `api.set_provider`, which waits for the provider to initialize there.
+
+The provider accepts the same `metadata`, `connection`, `logger`, `log_level`, and `telemetry` options as the server SDK's `create_client`.
+
+## Evaluation context
+
+The OpenFeature evaluation context maps onto the ConfigDirector context used by targeting rules:
+
+| OpenFeature | ConfigDirector |
+|---|---|
+| `targeting_key`, or failing that an `id` attribute | `id` |
+| `name` attribute | `name` |
+| `traits` attribute, a mapping | `traits` |
+| `anonymous` attribute, a boolean | `anonymous` |
+
+```python
+from openfeature.evaluation_context import EvaluationContext
+
+context = EvaluationContext("user-123", {"name": "Ada", "traits": {"plan": "pro"}})
+new_checkout = client.get_boolean_value("new-checkout", False, context)
+```
+
+## Evaluation details
+
+| Outcome | `reason` | `error_code` |
+|---|---|---|
+| A value was evaluated | `TARGETING_MATCH`, with the value's id as the `variant` | |
+| The config has no value | `DEFAULT` | |
+| No config has that key | `ERROR` | `FLAG_NOT_FOUND` |
+| The value does not match the requested type | `ERROR` | `TYPE_MISMATCH` |
+| No config state has been received yet | `ERROR` | `PROVIDER_NOT_READY` |
+
+If the first config state does not arrive within the configured timeout, initialization still completes and evaluations return their defaults. The provider keeps connecting, and emits `PROVIDER_READY` once config state arrives. It emits `PROVIDER_CONFIGURATION_CHANGED`, with the keys that changed, whenever configs are updated.
+
+## Documentation
+
+Refer to the [official documentation for the OpenFeature Python provider](https://docs.configdirector.com/sdks/openfeature/python).
+
+There is also [a quickstart guide for ConfigDirector and any of our SDKs](https://docs.configdirector.com/getting-started/quickstart).
+
+## Sample apps
+
+[`samples/configdirector-openfeature-server-provider/`](https://github.com/ConfigDirector/python-server-sdk/tree/main/samples/configdirector-openfeature-server-provider) holds small, runnable applications built on this provider. Start with [`flask`](https://github.com/ConfigDirector/python-server-sdk/tree/main/samples/configdirector-openfeature-server-provider/flask):
+
+```bash
+cd samples/configdirector-openfeature-server-provider/flask
+uv run flask --app app run --port 3600
+```
+
+## Getting Help
+
+- [Ask a question in Discussions](https://github.com/orgs/ConfigDirector/discussions)
+- [Contact support](https://www.configdirector.com/support)
+
+[//]: # "links"
+[ci-badge]: https://github.com/ConfigDirector/python-server-sdk/actions/workflows/ci.yml/badge.svg
+[ci]: https://github.com/ConfigDirector/python-server-sdk/actions/workflows/ci.yml
+[pypi-badge]: https://img.shields.io/pypi/v/configdirector-openfeature-server-provider
+[pypi]: https://pypi.org/project/configdirector-openfeature-server-provider/

configdirector_openfeature_server_provider-1.0.0/pyproject.toml

@@ -0,0 +1,101 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "configdirector-openfeature-server-provider"
+dynamic = ["version"]
+description = "OpenFeature server provider for ConfigDirector. ConfigDirector is a remote configuration and feature flag service."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "ConfigDirector" }]
+keywords = [
+  "configdirector",
+  "openfeature server provider",
+  "openfeature provider",
+  "openfeature",
+  "server",
+  "provider",
+  "config",
+  "configuration",
+  "remote config",
+  "remote configuration",
+  "feature flag",
+  "feature toggle",
+  "feature switch",
+]
+classifiers = [
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed",
+]
+
+dependencies = [
+  "configdirector-server-sdk>=1.2,<2",
+  "openfeature-sdk>=0.8.2,<1",
+]
+
+[project.urls]
+Homepage = "https://www.configdirector.com"
+Documentation = "https://docs.configdirector.com/sdks/openfeature/python"
+Repository = "https://github.com/ConfigDirector/python-server-sdk"
+Changelog = "https://github.com/ConfigDirector/python-server-sdk/blob/main/configdirector-openfeature-server-provider/CHANGELOG.md"
+Support = "https://www.configdirector.com/support"
+
+[dependency-groups]
+dev = [
+  "mypy>=1.14",
+  "pytest>=8.3",
+  "pytest-cov>=6.0",
+  "pytest-timeout>=2.3",
+]
+
+[tool.uv.sources]
+configdirector-server-sdk = { workspace = true }
+
+[tool.hatch.version]
+path = "src/configdirector_openfeature/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/configdirector_openfeature"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/configdirector_openfeature", "README.md", "LICENSE"]
+
+[tool.ruff]
+# Inherit the repository's style, but resolve first-party imports against this package so that
+# `configdirector` sorts as the third-party dependency it is here.
+extend = "../pyproject.toml"
+src = ["src", "."]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["src", "tests"]
+strict = true
+warn_unreachable = true
+enable_error_code = ["redundant-expr", "possibly-undefined", "truthy-bool"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra --strict-markers --strict-config --timeout=60 --timeout-method=thread"
+xfail_strict = true
+
+[tool.coverage.run]
+source = ["src/configdirector_openfeature"]
+branch = true
+
+[tool.coverage.report]
+exclude_lines = [
+  "pragma: no cover",
+  "raise NotImplementedError",
+  "if TYPE_CHECKING:",
+  "\\.\\.\\.",
+]

configdirector_openfeature_server_provider-1.0.0/src/configdirector_openfeature/__init__.py

@@ -0,0 +1,19 @@
+"""OpenFeature server provider for ConfigDirector.
+
+ConfigDirector is a remote configuration and feature flag service.
+
+Example::
+
+    from configdirector_openfeature import ConfigDirectorProvider
+    from openfeature import api
+
+    api.set_provider_and_wait(ConfigDirectorProvider("YOUR-SERVER-SDK-KEY"))
+
+    if api.get_client().get_boolean_value("new-checkout", False):
+        ...
+"""
+
+from ._version import __version__
+from .provider import ConfigDirectorProvider
+
+__all__ = ["ConfigDirectorProvider", "__version__"]

configdirector_openfeature_server_provider-1.0.0/src/configdirector_openfeature/_context.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from configdirector import Context
+from openfeature.evaluation_context import EvaluationContext
+
+from ._values import to_plain
+
+__all__ = ["to_context"]
+
+
+def to_context(evaluation_context: EvaluationContext | None) -> Context | None:
+    if evaluation_context is None:
+        return None
+
+    attributes = evaluation_context.attributes
+    traits = attributes.get("traits")
+    anonymous = attributes.get("anonymous")
+
+    return Context(
+        id=_identifier(evaluation_context),
+        name=_text(attributes.get("name")),
+        traits=to_plain(traits) if isinstance(traits, Mapping) and traits else None,
+        anonymous=anonymous if isinstance(anonymous, bool) else False,
+    )
+
+
+def _identifier(evaluation_context: EvaluationContext) -> str | None:
+    if evaluation_context.targeting_key is not None:
+        return evaluation_context.targeting_key
+    return _text(evaluation_context.attributes.get("id"))
+
+
+def _text(value: Any) -> str | None:
+    if value is None or isinstance(value, Mapping):
+        return None
+    if isinstance(value, str):
+        return value
+    if isinstance(value, Sequence):
+        return None
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(to_plain(value))

configdirector_openfeature_server_provider-1.0.0/src/configdirector_openfeature/_resolution.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import TypeVar
+
+from configdirector import ConfigEvaluation
+from openfeature.exception import ErrorCode
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+
+__all__ = ["to_resolution_details"]
+
+T = TypeVar("T")
+
+
+def to_resolution_details(value: T, evaluation: ConfigEvaluation | None) -> FlagResolutionDetails[T]:
+    if evaluation is None:
+        return FlagResolutionDetails(value=value)
+
+    if evaluation.reason == "found-match":
+        return FlagResolutionDetails(value=value, variant=evaluation.value_id, reason=Reason.TARGETING_MATCH)
+    if evaluation.reason == "value-missing":
+        return FlagResolutionDetails(value=value, reason=Reason.DEFAULT)
+    if evaluation.reason == "config-state-missing":
+        return _error(
+            value, ErrorCode.FLAG_NOT_FOUND, f"No config with the key '{evaluation.key}' was found."
+        )
+    if evaluation.reason == "client-not-ready":
+        return _error(
+            value,
+            ErrorCode.PROVIDER_NOT_READY,
+            "The ConfigDirector client has not received any configs yet.",
+        )
+    if evaluation.is_default:
+        return _error(
+            value,
+            ErrorCode.TYPE_MISMATCH,
+            f"The value of '{evaluation.key}' does not match the requested type ({evaluation.reason}).",
+        )
+    return FlagResolutionDetails(value=value)
+
+
+def _error(value: T, error_code: ErrorCode, message: str) -> FlagResolutionDetails[T]:
+    return FlagResolutionDetails(
+        value=value, reason=Reason.ERROR, error_code=error_code, error_message=message
+    )

configdirector_openfeature_server_provider-1.0.0/src/configdirector_openfeature/_values.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from datetime import datetime
+from typing import Any
+
+__all__ = ["to_plain"]
+
+
+def to_plain(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(key): to_plain(entry) for key, entry in value.items()}
+    if isinstance(value, (str, bytes)):
+        return value
+    if isinstance(value, Sequence):
+        return [to_plain(item) for item in value]
+    if isinstance(value, datetime):
+        return value.isoformat()
+    return value

configdirector_openfeature_server_provider-1.0.0/src/configdirector_openfeature/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

configdirector_openfeature_server_provider-1.0.0/src/configdirector_openfeature/provider.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import threading
+from collections.abc import Mapping, Sequence
+from contextvars import ContextVar
+from typing import TypeVar
+
+from configdirector import (
+    ClientHooks,
+    ClientReadyEvent,
+    ConfigDirectorLogger,
+    ConfigEvaluatedEvent,
+    ConfigEvaluation,
+    ConfigsUpdatedEvent,
+    ConfigValue,
+    ConnectionOptions,
+    Metadata,
+    TelemetryOptions,
+)
+from configdirector._wrappers import Wrapper, create_wrapped_client
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType
+from openfeature.provider import AbstractProvider
+from openfeature.provider import Metadata as ProviderMetadata
+
+from ._context import to_context
+from ._resolution import to_resolution_details
+from ._values import to_plain
+
+__all__ = ["ConfigDirectorProvider"]
+
+_NAME = "ConfigDirectorProvider"
+
+_ValueT = TypeVar("_ValueT", bound=ConfigValue)
+
+_evaluated: ContextVar[ConfigEvaluation | None] = ContextVar("configdirector_evaluated", default=None)
+
+
+class ConfigDirectorProvider(AbstractProvider):
+    """An OpenFeature provider backed by the ConfigDirector Python server SDK.
+
+    Register it with the OpenFeature API and read values through an OpenFeature client. The
+    provider owns a ConfigDirector client: it connects when OpenFeature initializes the provider,
+    and closes when OpenFeature shuts it down. Targeting rules are evaluated locally, so an
+    evaluation makes no network calls.
+
+    Example::
+
+        from configdirector_openfeature import ConfigDirectorProvider
+        from openfeature import api
+
+        api.set_provider_and_wait(ConfigDirectorProvider("YOUR-SERVER-SDK-KEY"))
+
+        enabled = api.get_client().get_boolean_value("new-checkout", False)
+
+    The OpenFeature evaluation context maps onto the ConfigDirector
+    :class:`~configdirector.Context`: the targeting key, or failing that an ``id`` attribute,
+    becomes the context's id, ``name`` its name, a ``traits`` mapping its traits, and a boolean
+    ``anonymous`` its anonymous flag.
+
+    If the first config state does not arrive within the configured timeout, initialization
+    still completes and evaluations return their defaults with the error code
+    ``PROVIDER_NOT_READY``. The provider keeps connecting, and emits ``PROVIDER_READY`` once
+    config state arrives.
+
+    Args:
+        server_sdk_key: Your ConfigDirector server SDK key. This is a secret value — do not
+            commit it to source control.
+        metadata: Metadata about your application. Supplying ``app_name`` and ``app_version`` is
+            recommended so that they can be referenced from targeting rules.
+        connection: Connection options such as mode, timeout, and polling interval.
+        logger: Any object implementing :class:`~configdirector.ConfigDirectorLogger`, including
+            a standard library :class:`logging.Logger`. Defaults to the standard library logger
+            named ``"configdirector"``.
+        log_level: A level to set on that default logger, as either a :mod:`logging` constant or
+            its name. Ignored when ``logger`` is supplied.
+        telemetry: Telemetry queue and flush tuning.
+
+    Raises:
+        configdirector.ConfigDirectorValidationError: If ``server_sdk_key`` is missing or empty,
+            or if a ``connection`` or ``telemetry`` setting is invalid.
+    """
+
+    def __init__(
+        self,
+        server_sdk_key: str,
+        *,
+        metadata: Metadata | None = None,
+        connection: ConnectionOptions | None = None,
+        logger: ConfigDirectorLogger | None = None,
+        log_level: int | str | None = None,
+        telemetry: TelemetryOptions | None = None,
+    ) -> None:
+        super().__init__()
+        self._lock = threading.Lock()
+        self._initialized = False
+        self._client = create_wrapped_client(
+            Wrapper.OPENFEATURE_SERVER_PROVIDER,
+            server_sdk_key,
+            metadata=metadata,
+            connection=connection,
+            logger=logger,
+            log_level=log_level,
+            telemetry=telemetry,
+            hooks=ClientHooks(
+                client_ready=self._on_client_ready,
+                configs_updated=self._on_configs_updated,
+                config_evaluated=self._on_config_evaluated,
+            ),
+        )
+
+    def get_metadata(self) -> ProviderMetadata:
+        """The name this provider is registered under with OpenFeature."""
+        return ProviderMetadata(name=_NAME)
+
+    def initialize(self, evaluation_context: EvaluationContext) -> None:
+        """Connects to ConfigDirector, waiting up to the configured timeout for config state."""
+        self._client.initialize()
+        with self._lock:
+            self._initialized = True
+
+    def shutdown(self) -> None:
+        """Closes the connection to ConfigDirector and flushes pending telemetry."""
+        self._client.close()
+
+    def resolve_boolean_details(
+        self,
+        flag_key: str,
+        default_value: bool,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[bool]:
+        """Evaluates ``flag_key`` as a boolean."""
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        flag_key: str,
+        default_value: str,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[str]:
+        """Evaluates ``flag_key`` as a string."""
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        flag_key: str,
+        default_value: int,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[int]:
+        """Evaluates ``flag_key`` as an integer."""
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        flag_key: str,
+        default_value: float,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[float]:
+        """Evaluates ``flag_key`` as a float."""
+        return self._resolve(flag_key, float(default_value), evaluation_context)
+
+    def resolve_object_details(
+        self,
+        flag_key: str,
+        default_value: Sequence[FlagValueType] | Mapping[str, FlagValueType],
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[Sequence[FlagValueType] | Mapping[str, FlagValueType]]:
+        """Evaluates ``flag_key`` as a JSON object or array."""
+        default: dict[str, FlagValueType] | list[FlagValueType] = to_plain(default_value)
+        return self._resolve(flag_key, default, evaluation_context)
+
+    def _resolve(
+        self, flag_key: str, default_value: _ValueT, evaluation_context: EvaluationContext | None
+    ) -> FlagResolutionDetails[_ValueT]:
+        _evaluated.set(None)
+        value = self._client.get_value(flag_key, default_value, to_context(evaluation_context))
+        return to_resolution_details(value, _evaluated.get())
+
+    def _on_config_evaluated(self, event: ConfigEvaluatedEvent) -> None:
+        _evaluated.set(event.evaluation)
+
+    def _on_configs_updated(self, event: ConfigsUpdatedEvent) -> None:
+        self.emit_provider_configuration_changed(ProviderEventDetails(flags_changed=list(event.keys)))
+
+    def _on_client_ready(self, _event: ClientReadyEvent) -> None:
+        with self._lock:
+            initialized = self._initialized
+        if initialized:
+            self.emit_provider_ready(ProviderEventDetails())