Python SDK - OpenFeature provider

westyx-nexus-openfeature ships NexusProvider, an AbstractProvider implementation for the OpenFeature Python SDK. The provider wraps an already-initialized NexusClient and delegates all evaluations to its in-memory cache. No additional I/O or network calls are made by the provider itself. Available since v0.8.0.

Installation

The provider is a separate package - install it alongside the main SDK:

pip install westyx-nexus-sdk westyx-nexus-openfeature

Both packages are hosted in the same GitLab PyPI registry. Add the registry URL first if you have not already done so (see Installation).

--extra-index-url https://gitlab.com/api/v4/projects/81978638/packages/pypi/simple
westyx-nexus-sdk==0.16.0
westyx-nexus-openfeature==0.16.0

Quick start

from westyx_nexus import NexusClient, NexusConfig
from nexus_openfeature import NexusProvider
from openfeature import api as openfeature_api

# 1. Initialize the Nexus client.
client = NexusClient.create(NexusConfig(
    base_url="https://blue-ocean-a5rx7.westyx.dev",
    api_key="wxs_...",
))

# 2. Register the provider once at startup.
openfeature_api.set_provider(NexusProvider(client))

# 3. Evaluate flags and configs using the standard OpenFeature API.
of_client = openfeature_api.get_client("my-service")

enabled = of_client.get_boolean_value("dark-mode", False)
theme   = of_client.get_string_value("ui.theme", "light")
retries = of_client.get_integer_value("http.max-retries", 3)
rate    = of_client.get_float_value("rate-limit.rps", 100.0)
rules   = of_client.get_object_value("routing-rules", {})

# 4. Close the client on shutdown.
client.close()

Evaluation mapping

OpenFeature method	Nexus call	On miss	On type mismatch
`get_boolean_value`	`find_flag(key)`, then `evaluate_ab` when the context carries a targeting key	`FLAG_NOT_FOUND`	n/a
`get_string_value`	`get_config(key)`	`FLAG_NOT_FOUND`	`TYPE_MISMATCH`
`get_integer_value`	`get_config(key)`	`FLAG_NOT_FOUND`	`TYPE_MISMATCH`
`get_float_value`	`get_config(key)`	`FLAG_NOT_FOUND`	`TYPE_MISMATCH`
`get_object_value`	`get_config(key)`	`FLAG_NOT_FOUND`	`TYPE_MISMATCH`

Integer evaluation accepts an int and an integral float (5.0); a bool, a string and 2.5 are a TYPE_MISMATCH. Float evaluation accepts an int and a float; a bool and a numeric string are a TYPE_MISMATCH.

Numbers are not coerced. int("7") is 7 and int(True) is 1 - bool is a subclass of int in Python - so converting would report a successful STATIC resolution carrying a value the config does not hold. JSON has a single number type, which is why an integral float still counts as an integer.

Per-user targeting

(v0.12.0+) A boolean evaluation carrying a targeting key is resolved through the AB Testing add-on, so the flag’s rollout percentage and cohort rules apply to that identity:

from openfeature.evaluation_context import EvaluationContext

ctx = EvaluationContext(targeting_key="user-abc", attributes={"plan": "pro"})
enabled = of_client.get_boolean_value("checkout-v2", False, ctx)

Without a targeting key the snapshot value is returned as before, so a consumer that passes no identity is unaffected. One request per identity. The provider asks about every flag the snapshot knows, not only the one being evaluated, so resolving five flags for one user costs one call. Requests are chunked at the endpoint’s 200-key limit, results are memoised per identity and flag (30 seconds by default), and concurrent evaluations for one identity coalesce into a single request.

Situation	Value	Reason
No targeting key	snapshot	`STATIC`
Flag not in the snapshot	your default	`DEFAULT` + `FLAG_NOT_FOUND`
Targeted result from the endpoint	per-user	`TARGETING_MATCH`
Served from the memo	per-user	`CACHED`
Request failed	snapshot	`STALE`
AB Testing add-on not active	snapshot	`STATIC`

A key the snapshot does not have is never sent: the endpoint answers false for a flag it does not know, so sending it would override a caller’s True default while reporting a successful targeted evaluation. A failed request answers with the snapshot value rather than an error, because the specification makes an error resolution return the caller’s default - which would report False for a flag that is genuinely on. Without the add-on the snapshot is authoritative, so that case is STATIC and the provider goes quiet for five minutes; the suppression expires on its own and any success clears it, so buying the add-on takes effect without a restart. Cohort attributes come from the context, string values only. A non-string attribute is dropped and named in the provider’s logger rather than stringified. The targeting key travels in its own request field and is not repeated as an attribute. Non-boolean resolutions read configs, which have no per-user dimension in Nexus, so they ignore the context.

Options

from nexus_openfeature import NexusProvider, NexusProviderOptions

provider = NexusProvider(
    client,
    NexusProviderOptions(
        targeting_ttl=30.0,         # how long one identity's results stay usable
        max_targeting_keys=10_000,  # cap on memoised identities, expired evicted first
        addon_suppression=300.0,    # quiet period after a 403
    ),
    logger=logging.getLogger("my-app.nexus"),
)

Every value is validated at construction, naming the option: a targeting_ttl of 0 accepted quietly would turn every evaluation into a network call.

Error details

Use get_*_details instead of get_*_value to inspect the full resolution:

details = of_client.get_string_details("ui.theme", "light")
if details.error_code:
    # FLAG_NOT_FOUND or TYPE_MISMATCH
    print(f"Evaluation error: {details.error_code} - {details.error_message}")
else:
    print(f"Value: {details.value} (reason: {details.reason})")

Overview

Backend SDKs

Browser SDKs

OpenFeature Providers

Python SDK - OpenFeature provider

Installation

Quick start

Evaluation mapping

Per-user targeting

Options

Error details

​Installation

​Quick start

​Evaluation mapping

​Per-user targeting

​Options

​Error details

Installation

Quick start

Evaluation mapping

Per-user targeting

Options

Error details