openfeature-provider-flagd 0.1.4__tar.gz → 0.1.5__tar.gz

{openfeature_provider_flagd-0.1.4 → openfeature_provider_flagd-0.1.5}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.5](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.1.4...openfeature-provider-flagd/v0.1.5) (2024-04-11)
+
+
+### ✨ New Features
+
+* in-process offline flagd resolver ([#74](https://github.com/open-feature/python-sdk-contrib/issues/74)) ([8cea506](https://github.com/open-feature/python-sdk-contrib/commit/8cea5066ee96f637f3108a9dc3a7539c450a14be))
+
 ## [0.1.4](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.1.3...openfeature-provider-flagd/v0.1.4) (2024-03-26)
 
 

{openfeature_provider_flagd-0.1.4 → openfeature_provider_flagd-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfeature-provider-flagd
-Version: 0.1.4
+Version: 0.1.5
 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>
@@ -211,8 +211,12 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Requires-Dist: grpcio>=1.60.0
+Requires-Dist: mmh3>=4.1.0
 Requires-Dist: openfeature-sdk>=0.4.0
+Requires-Dist: panzi-json-logic>=1.0.1
 Requires-Dist: protobuf>=4.25.2
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: semver<4,>=3
 Description-Content-Type: text/markdown
 
 # flagd Provider for OpenFeature
@@ -236,6 +240,19 @@ from openfeature.contrib.provider.flagd import FlagdProvider
 api.set_provider(FlagdProvider())
 ```
 
+To use in-process evaluation in offline mode with a file as source:
+
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+from openfeature.contrib.provider.flagd.config import ResolverType
+
+api.set_provider(FlagdProvider(
+    resolver_type=ResolverType.IN_PROCESS,
+    offline_flag_source_path="my-flag.json",
+))
+```
+
 ### Configuration options
 
 The default options can be defined in the FlagdProvider constructor.

{openfeature_provider_flagd-0.1.4 → openfeature_provider_flagd-0.1.5}/README.md

@@ -19,6 +19,19 @@ from openfeature.contrib.provider.flagd import FlagdProvider
 api.set_provider(FlagdProvider())
 ```
 
+To use in-process evaluation in offline mode with a file as source:
+
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+from openfeature.contrib.provider.flagd.config import ResolverType
+
+api.set_provider(FlagdProvider(
+    resolver_type=ResolverType.IN_PROCESS,
+    offline_flag_source_path="my-flag.json",
+))
+```
+
 ### Configuration options
 
 The default options can be defined in the FlagdProvider constructor.

{openfeature_provider_flagd-0.1.4 → openfeature_provider_flagd-0.1.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openfeature-provider-flagd"
-version = "0.1.4"
+version = "0.1.5"
 description = "OpenFeature provider for the flagd flag evaluation engine"
 readme = "README.md"
 authors = [{ name = "OpenFeature", email = "openfeature-core@groups.io" }]
@@ -20,6 +20,10 @@ dependencies = [
   "openfeature-sdk>=0.4.0",
   "grpcio>=1.60.0",
   "protobuf>=4.25.2",
+  "mmh3>=4.1.0",
+  "panzi-json-logic>=1.0.1",
+  "semver>=3,<4",
+  "pyyaml>=6.0.1",
 ]
 requires-python = ">=3.8"
 
@@ -32,6 +36,7 @@ Homepage = "https://github.com/open-feature/python-sdk-contrib"
 dependencies = [
   "coverage[toml]>=6.5",
   "pytest",
+  "pytest-bdd",
 ]
 post-install-commands = [
   "./scripts/gen_protos.sh"
@@ -42,6 +47,7 @@ test = "pytest {args:tests}"
 test-cov = "coverage run -m pytest {args:tests}"
 cov-report = [
   "coverage xml",
+  "coverage html",
 ]
 cov = [
   "test-cov",
@@ -61,4 +67,5 @@ packages = ["src/openfeature"]
 omit = [
   # exclude generated files
   "src/openfeature/contrib/provider/flagd/proto/*",
+  "tests/**",
 ]

{openfeature_provider_flagd-0.1.4 → openfeature_provider_flagd-0.1.5}/src/openfeature/contrib/provider/flagd/config.py

@@ -1,5 +1,6 @@
 import os
 import typing
+from enum import Enum
 
 T = typing.TypeVar("T")
 
@@ -17,13 +18,21 @@ def env_or_default(
     return val if cast is None else cast(val)
 
 
+class ResolverType(Enum):
+    GRPC = "grpc"
+    IN_PROCESS = "in-process"
+
+
 class Config:
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         host: typing.Optional[str] = None,
         port: typing.Optional[int] = None,
         tls: typing.Optional[bool] = None,
         timeout: typing.Optional[int] = None,
+        resolver_type: typing.Optional[ResolverType] = None,
+        offline_flag_source_path: typing.Optional[str] = None,
+        offline_poll_interval_seconds: typing.Optional[float] = None,
     ):
         self.host = env_or_default("FLAGD_HOST", "localhost") if host is None else host
         self.port = (
@@ -33,3 +42,18 @@ class Config:
             env_or_default("FLAGD_TLS", False, cast=str_to_bool) if tls is None else tls
         )
         self.timeout = 5 if timeout is None else timeout
+        self.resolver_type = (
+            ResolverType(env_or_default("FLAGD_RESOLVER_TYPE", "grpc"))
+            if resolver_type is None
+            else resolver_type
+        )
+        self.offline_flag_source_path = (
+            env_or_default("FLAGD_OFFLINE_FLAG_SOURCE_PATH", None)
+            if offline_flag_source_path is None
+            else offline_flag_source_path
+        )
+        self.offline_poll_interval_seconds = (
+            float(env_or_default("FLAGD_OFFLINE_POLL_INTERVAL_SECONDS", 1.0))
+            if offline_poll_interval_seconds is None
+            else offline_poll_interval_seconds
+        )

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/provider.py

@@ -0,0 +1,136 @@
+"""
+# This is a Python Provider to interact with flagd
+#
+# -- Usage --
+# open_feature_api.set_provider(flagd_provider.FlagdProvider())
+# flag_value =  open_feature_client.get_string_value(
+#                   key="foo",
+#                   default_value="missingflag"
+#               )
+# print(f"Flag Value is: {flag_value}")
+#   OR the more verbose option
+# flag = open_feature_client.get_string_details(key="foo", default_value="missingflag")
+# print(f"Flag is: {flag.value}")
+#   OR
+# print(f"Flag Details: {vars(flag)}"")
+#
+# -- Customisation --
+# Follows flagd defaults: 'http' protocol on 'localhost' on port '8013'
+# But can be overridden:
+# provider = open_feature_api.get_provider()
+# provider.initialise(schema="https",endpoint="example.com",port=1234,timeout=10)
+"""
+
+import typing
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.provider.metadata import Metadata
+from openfeature.provider.provider import AbstractProvider
+
+from .config import Config, ResolverType
+from .resolvers import AbstractResolver, GrpcResolver, InProcessResolver
+
+T = typing.TypeVar("T")
+
+
+class FlagdProvider(AbstractProvider):
+    """Flagd OpenFeature Provider"""
+
+    def __init__(  # noqa: PLR0913
+        self,
+        host: typing.Optional[str] = None,
+        port: typing.Optional[int] = None,
+        tls: typing.Optional[bool] = None,
+        timeout: typing.Optional[int] = None,
+        resolver_type: typing.Optional[ResolverType] = None,
+        offline_flag_source_path: typing.Optional[str] = None,
+        offline_poll_interval_seconds: typing.Optional[float] = None,
+    ):
+        """
+        Create an instance of the FlagdProvider
+
+        :param host: the host to make requests to
+        :param port: the port the flagd service is available on
+        :param tls: enable/disable secure TLS connectivity
+        :param timeout: the maximum to wait before a request times out
+        """
+        self.config = Config(
+            host=host,
+            port=port,
+            tls=tls,
+            timeout=timeout,
+            resolver_type=resolver_type,
+            offline_flag_source_path=offline_flag_source_path,
+            offline_poll_interval_seconds=offline_poll_interval_seconds,
+        )
+
+        self.resolver = self.setup_resolver()
+
+    def setup_resolver(self) -> AbstractResolver:
+        if self.config.resolver_type == ResolverType.GRPC:
+            return GrpcResolver(self.config)
+        elif self.config.resolver_type == ResolverType.IN_PROCESS:
+            return InProcessResolver(self.config, self)
+        else:
+            raise ValueError(
+                f"`resolver_type` parameter invalid: {self.config.resolver_type}"
+            )
+
+    def shutdown(self) -> None:
+        if self.resolver:
+            self.resolver.shutdown()
+
+    def get_metadata(self) -> Metadata:
+        """Returns provider metadata"""
+        return Metadata(name="FlagdProvider")
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self.resolver.resolve_boolean_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self.resolver.resolve_string_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        return self.resolver.resolve_float_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self.resolver.resolve_integer_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_object_details(
+        self,
+        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
+        )

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/resolvers/__init__.py

@@ -0,0 +1,51 @@
+import typing
+
+from typing_extensions import Protocol
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.flag_evaluation import FlagResolutionDetails
+
+from .grpc import GrpcResolver
+from .in_process import InProcessResolver
+
+
+class AbstractResolver(Protocol):
+    def shutdown(self) -> None: ...
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]: ...
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]: ...
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]: ...
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]: ...
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]: ...
+
+
+__all__ = ["AbstractResolver", "GrpcResolver", "InProcessResolver"]

openfeature_provider_flagd-0.1.4/src/openfeature/contrib/provider/flagd/provider.py → openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/resolvers/grpc.py

@@ -1,26 +1,3 @@
-"""
-# This is a Python Provider to interact with flagd
-#
-# -- Usage --
-# open_feature_api.set_provider(flagd_provider.FlagdProvider())
-# flag_value =  open_feature_client.get_string_value(
-#                   key="foo",
-#                   default_value="missingflag"
-#               )
-# print(f"Flag Value is: {flag_value}")
-#   OR the more verbose option
-# flag = open_feature_client.get_string_details(key="foo", default_value="missingflag")
-# print(f"Flag is: {flag.value}")
-#   OR
-# print(f"Flag Details: {vars(flag)}"")
-#
-# -- Customisation --
-# Follows flagd defaults: 'http' protocol on 'localhost' on port '8013'
-# But can be overridden:
-# provider = open_feature_api.get_provider()
-# provider.initialise(schema="https",endpoint="example.com",port=1234,timeout=10)
-"""
-
 import typing
 
 import grpc
@@ -35,52 +12,26 @@ from openfeature.exception import (
     TypeMismatchError,
 )
 from openfeature.flag_evaluation import FlagResolutionDetails
-from openfeature.provider.metadata import Metadata
-from openfeature.provider.provider import AbstractProvider
 
-from .config import Config
-from .flag_type import FlagType
-from .proto.schema.v1 import schema_pb2, schema_pb2_grpc
+from ..config import Config
+from ..flag_type import FlagType
+from ..proto.schema.v1 import schema_pb2, schema_pb2_grpc
 
 T = typing.TypeVar("T")
 
 
-class FlagdProvider(AbstractProvider):
-    """Flagd OpenFeature Provider"""
-
-    def __init__(
-        self,
-        host: typing.Optional[str] = None,
-        port: typing.Optional[int] = None,
-        tls: typing.Optional[bool] = None,
-        timeout: typing.Optional[int] = None,
-    ):
-        """
-        Create an instance of the FlagdProvider
-
-        :param host: the host to make requests to
-        :param port: the port the flagd service is available on
-        :param tls: enable/disable secure TLS connectivity
-        :param timeout: the maximum to wait before a request times out
-        """
-        self.config = Config(
-            host=host,
-            port=port,
-            tls=tls,
-            timeout=timeout,
+class GrpcResolver:
+    def __init__(self, config: Config):
+        self.config = config
+        channel_factory = (
+            grpc.secure_channel if self.config.tls else grpc.insecure_channel
         )
-
-        channel_factory = grpc.secure_channel if tls else grpc.insecure_channel
         self.channel = channel_factory(f"{self.config.host}:{self.config.port}")
         self.stub = schema_pb2_grpc.ServiceStub(self.channel)
 
     def shutdown(self) -> None:
         self.channel.close()
 
-    def get_metadata(self) -> Metadata:
-        """Returns provider metadata"""
-        return Metadata(name="FlagdProvider")
-
     def resolve_boolean_details(
         self,
         key: str,

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/resolvers/in_process.py

@@ -0,0 +1,122 @@
+import time
+import typing
+
+from json_logic import builtins, jsonLogic  # type: ignore[import-untyped]
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import FlagNotFoundError, ParseError
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.provider.provider import AbstractProvider
+
+from ..config import Config
+from .process.custom_ops import ends_with, fractional, sem_ver, starts_with
+from .process.file_watcher import FileWatcherFlagStore
+
+T = typing.TypeVar("T")
+
+
+class InProcessResolver:
+    OPERATORS: typing.ClassVar[dict] = {
+        **builtins.BUILTINS,
+        "fractional": fractional,
+        "starts_with": starts_with,
+        "ends_with": ends_with,
+        "sem_ver": sem_ver,
+    }
+
+    def __init__(self, config: Config, provider: AbstractProvider):
+        self.config = config
+        self.provider = provider
+        if not self.config.offline_flag_source_path:
+            raise ValueError(
+                "offline_flag_source_path must be provided when using in-process resolver"
+            )
+        self.flag_store = FileWatcherFlagStore(
+            self.config.offline_flag_source_path,
+            self.provider,
+            self.config.offline_poll_interval_seconds,
+        )
+
+    def shutdown(self) -> None:
+        self.flag_store.shutdown()
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def _resolve(
+        self,
+        key: str,
+        default_value: T,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[T]:
+        flag = self.flag_store.get_flag(key)
+        if not flag:
+            raise FlagNotFoundError(f"Flag with key {key} not present in flag store.")
+
+        if flag.state == "DISABLED":
+            return FlagResolutionDetails(default_value, reason=Reason.DISABLED)
+
+        if not flag.targeting:
+            variant, value = flag.default
+            return FlagResolutionDetails(value, variant=variant, reason=Reason.STATIC)
+
+        json_logic_context = evaluation_context.attributes if evaluation_context else {}
+        json_logic_context["$flagd"] = {"flagKey": key, "timestamp": int(time.time())}
+        json_logic_context["targetingKey"] = (
+            evaluation_context.targeting_key if evaluation_context else None
+        )
+        variant = jsonLogic(flag.targeting, json_logic_context, self.OPERATORS)
+        if variant is None:
+            variant, value = flag.default
+            return FlagResolutionDetails(value, variant=variant, 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:
+            raise ParseError(f"Resolved variant {variant} not in variants config.")
+
+        return FlagResolutionDetails(
+            value,
+            variant=variant,
+            reason=Reason.TARGETING_MATCH,
+        )

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/resolvers/process/custom_ops.py

@@ -0,0 +1,126 @@
+import logging
+import typing
+
+import mmh3
+import semver
+
+JsonPrimitive = typing.Union[str, bool, float, int]
+JsonLogicArg = typing.Union[JsonPrimitive, typing.Sequence[JsonPrimitive]]
+
+logger = logging.getLogger("openfeature.contrib")
+
+
+def fractional(data: dict, *args: JsonLogicArg) -> typing.Optional[str]:
+    if not args:
+        logger.error("No arguments provided to fractional operator.")
+        return None
+
+    bucket_by = None
+    if isinstance(args[0], str):
+        bucket_by = args[0]
+        args = args[1:]
+    else:
+        seed = data.get("$flagd", {}).get("flagKey", "")
+        targeting_key = data.get("targetingKey")
+        if not targeting_key:
+            logger.error("No targetingKey provided for fractional shorthand syntax.")
+            return None
+        bucket_by = seed + targeting_key
+
+    if not bucket_by:
+        logger.error("No hashKey value resolved")
+        return None
+
+    hash_ratio = abs(mmh3.hash(bucket_by)) / (2**31 - 1)
+    bucket = int(hash_ratio * 100)
+
+    for arg in args:
+        if (
+            not isinstance(arg, (tuple, list))
+            or len(arg) != 2
+            or not isinstance(arg[0], str)
+            or not isinstance(arg[1], int)
+        ):
+            logger.error("Fractional variant weights must be (str, int) tuple")
+            return None
+    variant_weights: typing.Tuple[typing.Tuple[str, int]] = args  # type: ignore[assignment]
+
+    range_end = 0
+    for variant, weight in variant_weights:
+        range_end += weight
+        if bucket < range_end:
+            return variant
+
+    return None
+
+
+def starts_with(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:
+    def f(s1: str, s2: str) -> bool:
+        return s1.startswith(s2)
+
+    return string_comp(f, data, *args)
+
+
+def ends_with(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:
+    def f(s1: str, s2: str) -> bool:
+        return s1.endswith(s2)
+
+    return string_comp(f, data, *args)
+
+
+def string_comp(
+    comparator: typing.Callable[[str, str], bool], data: dict, *args: JsonLogicArg
+) -> typing.Optional[bool]:
+    if not args:
+        logger.error("No arguments provided to string_comp operator.")
+        return None
+    if len(args) != 2:
+        logger.error("Exactly 2 args expected for string_comp operator.")
+        return None
+    arg1, arg2 = args
+    if not isinstance(arg1, str):
+        logger.debug(f"incorrect argument for first argument, expected string: {arg1}")
+        return False
+    if not isinstance(arg2, str):
+        logger.debug(f"incorrect argument for second argument, expected string: {arg2}")
+        return False
+
+    return comparator(arg1, arg2)
+
+
+def sem_ver(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:  # noqa: C901
+    if not args:
+        logger.error("No arguments provided to sem_ver operator.")
+        return None
+    if len(args) != 3:
+        logger.error("Exactly 3 args expected for sem_ver operator.")
+        return None
+
+    arg1, op, arg2 = args
+
+    try:
+        v1 = semver.Version.parse(str(arg1))
+        v2 = semver.Version.parse(str(arg2))
+    except ValueError as e:
+        logger.exception(e)
+        return None
+
+    if op == "=":
+        return v1 == v2
+    elif op == "!=":
+        return v1 != v2
+    elif op == "<":
+        return v1 < v2
+    elif op == "<=":
+        return v1 <= v2
+    elif op == ">":
+        return v1 > v2
+    elif op == ">=":
+        return v1 >= v2
+    elif op == "^":
+        return v1.major == v2.major
+    elif op == "~":
+        return v1.major == v2.major and v1.minor == v2.minor
+    else:
+        logger.error(f"Op not supported by sem_ver: {op}")
+        return None