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

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

@@ -1,5 +1,19 @@
 # Changelog
 
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openfeature-provider-flagd
-Version: 0.2.1
+Version: 0.2.2
 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.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openfeature-provider-flagd"
-version = "0.2.1"
+version = "0.2.2"
 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.2}/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.2}/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 = {}
 

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

@@ -121,7 +121,7 @@ class InProcessResolver:
             )
 
         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(

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.2}/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.2}/src/openfeature/contrib/provider/flagd/resolvers/process/flags.py

@@ -72,10 +72,8 @@ class Flag:
             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

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.2}/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.2}/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.2}/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.2}/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.2}/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,7 +40,7 @@ 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):

{openfeature_provider_flagd-0.2.1 → openfeature_provider_flagd-0.2.2}/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"
@@ -133,7 +135,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.2}/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.2/tests/test_in_process.py

@@ -0,0 +1,218 @@
+from unittest.mock import Mock, create_autospec
+
+import pytest
+
+from openfeature.contrib.provider.flagd.config import Config
+from openfeature.contrib.provider.flagd.resolvers.in_process import InProcessResolver
+from openfeature.contrib.provider.flagd.resolvers.process.flags import Flag, FlagStore
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import FlagNotFoundError, ParseError
+
+
+def targeting():
+    return {
+        "if": [
+            {"==": [{"var": "targetingKey"}, "target_variant"]},
+            "target_variant",
+            None,
+        ]
+    }
+
+
+def context(targeting_key):
+    return EvaluationContext(targeting_key=targeting_key)
+
+
+@pytest.fixture
+def config():
+    return create_autospec(Config)
+
+
+@pytest.fixture
+def flag_store():
+    return create_autospec(FlagStore)
+
+
+@pytest.fixture
+def flag():
+    return Flag(
+        key="flag",
+        state="ENABLED",
+        variants={"default_variant": False, "target_variant": True},
+        default_variant="default_variant",
+        targeting=targeting(),
+    )
+
+
+@pytest.fixture
+def resolver(config):
+    config.offline_flag_source_path = "flag.json"
+    config.deadline_ms = 100
+    return InProcessResolver(
+        config=config,
+        emit_provider_ready=Mock(),
+        emit_provider_error=Mock(),
+        emit_provider_stale=Mock(),
+        emit_provider_configuration_changed=Mock(),
+    )
+
+
+def test_resolve_boolean_details_flag_not_found(resolver):
+    resolver.flag_store.get_flag = Mock(return_value=None)
+    with pytest.raises(FlagNotFoundError):
+        resolver.resolve_boolean_details("nonexistent_flag", False)
+
+
+def test_resolve_boolean_details_disabled_flag(flag, resolver):
+    flag.state = "DISABLED"
+    resolver.flag_store.get_flag = Mock(return_value=flag)
+
+    result = resolver.resolve_boolean_details("disabled_flag", False)
+
+    assert result.reason == "DISABLED"
+    assert result.variant is None
+    assert not result.value
+
+
+def test_resolve_boolean_details_invalid_variant(resolver, flag):
+    flag.targeting = {"var": ["targetingKey", "invalid_variant"]}
+
+    resolver.flag_store.get_flag = Mock(return_value=flag)
+
+    with pytest.raises(ParseError):
+        resolver.resolve_boolean_details("flag", False)
+
+
+@pytest.mark.parametrize(
+    "input_config, resolve_config, expected",
+    [
+        (
+            {
+                "variants": {"default_variant": False, "target_variant": True},
+                "targeting": None,
+            },
+            {
+                "context": None,
+                "method": "resolve_boolean_details",
+                "default_value": False,
+            },
+            {"reason": "STATIC", "variant": "default_variant", "value": False},
+        ),
+        (
+            {
+                "variants": {"default_variant": False, "target_variant": True},
+                "targeting": targeting(),
+            },
+            {
+                "context": context("no_target_variant"),
+                "method": "resolve_boolean_details",
+                "default_value": False,
+            },
+            {"reason": "DEFAULT", "variant": "default_variant", "value": False},
+        ),
+        (
+            {
+                "variants": {"default_variant": False, "target_variant": True},
+                "targeting": targeting(),
+            },
+            {
+                "context": context("target_variant"),
+                "method": "resolve_boolean_details",
+                "default_value": False,
+            },
+            {"reason": "TARGETING_MATCH", "variant": "target_variant", "value": True},
+        ),
+        (
+            {
+                "variants": {"default_variant": "default", "target_variant": "target"},
+                "targeting": targeting(),
+            },
+            {
+                "context": context("target_variant"),
+                "method": "resolve_string_details",
+                "default_value": "placeholder",
+            },
+            {
+                "reason": "TARGETING_MATCH",
+                "variant": "target_variant",
+                "value": "target",
+            },
+        ),
+        (
+            {
+                "variants": {"default_variant": 1.0, "target_variant": 2.0},
+                "targeting": targeting(),
+            },
+            {
+                "context": context("target_variant"),
+                "method": "resolve_float_details",
+                "default_value": 0.0,
+            },
+            {"reason": "TARGETING_MATCH", "variant": "target_variant", "value": 2.0},
+        ),
+        (
+            {
+                "variants": {"default_variant": True, "target_variant": False},
+                "targeting": targeting(),
+            },
+            {
+                "context": context("target_variant"),
+                "method": "resolve_boolean_details",
+                "default_value": True,
+            },
+            {"reason": "TARGETING_MATCH", "variant": "target_variant", "value": False},
+        ),
+        (
+            {
+                "variants": {"default_variant": 10, "target_variant": 0},
+                "targeting": targeting(),
+            },
+            {
+                "context": context("target_variant"),
+                "method": "resolve_integer_details",
+                "default_value": 1,
+            },
+            {"reason": "TARGETING_MATCH", "variant": "target_variant", "value": 0},
+        ),
+        (
+            {
+                "variants": {"default_variant": {}, "target_variant": {}},
+                "targeting": targeting(),
+            },
+            {
+                "context": context("target_variant"),
+                "method": "resolve_object_details",
+                "default_value": {},
+            },
+            {"reason": "TARGETING_MATCH", "variant": "target_variant", "value": {}},
+        ),
+    ],
+    ids=[
+        "static_flag",
+        "boolean_default_fallback",
+        "boolean_targeting_match",
+        "string_targeting_match",
+        "float_targeting_match",
+        "boolean_falsy_target",
+        "integer_falsy_target",
+        "object_falsy_target",
+    ],
+)
+def test_resolver_details(
+    resolver,
+    flag,
+    input_config,
+    resolve_config,
+    expected,
+):
+    flag.variants = input_config["variants"]
+    flag.targeting = input_config["targeting"]
+    resolver.flag_store.get_flag = Mock(return_value=flag)
+
+    result = getattr(resolver, resolve_config["method"])(
+        "flag", resolve_config["default_value"], resolve_config["context"]
+    )
+
+    assert result.reason == expected["reason"]
+    assert result.variant == expected["variant"]
+    assert result.value == expected["value"]