gofeatureflag-python-provider 1.2.0__tar.gz → 1.3.0__tar.gz

gofeatureflag_python_provider-1.3.0/AGENTS.md

@@ -0,0 +1,160 @@
+# GO Feature Flag Python Provider
+
+OpenFeature Python provider for [GO Feature Flag](https://gofeatureflag.org).
+
+## Project Overview
+
+This package implements the OpenFeature provider interface for GO Feature Flag.
+It supports two evaluation modes, selected with `options.evaluation_type`:
+
+- **In-process** _(default)_: the provider polls the relay proxy for the flag
+  configuration and evaluates flags locally through the embedded WASM
+  evaluation engine (`wasmtime`). No network call per evaluation.
+- **Remote**: every evaluation is delegated to the relay proxy through the
+  OpenFeature Remote Evaluation Protocol (OFREP), via the
+  `openfeature-provider-ofrep` package.
+
+There is **no evaluation-result cache** in either mode (the former `pylru`
+LRU cache and WebSocket invalidation were removed with the in-process
+rewrite). The cache is an optional capability in the provider specification;
+this provider does not implement it.
+
+## Architecture
+
+```
+gofeatureflag_python_provider/
+├── provider.py                 # GoFeatureFlagProvider (AbstractProvider impl), hook wiring, provider events
+├── options.py                  # GoFeatureFlagOptions configuration
+├── metadata.py                 # Provider metadata ("GO Feature Flag Provider")
+├── exceptions.py               # Provider exceptions
+├── utils.py                    # contextKind helpers etc.
+├── evaluator/
+│   ├── abstract_evaluator.py   # AbstractEvaluator interface (sync + async resolves, is_flag_trackable)
+│   ├── inprocess_evaluator.py  # Polls flag configuration, evaluates via WASM, remote fallback via OFREP
+│   ├── remote_evaluator.py     # Delegates every resolve to the OFREP provider; flags are never trackable
+│   └── util.py
+├── hooks/
+│   ├── data_collector.py       # Collects FeatureEvents for local evaluations (after/error)
+│   └── enrich_evaluation_context.py  # Adds the gofeatureflag metadata to the context before evaluation
+├── services/
+│   ├── api.py                  # HTTP client: flag configuration (ETag aware) + data collector
+│   ├── event_publisher.py      # Buffers events, bulk-flushes on interval/threshold/shutdown
+│   ├── ofrep.py                # Shared OFREP client construction (auth, headers, timeout)
+│   └── model/                  # Pydantic request/response models
+└── wasm/
+    ├── evaluate_wasm.py        # WASM evaluation entry point, instance pool, trap handling
+    ├── wasi_runtime.py         # wasmtime runtime setup
+    ├── errors/                 # Trap/pool/loading error types
+    ├── model/                  # WASM input/output models
+    └── gofeatureflag-evaluation_<version>.wasi  # Bundled engine (pinned in _wasi_version.txt)
+```
+
+## Key Components
+
+### GoFeatureFlagProvider (`provider.py`)
+- Extends `AbstractProvider`; delegates all `resolve_*_details` (sync and
+  async) to the evaluator chosen from `options.evaluation_type`.
+- Registers two provider hooks, in order: `EnrichEvaluationContextHook`, then
+  `DataCollectorHook` (the collector must observe the enriched context).
+- Emits provider events (`configuration changed`, `stale`, `ready`) from the
+  in-process polling loop.
+
+### GoFeatureFlagOptions (`options.py`)
+- `endpoint` (required): URL of the relay proxy
+- `evaluation_type`: `INPROCESS` (default) or `REMOTE`
+- `api_key`: sent as an `X-API-Key` header when set
+- `timeout`: HTTP timeout in ms (default: 10000)
+- `flag_config_poll_interval_seconds`: in-process polling interval (default: 120)
+- `evaluation_flag_list`: restrict fetched flag configuration (in-process only)
+- `wasm_file_path`, `wasm_pool_size`: WASM binary override / instance pool size
+  (default pool size: CPU core count)
+- `data_flush_interval` (ms, default 60000), `max_pending_events`
+  (default 10000), `disable_data_collection`, `exporter_metadata`,
+  `data_collector_base_url`: data collection tuning
+- `custom_headers`, `urllib3_pool_manager`, `log_level`
+
+### DataCollectorHook (`hooks/data_collector.py`)
+- Builds a `FeatureEvent` in `after()`/`error()` and enqueues it on the
+  `EventPublisher`.
+- Skips the event when data collection is disabled, when the evaluator reports
+  the flag as not trackable, or when the result carries the
+  `gofeatureflag_evaluated_remotely` metadata (the relay proxy already
+  recorded it — emitting would double count).
+- **Remote mode emits no feature events at all**: `RemoteEvaluator.
+  is_flag_trackable()` always returns `False` because every remote evaluation
+  is already recorded server-side. `source` is always `INPROCESS`.
+
+### EventPublisher (`services/event_publisher.py`)
+- Buffers events and bulk-posts them to `/v1/data/collector` on a periodic
+  interval, when the buffer reaches `max_pending_events`, and on shutdown.
+- Never posts an empty batch; failed batches are re-queued in order; the
+  buffer is capped at twice `max_pending_events` (oldest dropped first).
+
+## API Reference
+
+| Endpoint | Method | Purpose |
+|----------|--------|---------|
+| `/v1/flag/configuration` | POST | Fetch flag configuration (in-process; ETag/If-None-Match aware) |
+| `/ofrep/v1/evaluate/flags/{flag_key}` | POST | Remote evaluation via OFREP |
+| `/v1/data/collector` | POST | Bulk usage/evaluation data |
+
+## Development
+
+### Prerequisites
+- Python 3.9+
+- uv (package manager)
+- Docker (optional — only for the container-backed tests, which skip without it)
+
+### Setup and common commands
+```bash
+uv sync                  # Install dependencies
+uv run pytest            # Run all tests
+uv run pytest tests/test_inprocess_evaluator.py   # One file
+uv run black gofeatureflag_python_provider tests  # Format
+```
+
+## Key Patterns
+
+- **Pydantic models** for options and API payloads (`model_dump_json()` /
+  `model_validate_json()`).
+- **HTTP**: `urllib3.PoolManager` for flag configuration and data collection;
+  the OFREP client (built in `services/ofrep.py`) handles remote evaluation.
+  Both paths share auth/header/timeout construction.
+- **WASM**: `wasmtime.Store` is not thread-safe — evaluation uses an instance
+  pool; a trapped instance is poisoned and recycled, never reused.
+- **Error handling**: evaluators raise OpenFeature exceptions
+  (`FlagNotFoundError`, `TypeMismatchError`, `InvalidContextError`,
+  `GeneralError`); the SDK converts them into default-value results.
+
+## Tests
+
+Table of the main test files (pytest):
+
+| File | Covers |
+|------|--------|
+| `test_gofeatureflag_provider.py` | Provider end-to-end (remote mode) |
+| `test_gofeatureflag_provider_inprocess.py` | Provider end-to-end (in-process) |
+| `test_inprocess_evaluator.py` | In-process evaluator, polling, fallback |
+| `test_remote_evaluator_ofrep.py` | Remote evaluator delegation to OFREP |
+| `test_evaluate_wasm.py`, `test_wasm_trap_diagnosis.py` | WASM engine host, trap handling |
+| `test_data_collector_hook.py`, `test_event_publisher.py` | Data collection |
+| `test_options.py` | Options, including removal of the old cache options |
+| `test_services_api.py` | HTTP layer (ETag, status mapping) |
+| `test_integration_relayproxy.py` | Real evaluations against a containerised relay proxy (both modes) |
+
+### Container-backed tests
+
+Every test file above this one mocks the transport, so the recordings are only
+ever checked against themselves. `test_integration_relayproxy.py` boots a real
+relay proxy with [testcontainers](https://testcontainers.com) and evaluates
+through the public OpenFeature API in both evaluation modes, asserting the same
+expectations as the mocked tests — a mock that drifts from what the relay proxy
+serves fails there.
+
+The `relay_proxy` fixture (`tests/conftest.py`) generates the proxy's
+configuration from `tests/mock_responses/config/valid-all-types.json`, the same
+fixture the mocked in-process tests replay, and mounts it at `/goff/` (one of the
+relay proxy's default config locations). It waits on `GET /health` and binds a
+random host port, so it never collides with a proxy already running on 1031.
+
+The module **skips** when no Docker daemon is reachable. CI runs it by default.

{gofeatureflag_python_provider-1.2.0 → gofeatureflag_python_provider-1.3.0}/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [1.3.0](https://github.com/thomaspoignant/go-feature-flag/compare/openfeature/providers/python-provider/v1.2.0...openfeature/providers/python-provider/v1.3.0) (2026-09-01)
+
+
+### 🚀 New Features
+
+* **python-provider:** survive WASM traps and harden the wasm evaluation module ([bc37081](https://github.com/thomaspoignant/go-feature-flag/commit/bc37081f0314b18ffb41ebd74aea1d3b9872dd67))
+
+
+### 🐛 Bug Fixes
+
+* **sonar:** resolve SonarCloud issues reported on main ([#5797](https://github.com/thomaspoignant/go-feature-flag/issues/5797)) ([7314d1b](https://github.com/thomaspoignant/go-feature-flag/commit/7314d1b1934b25b169405dfc3a2ea0294b19924f))
+* **sonar:** resolve SonarCloud issues reported on main ([#5799](https://github.com/thomaspoignant/go-feature-flag/issues/5799)) ([e2da54a](https://github.com/thomaspoignant/go-feature-flag/commit/e2da54a0a7ebe44ade2d772d83c994d05af0228b))
+
+
+### 🔧 Chores
+
+* Bump github.com/aws/aws-sdk-go-v2 from 1.43.2 to 1.43.3 ([#5804](https://github.com/thomaspoignant/go-feature-flag/issues/5804)) ([5cd3520](https://github.com/thomaspoignant/go-feature-flag/commit/5cd352036f7fcc22edbe34d47af85f1c675eec9f))
+* Bump github.com/aws/aws-sdk-go-v2 from 1.43.5 to 1.43.7 ([#5923](https://github.com/thomaspoignant/go-feature-flag/issues/5923)) ([6e64093](https://github.com/thomaspoignant/go-feature-flag/commit/6e640937a0d8d2f107f9fc9af57386cf40672853))
+* Bump github.com/aws/aws-sdk-go-v2/service/s3 ([#5577](https://github.com/thomaspoignant/go-feature-flag/issues/5577)) ([02d42d7](https://github.com/thomaspoignant/go-feature-flag/commit/02d42d7ca089071c263fe5283ad3d01ce6365025))
+* Bump github.com/aws/aws-sdk-go-v2/service/s3 ([#5594](https://github.com/thomaspoignant/go-feature-flag/issues/5594)) ([4784dba](https://github.com/thomaspoignant/go-feature-flag/commit/4784dba83fd00f8472cd4bf87ec94264df7c0bfa))
+* Bump github.com/aws/aws-sdk-go-v2/service/s3 ([#5771](https://github.com/thomaspoignant/go-feature-flag/issues/5771)) ([e46119d](https://github.com/thomaspoignant/go-feature-flag/commit/e46119d953efe049174b5d87518824d1330fef8b))
+* Bump github.com/aws/aws-sdk-go-v2/service/s3 ([#5840](https://github.com/thomaspoignant/go-feature-flag/issues/5840)) ([b11fb03](https://github.com/thomaspoignant/go-feature-flag/commit/b11fb03abcba68ee2fc82ed98f838747fe406dca))
+* Bump github.com/aws/smithy-go from 1.27.5 to 1.27.6 ([#5807](https://github.com/thomaspoignant/go-feature-flag/issues/5807)) ([627e361](https://github.com/thomaspoignant/go-feature-flag/commit/627e3610e09f3bb48ed968d6d3d99a228a434ad8))
+* Bump github.com/aws/smithy-go from 1.27.7 to 1.27.8 ([#5895](https://github.com/thomaspoignant/go-feature-flag/issues/5895)) ([c7f9192](https://github.com/thomaspoignant/go-feature-flag/commit/c7f9192f1a3e69d6b837b8750917275d2078444e))
+
+
+### ⚙️ CI/CD
+
+* install Python provider deps from the committed uv.lock ([#5708](https://github.com/thomaspoignant/go-feature-flag/issues/5708)) ([c88351c](https://github.com/thomaspoignant/go-feature-flag/commit/c88351c885d45eb96d0e202586b2dae9ca726e34))
+
 ## [1.2.0](https://github.com/thomaspoignant/go-feature-flag/compare/openfeature/providers/python-provider/v1.1.0...openfeature/providers/python-provider/v1.2.0) (2026-07-02)
 
 

{gofeatureflag_python_provider-1.2.0 → gofeatureflag_python_provider-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: gofeatureflag-python-provider
-Version: 1.2.0
+Version: 1.3.0
 Summary: GO Feature Flag provider for OpenFeature
 Project-URL: Bug Tracker, https://github.com/thomaspoignant/go-feature-flag/issues
 Project-URL: Source Code, https://github.com/thomaspoignant/go-feature-flag/tree/main/openfeature/providers/python-provider
@@ -11,11 +11,11 @@ Keywords: feature flags,feature toggles,go-feature-flag,gofeatureflag,open-featu
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
-Requires-Dist: openfeature-provider-ofrep>=0.2.0
+Requires-Dist: openfeature-provider-ofrep>=0.3.0
 Requires-Dist: openfeature-sdk<0.11.0,>=0.8.4
-Requires-Dist: pydantic>=2.5.2
-Requires-Dist: urllib3>=2.1.0
-Requires-Dist: wasmtime>=41.0.0
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: urllib3>=2.7.0
+Requires-Dist: wasmtime>=47.0.1
 Description-Content-Type: text/markdown
 
 # GO Feature Flag Python Provider
@@ -133,16 +133,60 @@ else:
 |--------|------|---------|-------------|
 | `endpoint` | `str` | _(required)_ | URL of the GO Feature Flag relay proxy |
 | `evaluation_type` | `EvaluationType` | `INPROCESS` | Evaluation mode: `INPROCESS` or `REMOTE` |
-| `cache_size` | `int` | `10000` | Maximum number of flag evaluations kept in the LRU cache _(remote mode)_ |
+| `data_collector_base_url` | `str` | `endpoint` | Base URL of the data collector only. Replaces the whole base — scheme, host, port and path prefix. Flag configuration and evaluation keep using `endpoint` |
+| `timeout` | `int` | `10000` | Timeout (ms) for flag configuration, remote evaluation and data collection requests. Carried by the HTTP client the provider builds, so a custom `urllib3_pool_manager` replaces it with its own |
 | `data_flush_interval` | `int` | `60000` | Interval (ms) to flush usage data to the relay proxy |
 | `disable_data_collection` | `bool` | `False` | Set to `True` to disable usage analytics |
-| `reconnect_interval` | `int` | `60` | WebSocket reconnect interval (seconds) _(remote mode)_ |
-| `disable_cache_invalidation` | `bool` | `False` | Disable WebSocket-based cache invalidation _(remote mode)_ |
-| `flag_config_poll_interval_seconds` | `int` | `10` | Polling interval (seconds) for flag configuration _(in-process mode)_ |
-| `api_key` | `str` | `None` | API key for authenticated relay proxy requests |
-| `exporter_metadata` | `dict` | `{}` | Static metadata attached to evaluation events |
-| `max_pending_events` | `int` | `10000` | Maximum buffered events before a forced flush |
+| `flag_config_poll_interval_seconds` | `int` | `120` | Polling interval (seconds) for flag configuration _(in-process mode)_ |
+| `api_key` | `str` | `None` | API key for authenticated relay proxy requests, sent as `Authorization: Bearer` |
+| `exporter_metadata` | `dict` | `{}` | Static metadata attached to evaluation events. Values must be `str`, `bool`, `int` or `float`. The reserved keys `provider` and `openfeature` are always added and win over your values |
+| `max_pending_events` | `int` | `10000` | Buffered events that trigger an immediate flush. The buffer holds up to twice this many, above which the oldest are dropped |
 | `wasm_file_path` | `str` | `None` | Path to a custom WASM/WASI evaluation binary _(in-process mode, uses bundled binary by default)_ |
-| `wasm_pool_size` | `int` | `10` | Pool size for concurrent WASM evaluation instances _(in-process mode)_ |
-| `log_level` | `str\|int` | `"WARNING"` | Logging level (`"DEBUG"`, `"INFO"`, `"WARNING"`, `"ERROR"`) |
-| `urllib3_pool_manager` | `urllib3.PoolManager` | `None` | Custom HTTP client |
+| `wasm_pool_size` | `int` | CPU core count | Pool size for concurrent WASM evaluation instances _(in-process mode)_ |
+| `evaluation_flag_list` | `list[str]` | `None` | Restrict the fetched flag configuration to these keys. Unset or empty means all flags _(in-process mode)_ |
+| `custom_headers` | `dict[str, str]` | `None` | Extra headers on every relay proxy request, for deployments behind a gateway with its own authentication. Applied before the provider's own headers, so a configured `api_key` wins over a custom `Authorization` |
+| `log_level` | `str\|int` | `"WARNING"` | Logging level (`"DEBUG"`, `"INFO"`, `"WARNING"`, `"ERROR"`). Applied only if your application has not configured the `gofeatureflag_python_provider` logger itself — see [Logging](#logging) |
+| `urllib3_pool_manager` | `urllib3.PoolManager` | `None` | Custom HTTP client for flag configuration and data collection. Remote evaluation uses the OFREP client, which builds its own |
+
+Usage analytics are collected only while the provider is running — between `initialize()`
+(called for you by `set_provider`) and `shutdown()`. Evaluations outside that window are not
+recorded: no flush runs to deliver them, and a buffer left to fill would post to the collector
+after `shutdown()` reported it was done. Each such period logs one warning, and the number of
+events dropped is reported if the provider is started again.
+
+## Logging
+
+Every module logs through the standard library under the **`gofeatureflag_python_provider`**
+logger, with one child logger per module (`gofeatureflag_python_provider.wasm.evaluate_wasm`,
+`gofeatureflag_python_provider.services.event_publisher`, and so on). Attach your handler to the
+package logger to capture all of it:
+
+```python
+import logging
+
+logging.getLogger("gofeatureflag_python_provider").setLevel(logging.INFO)
+logging.getLogger("gofeatureflag_python_provider").addHandler(logging.StreamHandler())
+```
+
+The provider ships a `NullHandler` on that logger, so it stays silent until your application
+configures logging.
+
+Two things worth knowing:
+
+- **`log_level` yields to your configuration.** The provider applies it to the package logger only
+  when nothing has set a level there yet, because that level is process-wide state. If you
+  configure the logger yourself (directly or through `logging.config.dictConfig`), your setting
+  wins. If several providers are created with different `log_level` values, the first one applies.
+- **Exceptions raised inside hooks are logged by the OpenFeature SDK**, under its own `openfeature`
+  logger, not this one. `log_level` does not affect them — configure `logging.getLogger("openfeature")`
+  if you need to see them.
+
+## Conformance
+
+This provider targets version **1.0** of the
+[GO Feature Flag Provider Specification](https://gofeatureflag.org/specification/openfeature-provider),
+exposed as `gofeatureflag_python_provider.__specification_version__`.
+
+The evaluation engine it is pinned to is recorded in
+`gofeatureflag_python_provider/wasm/_wasi_version.txt`, which is the single source of truth
+for the bundled WASI binary version.

{gofeatureflag_python_provider-1.2.0 → gofeatureflag_python_provider-1.3.0}/README.md

@@ -113,16 +113,60 @@ else:
 |--------|------|---------|-------------|
 | `endpoint` | `str` | _(required)_ | URL of the GO Feature Flag relay proxy |
 | `evaluation_type` | `EvaluationType` | `INPROCESS` | Evaluation mode: `INPROCESS` or `REMOTE` |
-| `cache_size` | `int` | `10000` | Maximum number of flag evaluations kept in the LRU cache _(remote mode)_ |
+| `data_collector_base_url` | `str` | `endpoint` | Base URL of the data collector only. Replaces the whole base — scheme, host, port and path prefix. Flag configuration and evaluation keep using `endpoint` |
+| `timeout` | `int` | `10000` | Timeout (ms) for flag configuration, remote evaluation and data collection requests. Carried by the HTTP client the provider builds, so a custom `urllib3_pool_manager` replaces it with its own |
 | `data_flush_interval` | `int` | `60000` | Interval (ms) to flush usage data to the relay proxy |
 | `disable_data_collection` | `bool` | `False` | Set to `True` to disable usage analytics |
-| `reconnect_interval` | `int` | `60` | WebSocket reconnect interval (seconds) _(remote mode)_ |
-| `disable_cache_invalidation` | `bool` | `False` | Disable WebSocket-based cache invalidation _(remote mode)_ |
-| `flag_config_poll_interval_seconds` | `int` | `10` | Polling interval (seconds) for flag configuration _(in-process mode)_ |
-| `api_key` | `str` | `None` | API key for authenticated relay proxy requests |
-| `exporter_metadata` | `dict` | `{}` | Static metadata attached to evaluation events |
-| `max_pending_events` | `int` | `10000` | Maximum buffered events before a forced flush |
+| `flag_config_poll_interval_seconds` | `int` | `120` | Polling interval (seconds) for flag configuration _(in-process mode)_ |
+| `api_key` | `str` | `None` | API key for authenticated relay proxy requests, sent as `Authorization: Bearer` |
+| `exporter_metadata` | `dict` | `{}` | Static metadata attached to evaluation events. Values must be `str`, `bool`, `int` or `float`. The reserved keys `provider` and `openfeature` are always added and win over your values |
+| `max_pending_events` | `int` | `10000` | Buffered events that trigger an immediate flush. The buffer holds up to twice this many, above which the oldest are dropped |
 | `wasm_file_path` | `str` | `None` | Path to a custom WASM/WASI evaluation binary _(in-process mode, uses bundled binary by default)_ |
-| `wasm_pool_size` | `int` | `10` | Pool size for concurrent WASM evaluation instances _(in-process mode)_ |
-| `log_level` | `str\|int` | `"WARNING"` | Logging level (`"DEBUG"`, `"INFO"`, `"WARNING"`, `"ERROR"`) |
-| `urllib3_pool_manager` | `urllib3.PoolManager` | `None` | Custom HTTP client |
+| `wasm_pool_size` | `int` | CPU core count | Pool size for concurrent WASM evaluation instances _(in-process mode)_ |
+| `evaluation_flag_list` | `list[str]` | `None` | Restrict the fetched flag configuration to these keys. Unset or empty means all flags _(in-process mode)_ |
+| `custom_headers` | `dict[str, str]` | `None` | Extra headers on every relay proxy request, for deployments behind a gateway with its own authentication. Applied before the provider's own headers, so a configured `api_key` wins over a custom `Authorization` |
+| `log_level` | `str\|int` | `"WARNING"` | Logging level (`"DEBUG"`, `"INFO"`, `"WARNING"`, `"ERROR"`). Applied only if your application has not configured the `gofeatureflag_python_provider` logger itself — see [Logging](#logging) |
+| `urllib3_pool_manager` | `urllib3.PoolManager` | `None` | Custom HTTP client for flag configuration and data collection. Remote evaluation uses the OFREP client, which builds its own |
+
+Usage analytics are collected only while the provider is running — between `initialize()`
+(called for you by `set_provider`) and `shutdown()`. Evaluations outside that window are not
+recorded: no flush runs to deliver them, and a buffer left to fill would post to the collector
+after `shutdown()` reported it was done. Each such period logs one warning, and the number of
+events dropped is reported if the provider is started again.
+
+## Logging
+
+Every module logs through the standard library under the **`gofeatureflag_python_provider`**
+logger, with one child logger per module (`gofeatureflag_python_provider.wasm.evaluate_wasm`,
+`gofeatureflag_python_provider.services.event_publisher`, and so on). Attach your handler to the
+package logger to capture all of it:
+
+```python
+import logging
+
+logging.getLogger("gofeatureflag_python_provider").setLevel(logging.INFO)
+logging.getLogger("gofeatureflag_python_provider").addHandler(logging.StreamHandler())
+```
+
+The provider ships a `NullHandler` on that logger, so it stays silent until your application
+configures logging.
+
+Two things worth knowing:
+
+- **`log_level` yields to your configuration.** The provider applies it to the package logger only
+  when nothing has set a level there yet, because that level is process-wide state. If you
+  configure the logger yourself (directly or through `logging.config.dictConfig`), your setting
+  wins. If several providers are created with different `log_level` values, the first one applies.
+- **Exceptions raised inside hooks are logged by the OpenFeature SDK**, under its own `openfeature`
+  logger, not this one. `log_level` does not affect them — configure `logging.getLogger("openfeature")`
+  if you need to see them.
+
+## Conformance
+
+This provider targets version **1.0** of the
+[GO Feature Flag Provider Specification](https://gofeatureflag.org/specification/openfeature-provider),
+exposed as `gofeatureflag_python_provider.__specification_version__`.
+
+The evaluation engine it is pinned to is recorded in
+`gofeatureflag_python_provider/wasm/_wasi_version.txt`, which is the single source of truth
+for the bundled WASI binary version.

gofeatureflag_python_provider-1.3.0/gofeatureflag_python_provider/__init__.py

@@ -0,0 +1,18 @@
+import logging
+
+# Every module in this package logs through `logging.getLogger(__name__)`, so all
+# records land under this logger. A library must not impose output on the
+# application embedding it: the NullHandler keeps Python from falling back to
+# "no handlers could be found" when the application configured no logging at all,
+# while leaving propagation intact so an application that did configure it still
+# receives everything.
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+__version__ = "1.3.0"
+
+# Version of the GO Feature Flag Provider Specification this provider targets.
+# https://gofeatureflag.org/specification/openfeature-provider
+#
+# The evaluation engine it is pinned to is recorded separately, in
+# gofeatureflag_python_provider/wasm/_wasi_version.txt.
+__specification_version__ = "1.0"

{gofeatureflag_python_provider-1.2.0 → gofeatureflag_python_provider-1.3.0}/gofeatureflag_python_provider/evaluator/abstract_evaluator.py

@@ -18,7 +18,7 @@ class AbstractEvaluator(ABC):
     def initialize(
         self, evaluation_context: Optional[EvaluationContext] = None
     ) -> None:
-        """Initialize the evaluator (e.g. cache, WebSocket, WASM)."""
+        """Initialize the evaluator (e.g. flag configuration polling, WASM runtime)."""
         ...
 
     @abstractmethod