openfeature-provider-flagd 0.2.1__tar.gz → 0.2.3__tar.gz

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.2.3](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.2.2...openfeature-provider-flagd/v0.2.3) (2025-04-11)
+
+
+### 🐛 Bug Fixes
+
+* **flagd:** fix parameter name inconsistency with SDK version 0.8.1 ([#232](https://github.com/open-feature/python-sdk-contrib/issues/232)) ([55ee420](https://github.com/open-feature/python-sdk-contrib/commit/55ee42087bd9a948a130b08671395138baa33621))
+
+
+### ✨ New Features
+
+* add support for flagd flag metadata ([#215](https://github.com/open-feature/python-sdk-contrib/issues/215)) ([6dc72c0](https://github.com/open-feature/python-sdk-contrib/commit/6dc72c0e16b01cd40e6c103884a2d457e95871d1))
+
+
+### 🧹 Chore
+
+* **deps:** update dependency providers/openfeature-provider-flagd/openfeature/test-harness to v2.7.3 ([#226](https://github.com/open-feature/python-sdk-contrib/issues/226)) ([9a0971c](https://github.com/open-feature/python-sdk-contrib/commit/9a0971c1fd67998259903a3ea4b42772413fc259))
+* **deps:** update providers/openfeature-provider-flagd/openfeature/spec digest to 130df3e ([#222](https://github.com/open-feature/python-sdk-contrib/issues/222)) ([fa7f429](https://github.com/open-feature/python-sdk-contrib/commit/fa7f4293e060a3d56b204db851c19a668076e7a7))
+* **deps:** update providers/openfeature-provider-flagd/openfeature/spec digest to 27e4461 ([#223](https://github.com/open-feature/python-sdk-contrib/issues/223)) ([9bf2e42](https://github.com/open-feature/python-sdk-contrib/commit/9bf2e421e52922516afa2e5b8648b52a035a038d))
+* **deps:** update providers/openfeature-provider-flagd/openfeature/spec digest to aad6193 ([#194](https://github.com/open-feature/python-sdk-contrib/issues/194)) ([277ad0e](https://github.com/open-feature/python-sdk-contrib/commit/277ad0e744764bbc4eb5c5ebb773287bc2607ac3))
+
+## [0.2.2](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.2.1...openfeature-provider-flagd/v0.2.2) (2025-03-18)
+
+
+### 🐛 Bug Fixes
+
+* **flagd:** handle falsy target values correctly ([#214](https://github.com/open-feature/python-sdk-contrib/issues/214)) ([fafd099](https://github.com/open-feature/python-sdk-contrib/commit/fafd099f07365a7d0032e8215477b51bfe90c01a))
+
+
+### 🧹 Chore
+
+* **deps:** update dependency grpcio-health-checking to v1.71.0 ([#209](https://github.com/open-feature/python-sdk-contrib/issues/209)) ([345e793](https://github.com/open-feature/python-sdk-contrib/commit/345e7934b9de3879d3aff45c8213ece1a98e3711))
+* **deps:** update pre-commit hook astral-sh/ruff-pre-commit to v0.11.0 ([#212](https://github.com/open-feature/python-sdk-contrib/issues/212)) ([1b9b5f1](https://github.com/open-feature/python-sdk-contrib/commit/1b9b5f128a7fe08ffbf84cbc7de2986f95dc01f5))
+* **flagd:** Add sync metadata disabled ([#211](https://github.com/open-feature/python-sdk-contrib/issues/211)) ([2f85057](https://github.com/open-feature/python-sdk-contrib/commit/2f850574943cc92d55d198c8ccd91e80583a2ee6))
+
 ## [0.2.1](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.2.0...openfeature-provider-flagd/v0.2.1) (2025-03-10)
 
 

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openfeature-provider-flagd
-Version: 0.2.1
+Version: 0.2.3
 Summary: OpenFeature provider for the flagd flag evaluation engine
 Project-URL: Homepage, https://github.com/open-feature/python-sdk-contrib
 Author-email: OpenFeature <openfeature-core@groups.io>

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openfeature-provider-flagd"
-version = "0.2.1"
+version = "0.2.3"
 description = "OpenFeature provider for the flagd flag evaluation engine"
 readme = "README.md"
 authors = [{ name = "OpenFeature", email = "openfeature-core@groups.io" }]
@@ -40,7 +40,7 @@ dependencies = [
   "pytest-bdd",
   "testcontainers",
   "asserts",
-  "grpcio-health-checking==1.70.0",
+  "grpcio-health-checking==1.71.0",
 ]
 pre-install-commands = [
   "hatch build",

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/contrib/provider/flagd/config.py

@@ -100,6 +100,7 @@ class Config:
         cert_path: typing.Optional[str] = None,
         default_authority: typing.Optional[str] = None,
         channel_credentials: typing.Optional[grpc.ChannelCredentials] = None,
+        sync_metadata_disabled: typing.Optional[bool] = None,
     ):
         self.host = env_or_default(ENV_VAR_HOST, DEFAULT_HOST) if host is None else host
 
@@ -248,3 +249,11 @@ class Config:
         )
 
         self.channel_credentials = channel_credentials
+
+        # TODO: remove the metadata call entirely after https://github.com/open-feature/flagd/issues/1584
+        # This is a temporary stop-gap solutions to support servers that don't implement sync.GetMetadata
+        # (see: https://buf.build/open-feature/flagd/docs/main:flagd.sync.v1#flagd.sync.v1.FlagSyncService.GetMetadata).
+        # Using this option disables call to sync.GetMetadata
+        # Disabling will prevent static context from flagd being used in evaluations.
+        # GetMetadata and this option will be removed.
+        self.sync_metadata_disabled = sync_metadata_disabled

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/contrib/provider/flagd/provider.py

@@ -64,6 +64,7 @@ class FlagdProvider(AbstractProvider):
         cert_path: typing.Optional[str] = None,
         default_authority: typing.Optional[str] = None,
         channel_credentials: typing.Optional[grpc.ChannelCredentials] = None,
+        sync_metadata_disabled: typing.Optional[bool] = None,
     ):
         """
         Create an instance of the FlagdProvider
@@ -106,6 +107,7 @@ class FlagdProvider(AbstractProvider):
             cert_path=cert_path,
             default_authority=default_authority,
             channel_credentials=channel_credentials,
+            sync_metadata_disabled=sync_metadata_disabled,
         )
         self.enriched_context: dict = {}
 
@@ -156,52 +158,52 @@ class FlagdProvider(AbstractProvider):
 
     def resolve_boolean_details(
         self,
-        key: str,
+        flag_key: str,
         default_value: bool,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[bool]:
         return self.resolver.resolve_boolean_details(
-            key, default_value, evaluation_context
+            flag_key, default_value, evaluation_context
         )
 
     def resolve_string_details(
         self,
-        key: str,
+        flag_key: str,
         default_value: str,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[str]:
         return self.resolver.resolve_string_details(
-            key, default_value, evaluation_context
+            flag_key, default_value, evaluation_context
         )
 
     def resolve_float_details(
         self,
-        key: str,
+        flag_key: str,
         default_value: float,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[float]:
         return self.resolver.resolve_float_details(
-            key, default_value, evaluation_context
+            flag_key, default_value, evaluation_context
         )
 
     def resolve_integer_details(
         self,
-        key: str,
+        flag_key: str,
         default_value: int,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[int]:
         return self.resolver.resolve_integer_details(
-            key, default_value, evaluation_context
+            flag_key, default_value, evaluation_context
         )
 
     def resolve_object_details(
         self,
-        key: str,
+        flag_key: str,
         default_value: typing.Union[dict, list],
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[typing.Union[dict, list]]:
         return self.resolver.resolve_object_details(
-            key, default_value, evaluation_context
+            flag_key, default_value, evaluation_context
         )
 
     def emit_provider_ready_with_context(

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/contrib/provider/flagd/resolvers/in_process.py

@@ -17,6 +17,23 @@ from .process.targeting import targeting
 T = typing.TypeVar("T")
 
 
+def _merge_metadata(
+    flag_metadata: typing.Optional[
+        typing.Mapping[str, typing.Union[float, int, str, bool]]
+    ],
+    flag_set_metadata: typing.Optional[
+        typing.Mapping[str, typing.Union[float, int, str, bool]]
+    ],
+) -> typing.Mapping[str, typing.Union[float, int, str, bool]]:
+    metadata = {} if flag_set_metadata is None else dict(flag_set_metadata)
+
+    if flag_metadata is not None:
+        for key, value in flag_metadata.items():
+            metadata[key] = value
+
+    return metadata
+
+
 class InProcessResolver:
     def __init__(
         self,
@@ -103,29 +120,38 @@ class InProcessResolver:
         if not flag:
             raise FlagNotFoundError(f"Flag with key {key} not present in flag store.")
 
+        metadata = _merge_metadata(flag.metadata, self.flag_store.flag_set_metadata)
+
         if flag.state == "DISABLED":
-            return FlagResolutionDetails(default_value, reason=Reason.DISABLED)
+            return FlagResolutionDetails(
+                default_value, flag_metadata=metadata, reason=Reason.DISABLED
+            )
 
         if not flag.targeting:
             variant, value = flag.default
-            return FlagResolutionDetails(value, variant=variant, reason=Reason.STATIC)
+            return FlagResolutionDetails(
+                value, variant=variant, flag_metadata=metadata, reason=Reason.STATIC
+            )
 
         variant = targeting(flag.key, flag.targeting, evaluation_context)
 
         if variant is None:
             variant, value = flag.default
-            return FlagResolutionDetails(value, variant=variant, reason=Reason.DEFAULT)
+            return FlagResolutionDetails(
+                value, variant=variant, flag_metadata=metadata, reason=Reason.DEFAULT
+            )
         if not isinstance(variant, (str, bool)):
             raise ParseError(
                 "Parsed JSONLogic targeting did not return a string or bool"
             )
 
         variant, value = flag.get_variant(variant)
-        if not value:
+        if value is None:
             raise ParseError(f"Resolved variant {variant} not in variants config.")
 
         return FlagResolutionDetails(
             value,
             variant=variant,
             reason=Reason.TARGETING_MATCH,
+            flag_metadata=metadata,
         )

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/contrib/provider/flagd/resolvers/process/connector/file_watcher.py

@@ -14,7 +14,7 @@ from openfeature.contrib.provider.flagd.resolvers.process.connector import (
 from openfeature.contrib.provider.flagd.resolvers.process.flags import FlagStore
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import ProviderEventDetails
-from openfeature.exception import ParseError, ProviderNotReadyError
+from openfeature.exception import ErrorCode, ParseError, ProviderNotReadyError
 
 logger = logging.getLogger("openfeature.contrib")
 
@@ -76,8 +76,15 @@ class FileWatcher(FlagStateConnector):
             self.handle_error("Could not parse JSON flag data from file")
         except yaml.error.YAMLError:
             self.handle_error("Could not parse YAML flag data from file")
-        except ParseError:
-            self.handle_error("Could not parse flag data using flagd syntax")
+        except ParseError as e:
+            self.handle_error(
+                "Could not parse flag data using flagd syntax: "
+                + (
+                    "no error message provided"
+                    if e is None or e.error_message is None
+                    else e.error_message
+                )
+            )
         except Exception:
             self.handle_error("Could not read flags from file")
 
@@ -104,4 +111,8 @@ class FileWatcher(FlagStateConnector):
     def handle_error(self, error_message: str) -> None:
         logger.exception(error_message)
         self.should_emit_ready_on_success = True
-        self.emit_provider_error(ProviderEventDetails(message=error_message))
+        self.emit_provider_error(
+            ProviderEventDetails(
+                message=error_message, error_code=ErrorCode.PARSE_ERROR
+            )
+        )

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/contrib/provider/flagd/resolvers/process/connector/grpc_watcher.py

@@ -6,6 +6,7 @@ import typing
 
 import grpc
 from google.protobuf.json_format import MessageToDict
+from google.protobuf.struct_pb2 import Struct
 
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import ProviderEventDetails
@@ -162,24 +163,36 @@ class GrpcWatcher(FlagStateConnector):
         self.active = False
         self.channel.close()
 
+    def _create_request_args(self) -> dict:
+        request_args = {}
+        if self.selector is not None:
+            request_args["selector"] = self.selector
+        if self.provider_id is not None:
+            request_args["provider_id"] = self.provider_id
+
+        return request_args
+
     def listen(self) -> None:
         call_args = (
             {"timeout": self.streamline_deadline_seconds}
             if self.streamline_deadline_seconds > 0
             else {}
         )
-        request_args = {}
-        if self.selector is not None:
-            request_args["selector"] = self.selector
-        if self.provider_id is not None:
-            request_args["provider_id"] = self.provider_id
+        request_args = self._create_request_args()
 
         while self.active:
             try:
-                context_values_request = sync_pb2.GetMetadataRequest()
-                context_values_response: sync_pb2.GetMetadataResponse = (
-                    self.stub.GetMetadata(context_values_request, wait_for_ready=True)
-                )
+                context_values_response: sync_pb2.GetMetadataResponse
+                if self.config.sync_metadata_disabled:
+                    context_values_response = sync_pb2.GetMetadataResponse(
+                        metadata=Struct()
+                    )
+                else:
+                    context_values_request = sync_pb2.GetMetadataRequest()
+                    context_values_response = self.stub.GetMetadata(
+                        context_values_request, wait_for_ready=True
+                    )
+
                 context_values = MessageToDict(context_values_response)
 
                 request = sync_pb2.SyncFlagsRequest(**request_args)

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/contrib/provider/flagd/resolvers/process/flags.py

@@ -7,6 +7,21 @@ from openfeature.event import ProviderEventDetails
 from openfeature.exception import ParseError
 
 
+def _validate_metadata(key: str, value: typing.Union[float, int, str, bool]) -> None:
+    if key is None:
+        raise ParseError("Metadata key must be set")
+    elif not isinstance(key, str):
+        raise ParseError(f"Metadata key {key} must be of type str, but is {type(key)}")
+    elif not key:
+        raise ParseError("key must not be empty")
+    if value is None:
+        raise ParseError(f"Metadata value for key {key} must be set")
+    elif not isinstance(value, (float, int, str, bool)):
+        raise ParseError(
+            f"Metadata value {value} for key  {key} must be of type float, int, str or bool, but is {type(value)}"
+        )
+
+
 class FlagStore:
     def __init__(
         self,
@@ -16,12 +31,16 @@ class FlagStore:
     ):
         self.emit_provider_configuration_changed = emit_provider_configuration_changed
         self.flags: typing.Mapping[str, Flag] = {}
+        self.flag_set_metadata: typing.Mapping[
+            str, typing.Union[float, int, str, bool]
+        ] = {}
 
     def get_flag(self, key: str) -> typing.Optional["Flag"]:
         return self.flags.get(key)
 
     def update(self, flags_data: dict) -> None:
         flags = flags_data.get("flags", {})
+        metadata = flags_data.get("metadata", {})
         evaluators: typing.Optional[dict] = flags_data.get("$evaluators")
         if evaluators:
             transposed = json.dumps(flags)
@@ -33,10 +52,18 @@ class FlagStore:
 
         if not isinstance(flags, dict):
             raise ParseError("`flags` key of configuration must be a dictionary")
+        if not isinstance(metadata, dict):
+            raise ParseError("`metadata` key of configuration must be a dictionary")
+        for key, value in metadata.items():
+            _validate_metadata(key, value)
+
         self.flags = {key: Flag.from_dict(key, data) for key, data in flags.items()}
+        self.flag_set_metadata = metadata
 
         self.emit_provider_configuration_changed(
-            ProviderEventDetails(flags_changed=list(self.flags.keys()))
+            ProviderEventDetails(
+                flags_changed=list(self.flags.keys()), metadata=metadata
+            )
         )
 
 
@@ -47,6 +74,9 @@ class Flag:
     variants: typing.Mapping[str, typing.Any]
     default_variant: typing.Union[bool, str]
     targeting: typing.Optional[dict] = None
+    metadata: typing.Optional[
+        typing.Mapping[str, typing.Union[float, int, str, bool]]
+    ] = None
 
     def __post_init__(self) -> None:
         if not self.state or not isinstance(self.state, str):
@@ -66,19 +96,25 @@ class Flag:
         if self.default_variant not in self.variants:
             raise ParseError("Default variant does not match set of variants")
 
+        if self.metadata:
+            if not isinstance(self.metadata, dict):
+                raise ParseError("Flag metadata is not a valid json object")
+            for key, value in self.metadata.items():
+                _validate_metadata(key, value)
+
     @classmethod
     def from_dict(cls, key: str, data: dict) -> "Flag":
         if "defaultVariant" in data:
             data["default_variant"] = data["defaultVariant"]
             del data["defaultVariant"]
 
-        if "source" in data:
-            del data["source"]
-        if "selector" in data:
-            del data["selector"]
+        data.pop("source", None)
+        data.pop("selector", None)
         try:
             flag = cls(key=key, **data)
             return flag
+        except ParseError as parseError:
+            raise parseError
         except Exception as err:
             raise ParseError from err
 

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 from openfeature.schemas.protobuf.flagd.evaluation.v1 import evaluation_pb2 as openfeature_dot_schemas_dot_protobuf_dot_flagd_dot_evaluation_dot_v1_dot_evaluation__pb2
 
-GRPC_GENERATED_VERSION = '1.70.0'
+GRPC_GENERATED_VERSION = '1.71.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/schemas/protobuf/flagd/sync/v1/sync_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 from openfeature.schemas.protobuf.flagd.sync.v1 import sync_pb2 as openfeature_dot_schemas_dot_protobuf_dot_flagd_dot_sync_dot_v1_dot_sync__pb2
 
-GRPC_GENERATED_VERSION = '1.70.0'
+GRPC_GENERATED_VERSION = '1.71.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/schemas/protobuf/schema/v1/schema_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 from openfeature.schemas.protobuf.schema.v1 import schema_pb2 as openfeature_dot_schemas_dot_protobuf_dot_schema_dot_v1_dot_schema__pb2
 
-GRPC_GENERATED_VERSION = '1.70.0'
+GRPC_GENERATED_VERSION = '1.71.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/src/openfeature/schemas/protobuf/sync/v1/sync_service_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 from openfeature.schemas.protobuf.sync.v1 import sync_service_pb2 as openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2
 
-GRPC_GENERATED_VERSION = '1.70.0'
+GRPC_GENERATED_VERSION = '1.71.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/tests/e2e/rpc/conftest.py

@@ -4,7 +4,7 @@ from openfeature.contrib.provider.flagd.config import ResolverType
 from tests.e2e.testfilter import TestFilter
 
 resolver = ResolverType.RPC
-feature_list = ["~targetURI", "~unixsocket", "~sync"]
+feature_list = ["~targetURI", "~unixsocket", "~sync", "~metadata"]
 
 
 def pytest_collection_modifyitems(config, items):

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/tests/e2e/step/event_steps.py

@@ -8,6 +8,8 @@ from pytest_bdd import given, parsers, then, when
 from openfeature.client import OpenFeatureClient
 from openfeature.event import ProviderEvent
 
+logger = logging.getLogger("openfeature.contrib.tests")
+
 events = {
     "ready": ProviderEvent.PROVIDER_READY,
     "error": ProviderEvent.PROVIDER_ERROR,
@@ -28,7 +30,7 @@ def event_handles() -> list:
 )
 def add_event_handler(client: OpenFeatureClient, event_type: str, event_handles: list):
     def handler(event):
-        logging.warning((event_type, event))
+        logger.warning((event_type, event))
         event_handles.append(
             {
                 "type": event_type,
@@ -38,11 +40,11 @@ def add_event_handler(client: OpenFeatureClient, event_type: str, event_handles:
 
     client.add_handler(events[event_type], handler)
 
-    logging.warning(("handler added", event_type))
+    logger.warning(("handler added", event_type))
 
 
 def assert_handlers(handles, event_type: str, max_wait: int = 2):
-    poll_interval = 1
+    poll_interval = 0.2
     while max_wait > 0:
         found = any(h["type"] == event_type for h in handles)
         if not found:

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/tests/e2e/step/flag_step.py

@@ -94,3 +94,16 @@ def resolve_details_reason(
     reason: str,
 ):
     assert_equal(details.reason, Reason(reason))
+
+
+@then(parsers.cfparse("the resolved metadata should contain"))
+def metadata_contains(details: FlagEvaluationDetails[JsonPrimitive], datatable):
+    assert_equal(len(details.flag_metadata), len(datatable) - 1)  # skip table header
+    for i in range(1, len(datatable)):
+        key, metadata_type, expected = datatable[i]
+        assert_equal(details.flag_metadata[key], type_cast[metadata_type](expected))
+
+
+@then("the resolved metadata is empty")
+def empty_metadata(details: FlagEvaluationDetails[JsonPrimitive]):
+    assert_equal(len(details.flag_metadata), 0)

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/tests/e2e/step/provider_steps.py

@@ -22,6 +22,8 @@ KEY_FLAGS = "flags"
 
 MERGED_FILE = "merged_file"
 
+logger = logging.getLogger("openfeature.contrib.tests")
+
 
 class TestProviderType(Enum):
     UNAVAILABLE = "unavailable"
@@ -29,6 +31,7 @@ class TestProviderType(Enum):
     UNSTABLE = "unstable"
     SSL = "ssl"
     SOCKET = "socket"
+    METADATA = "metadata"
 
 
 @given("a provider is registered", target_fixture="client")
@@ -41,7 +44,7 @@ def setup_provider_old(
 
 
 def get_default_options_for_provider(
-    provider_type: str, resolver_type: ResolverType, container
+    provider_type: str, resolver_type: ResolverType, container, option_values: dict
 ) -> tuple[dict, bool]:
     launchpad = "default"
     t = TestProviderType(provider_type)
@@ -66,11 +69,20 @@ def get_default_options_for_provider(
         launchpad = "ssl"
     elif t == TestProviderType.SOCKET:
         return options, True
+    elif t == TestProviderType.METADATA:
+        launchpad = "metadata"
 
     if resolver_type == ResolverType.FILE:
-        options["offline_flag_source_path"] = os.path.join(
-            container.flagDir.name, "allFlags.json"
-        )
+        if "selector" in option_values:
+            path = option_values["selector"]
+            path = path.replace("rawflags/", "")
+            options["offline_flag_source_path"] = os.path.join(
+                Path(__file__).parents[3], "openfeature", "test-harness", "flags", path
+            )
+        else:
+            options["offline_flag_source_path"] = os.path.join(
+                container.flagDir.name, "allFlags.json"
+            )
 
     requests.post(
         f"{container.get_launchpad_url()}/start?config={launchpad}", timeout=1
@@ -89,7 +101,7 @@ def setup_provider(
     option_values: dict,
 ) -> OpenFeatureClient:
     default_options, wait = get_default_options_for_provider(
-        provider_type, resolver_type, container
+        provider_type, resolver_type, container, option_values
     )
 
     combined_options = {**default_options, **option_values}
@@ -118,7 +130,8 @@ def flagd_restart(
     resolver_type: ResolverType,
 ):
     requests.post(
-        f"{container.get_launchpad_url()}/restart?seconds={seconds}", timeout=2
+        f"{container.get_launchpad_url()}/restart?seconds={seconds}",
+        timeout=float(seconds) + 2,
     )
     pass
 
@@ -133,7 +146,7 @@ def container(request):
         try:
             container.stop()
         except:  # noqa: E722 - we want to ensure all containers are stopped, even if we do have an exception here
-            logging.debug("container was not running anymore")
+            logger.debug("container was not running anymore")
 
     # Teardown code
     request.addfinalizer(fin)

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.3}/tests/e2e/testfilter.py

@@ -1,6 +1,8 @@
 import logging
 import os
 
+logger = logging.getLogger("openfeature.contrib.tests")
+
 
 class TestFilter:
     def __init__(self, config, feature_list=None, resolver=None, base_path=None):
@@ -40,7 +42,7 @@ class TestFilter:
             all_tags = self._get_item_tags(item)
 
             # Debug: Print collected tags for each item
-            logging.debug(f"Item: {item.nodeid}, Tags: {all_tags}")
+            logger.debug(f"Item: {item.nodeid}, Tags: {all_tags}")
 
             # Include-only logic: Skip items that do not match include_tags
             if (

openfeature_provider_flagd-0.2.3/tests/flags/basic-flag-combined-metadata.json

@@ -0,0 +1,29 @@
+{
+  "flags": {
+    "basic-flag": {
+      "state": "ENABLED",
+      "variants": {
+        "true": true,
+        "false": false
+      },
+      "defaultVariant": "false",
+      "targeting": {},
+      "metadata": {
+        "string": "a",
+        "integer": 1,
+        "float": 1.2,
+        "bool": true
+      }
+    }
+  },
+  "metadata": {
+    "string": "b",
+    "integer": 2,
+    "float": 2.2,
+    "bool": false,
+    "flag-set-string": "c",
+    "flag-set-integer": 3,
+    "flag-set-float": 3.2,
+    "flag-set-bool": false
+  }
+}