openfeature-provider-flagd 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

openfeature/contrib/provider/flagd/config.py

@@ -0,0 +1,59 @@
+import os
+import typing
+from enum import Enum
+
+T = typing.TypeVar("T")
+
+
+def str_to_bool(val: str) -> bool:
+    return val.lower() == "true"
+
+
+def env_or_default(
+    env_var: str, default: T, cast: typing.Optional[typing.Callable[[str], T]] = None
+) -> typing.Union[str, T]:
+    val = os.environ.get(env_var)
+    if val is None:
+        return default
+    return val if cast is None else cast(val)
+
+
+class ResolverType(Enum):
+    GRPC = "grpc"
+    IN_PROCESS = "in-process"
+
+
+class Config:
+    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 = (
+            env_or_default("FLAGD_PORT", 8013, cast=int) if port is None else port
+        )
+        self.tls = (
+            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/contrib/provider/flagd/provider.py

@@ -22,181 +22,115 @@
 """
 
 import typing
-from numbers import Number
-
-import grpc
-from google.protobuf.struct_pb2 import Struct
 
 from openfeature.evaluation_context import EvaluationContext
-from openfeature.exception import (
-    FlagNotFoundError,
-    GeneralError,
-    InvalidContextError,
-    ParseError,
-    TypeMismatchError,
-)
-from openfeature.flag_evaluation import FlagEvaluationDetails
+from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.provider.metadata import Metadata
 from openfeature.provider.provider import AbstractProvider
 
-from .defaults import Defaults
-from .flag_type import FlagType
-from .proto.schema.v1 import schema_pb2, schema_pb2_grpc
+from .config import Config, ResolverType
+from .resolvers import AbstractResolver, GrpcResolver, InProcessResolver
+
+T = typing.TypeVar("T")
 
 
 class FlagdProvider(AbstractProvider):
     """Flagd OpenFeature Provider"""
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
-        name: str = "flagd",
-        schema: str = Defaults.SCHEMA,
-        host: str = Defaults.HOST,
-        port: int = Defaults.PORT,
-        timeout: int = Defaults.TIMEOUT,
+        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 name: the name of the provider to be stored in metadata
-        :param schema: the schema for the transport protocol, e.g. 'http', 'https'
         :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.provider_name = name
-        self.schema = schema
-        self.host = host
-        self.port = port
-        self.timeout = timeout
-
-        channel_factory = (
-            grpc.insecure_channel if schema == "http" else grpc.secure_channel
+        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.channel = channel_factory(f"{self.host}:{self.port}")
-        self.stub = schema_pb2_grpc.ServiceStub(self.channel)
 
-    def shutdown(self):
-        self.channel.close()
+        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 get_metadata(self):
+    def shutdown(self) -> None:
+        if self.resolver:
+            self.resolver.shutdown()
+
+    def get_metadata(self) -> Metadata:
         """Returns provider metadata"""
-        return {
-            "name": self.get_name(),
-            "schema": self.schema,
-            "host": self.host,
-            "port": self.port,
-            "timeout": self.timeout,
-        }
-
-    def get_name(self) -> str:
-        """Returns provider name"""
-        return self.provider_name
+        return Metadata(name="FlagdProvider")
 
     def resolve_boolean_details(
         self,
         key: str,
         default_value: bool,
-        evaluation_context: EvaluationContext = None,
-    ):
-        return self._resolve(key, FlagType.BOOLEAN, default_value, evaluation_context)
+        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: EvaluationContext = None,
-    ):
-        return self._resolve(key, FlagType.STRING, default_value, evaluation_context)
+        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: Number,
-        evaluation_context: EvaluationContext = None,
-    ):
-        return self._resolve(key, FlagType.FLOAT, default_value, evaluation_context)
+        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: Number,
-        evaluation_context: EvaluationContext = None,
-    ):
-        return self._resolve(key, FlagType.INTEGER, default_value, evaluation_context)
+        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: EvaluationContext = None,
-    ):
-        return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
-
-    def _resolve(
-        self,
-        flag_key: str,
-        flag_type: FlagType,
-        default_value: typing.Any,
-        evaluation_context: EvaluationContext,
-    ):
-        context = self._convert_context(evaluation_context)
-        try:
-            if flag_type == FlagType.BOOLEAN:
-                request = schema_pb2.ResolveBooleanRequest(
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveBoolean(request)
-            elif flag_type == FlagType.STRING:
-                request = schema_pb2.ResolveStringRequest(
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveString(request)
-            elif flag_type == FlagType.OBJECT:
-                request = schema_pb2.ResolveObjectRequest(
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveObject(request)
-            elif flag_type == FlagType.FLOAT:
-                request = schema_pb2.ResolveFloatRequest(
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveFloat(request)
-            elif flag_type == FlagType.INTEGER:
-                request = schema_pb2.ResolveIntRequest(
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveInt(request)
-            else:
-                raise ValueError(f"Unknown flag type: {flag_type}")
-
-        except grpc.RpcError as e:
-            code = e.code()
-            message = f"received grpc status code {code}"
-
-            if code == grpc.StatusCode.NOT_FOUND:
-                raise FlagNotFoundError(message) from e
-            elif code == grpc.StatusCode.INVALID_ARGUMENT:
-                raise TypeMismatchError(message) from e
-            elif code == grpc.StatusCode.DATA_LOSS:
-                raise ParseError(message) from e
-            raise GeneralError(message) from e
-
-        # Got a valid flag and valid type. Return it.
-        return FlagEvaluationDetails(
-            flag_key=flag_key,
-            value=response.value,
-            reason=response.reason,
-            variant=response.variant,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self.resolver.resolve_object_details(
+            key, default_value, evaluation_context
         )
-
-    def _convert_context(self, evaluation_context: EvaluationContext):
-        s = Struct()
-        if evaluation_context:
-            try:
-                s.update(evaluation_context.attributes)
-            except ValueError as exc:
-                message = (
-                    "could not serialize evaluation context to google.protobuf.Struct"
-                )
-                raise InvalidContextError(message) from exc
-        return s

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/contrib/provider/flagd/resolvers/grpc.py

@@ -0,0 +1,145 @@
+import typing
+
+import grpc
+from google.protobuf.struct_pb2 import Struct
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import (
+    FlagNotFoundError,
+    GeneralError,
+    InvalidContextError,
+    ParseError,
+    TypeMismatchError,
+)
+from openfeature.flag_evaluation import FlagResolutionDetails
+
+from ..config import Config
+from ..flag_type import FlagType
+from ..proto.schema.v1 import schema_pb2, schema_pb2_grpc
+
+T = typing.TypeVar("T")
+
+
+class GrpcResolver:
+    def __init__(self, config: Config):
+        self.config = config
+        channel_factory = (
+            grpc.secure_channel if self.config.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 resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(key, FlagType.BOOLEAN, 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, FlagType.STRING, 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, FlagType.FLOAT, 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, FlagType.INTEGER, 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, FlagType.OBJECT, default_value, evaluation_context)
+
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: T,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[T]:
+        context = self._convert_context(evaluation_context)
+        call_args = {"timeout": self.config.timeout}
+        try:
+            if flag_type == FlagType.BOOLEAN:
+                request = schema_pb2.ResolveBooleanRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveBoolean(request, **call_args)
+            elif flag_type == FlagType.STRING:
+                request = schema_pb2.ResolveStringRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveString(request, **call_args)
+            elif flag_type == FlagType.OBJECT:
+                request = schema_pb2.ResolveObjectRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveObject(request, **call_args)
+            elif flag_type == FlagType.FLOAT:
+                request = schema_pb2.ResolveFloatRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveFloat(request, **call_args)
+            elif flag_type == FlagType.INTEGER:
+                request = schema_pb2.ResolveIntRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveInt(request, **call_args)
+            else:
+                raise ValueError(f"Unknown flag type: {flag_type}")
+
+        except grpc.RpcError as e:
+            code = e.code()
+            message = f"received grpc status code {code}"
+
+            if code == grpc.StatusCode.NOT_FOUND:
+                raise FlagNotFoundError(message) from e
+            elif code == grpc.StatusCode.INVALID_ARGUMENT:
+                raise TypeMismatchError(message) from e
+            elif code == grpc.StatusCode.DATA_LOSS:
+                raise ParseError(message) from e
+            raise GeneralError(message) from e
+
+        # Got a valid flag and valid type. Return it.
+        return FlagResolutionDetails(
+            value=response.value,
+            reason=response.reason,
+            variant=response.variant,
+        )
+
+    def _convert_context(
+        self, evaluation_context: typing.Optional[EvaluationContext]
+    ) -> Struct:
+        s = Struct()
+        if evaluation_context:
+            try:
+                s["targetingKey"] = evaluation_context.targeting_key
+                s.update(evaluation_context.attributes)
+            except ValueError as exc:
+                message = (
+                    "could not serialize evaluation context to google.protobuf.Struct"
+                )
+                raise InvalidContextError(message) from exc
+        return s

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/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

openfeature/contrib/provider/flagd/resolvers/process/file_watcher.py

@@ -0,0 +1,89 @@
+import json
+import logging
+import os
+import re
+import threading
+import time
+import typing
+
+import yaml
+
+from openfeature.event import ProviderEventDetails
+from openfeature.exception import ParseError
+from openfeature.provider.provider import AbstractProvider
+
+from .flags import Flag
+
+logger = logging.getLogger("openfeature.contrib")
+
+
+class FileWatcherFlagStore:
+    def __init__(
+        self,
+        file_path: str,
+        provider: AbstractProvider,
+        poll_interval_seconds: float = 1.0,
+    ):
+        self.file_path = file_path
+        self.provider = provider
+        self.poll_interval_seconds = poll_interval_seconds
+
+        self.last_modified = 0.0
+        self.flag_data: typing.Mapping[str, Flag] = {}
+        self.load_data()
+        self.thread = threading.Thread(target=self.refresh_file, daemon=True)
+        self.thread.start()
+
+    def shutdown(self) -> None:
+        pass
+
+    def get_flag(self, key: str) -> typing.Optional[Flag]:
+        return self.flag_data.get(key)
+
+    def refresh_file(self) -> None:
+        while True:
+            time.sleep(self.poll_interval_seconds)
+            logger.debug("checking for new flag store contents from file")
+            last_modified = os.path.getmtime(self.file_path)
+            if last_modified > self.last_modified:
+                self.load_data(last_modified)
+
+    def load_data(self, modified_time: typing.Optional[float] = None) -> None:
+        try:
+            with open(self.file_path) as file:
+                if self.file_path.endswith(".yaml"):
+                    data = yaml.safe_load(file)
+                else:
+                    data = json.load(file)
+
+                self.flag_data = self.parse_flags(data)
+                logger.debug(f"{self.flag_data=}")
+                self.provider.emit_provider_configuration_changed(
+                    ProviderEventDetails(flags_changed=list(self.flag_data.keys()))
+                )
+            self.last_modified = modified_time or os.path.getmtime(self.file_path)
+        except FileNotFoundError:
+            logger.exception("Provided file path not valid")
+        except json.JSONDecodeError:
+            logger.exception("Could not parse JSON flag data from file")
+        except yaml.error.YAMLError:
+            logger.exception("Could not parse YAML flag data from file")
+        except ParseError:
+            logger.exception("Could not parse flag data using flagd syntax")
+        except Exception:
+            logger.exception("Could not read flags from file")
+
+    def parse_flags(self, flags_data: dict) -> dict:
+        flags = flags_data.get("flags", {})
+        evaluators: typing.Optional[dict] = flags_data.get("$evaluators")
+        if evaluators:
+            transposed = json.dumps(flags)
+            for name, rule in evaluators.items():
+                transposed = re.sub(
+                    rf"{{\s*\"\$ref\":\s*\"{name}\"\s*}}", json.dumps(rule), transposed
+                )
+            flags = json.loads(transposed)
+
+        if not isinstance(flags, dict):
+            raise ParseError("`flags` key of configuration must be a dictionary")
+        return {key: Flag.from_dict(key, data) for key, data in flags.items()}

openfeature/contrib/provider/flagd/resolvers/process/flags.py

@@ -0,0 +1,51 @@
+import typing
+from dataclasses import dataclass
+
+from openfeature.exception import ParseError
+
+
+@dataclass
+class Flag:
+    key: str
+    state: str
+    variants: typing.Mapping[str, typing.Any]
+    default_variant: typing.Union[bool, str]
+    targeting: typing.Optional[dict] = None
+
+    def __post_init__(self) -> None:
+        if not self.state or not isinstance(self.state, str):
+            raise ParseError("Incorrect 'state' value provided in flag config")
+
+        if not self.variants or not isinstance(self.variants, dict):
+            raise ParseError("Incorrect 'variants' value provided in flag config")
+
+        if not self.default_variant or not isinstance(
+            self.default_variant, (str, bool)
+        ):
+            raise ParseError("Incorrect 'defaultVariant' value provided in flag config")
+
+        if self.targeting and not isinstance(self.targeting, dict):
+            raise ParseError("Incorrect 'targeting' value provided in flag config")
+
+        if self.default_variant not in self.variants:
+            raise ParseError("Default variant does not match set of variants")
+
+    @classmethod
+    def from_dict(cls, key: str, data: dict) -> "Flag":
+        data["default_variant"] = data["defaultVariant"]
+        del data["defaultVariant"]
+        flag = cls(key=key, **data)
+
+        return flag
+
+    @property
+    def default(self) -> typing.Tuple[str, typing.Any]:
+        return self.get_variant(self.default_variant)
+
+    def get_variant(
+        self, variant_key: typing.Union[str, bool]
+    ) -> typing.Tuple[str, typing.Any]:
+        if isinstance(variant_key, bool):
+            variant_key = str(variant_key).lower()
+
+        return variant_key, self.variants.get(variant_key)

{openfeature_provider_flagd-0.1.3.dist-info → openfeature_provider_flagd-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: openfeature-provider-flagd
-Version: 0.1.3
+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.3.dist-info → openfeature_provider_flagd-0.1.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
 openfeature/contrib/provider/flagd/__init__.py,sha256=WlrcPaCH31dEG1IvrvpeuhAaQ8Ni8LEzDpNM_x-qKOA,65
-openfeature/contrib/provider/flagd/defaults.py,sha256=OeTt08wp_GUzpUetEJQvhSBGk9u4gTzACILQVqicbUw,102
+openfeature/contrib/provider/flagd/config.py,sha256=DF_pAm1jYWIUTS7564YHI1mLBb1v3z7MstRgMwUHsmA,1921
 openfeature/contrib/provider/flagd/flag_type.py,sha256=rZYfmqQEmtqVVTb8e-d8Wt8ZCnHtf7xPSmYxyU8w0R0,158
-openfeature/contrib/provider/flagd/provider.py,sha256=2CZxQNJfcP8S5UJgDfwp6Q-znHRRaBpP7W7sGNS5lqk,6779
+openfeature/contrib/provider/flagd/provider.py,sha256=i5_hJmy-EdbltQaPfcbCk6j9k1YkUnKxgubzKIQK3dQ,4614
 openfeature/contrib/provider/flagd/proto/flagd/evaluation/v1/evaluation_pb2.py,sha256=W0Vgg8z7nEg_HTlAJkO6pu5nBcR8Ls3yoIykboavLRI,7704
 openfeature/contrib/provider/flagd/proto/flagd/evaluation/v1/evaluation_pb2_grpc.py,sha256=GTKQXbUfRrquUG5o11N7ymhFnOuzh9_hcToZ9-cjOtA,13339
 openfeature/contrib/provider/flagd/proto/flagd/sync/v1/sync_pb2.py,sha256=zUu_-V6DhHH5ZekWVsxKjGkUwkJrRrhqyXj8oX-Jo_g,3205
@@ -10,7 +10,13 @@ openfeature/contrib/provider/flagd/proto/schema/v1/schema_pb2.py,sha256=onIastnV
 openfeature/contrib/provider/flagd/proto/schema/v1/schema_pb2_grpc.py,sha256=nllthJYfwhDBZHH_eGfSHesNbO6rJEZ0vXKyTFFy4AA,12393
 openfeature/contrib/provider/flagd/proto/sync/v1/sync_service_pb2.py,sha256=uKBjB_lpfHN3r8wsjmqnQEBLtN9gw8zPmvWfWKsOYAE,2954
 openfeature/contrib/provider/flagd/proto/sync/v1/sync_service_pb2_grpc.py,sha256=v5MSyyIOpE68EYWjsbdAq677gnD4jdNeLhMAB7EveNQ,4424
-openfeature_provider_flagd-0.1.3.dist-info/METADATA,sha256=HCF4wFfmAKKkyOoHg_I3-1IHvAtbvnWhYkSbZUI1PRo,14518
-openfeature_provider_flagd-0.1.3.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-openfeature_provider_flagd-0.1.3.dist-info/licenses/LICENSE,sha256=h8jwqxShIeVkc8vOo9ynxGYW16f4fVPxLhZKZs0H5U8,11350
-openfeature_provider_flagd-0.1.3.dist-info/RECORD,,
+openfeature/contrib/provider/flagd/resolvers/__init__.py,sha256=kM5bt6cJCQgCsvJd1Tb2YD050X06wk8rK249JmNjoUc,1468
+openfeature/contrib/provider/flagd/resolvers/grpc.py,sha256=9F-jX08Ynar5d2cgTV90lDQxgxIlxKg9KEIwueCU3u8,5460
+openfeature/contrib/provider/flagd/resolvers/in_process.py,sha256=-RGKP9xC4Ic65-gBLvjMJJ-7EKDKsKnEu_0GdqGHaKk,4383
+openfeature/contrib/provider/flagd/resolvers/process/custom_ops.py,sha256=8vscgX-SA_lnjb8Tg4S_qrVspqeVwtyXc8F846tcdc8,3644
+openfeature/contrib/provider/flagd/resolvers/process/file_watcher.py,sha256=0GMA-gs6PchT4tW_daV1LwFmCw21mVa_WawusW72xWA,3191
+openfeature/contrib/provider/flagd/resolvers/process/flags.py,sha256=aE-i-ghpjoGejOwP3K4DotcdHYw_o393oxrMaBmpgko,1718
+openfeature_provider_flagd-0.1.5.dist-info/METADATA,sha256=rWFt0M5Qb54eiiLaEPhhHVCzwY5PlxLYZwEToiMaCTA,15005
+openfeature_provider_flagd-0.1.5.dist-info/WHEEL,sha256=as-1oFTWSeWBgyzh0O_qF439xqBe6AbBgt4MfYe5zwY,87
+openfeature_provider_flagd-0.1.5.dist-info/licenses/LICENSE,sha256=h8jwqxShIeVkc8vOo9ynxGYW16f4fVPxLhZKZs0H5U8,11350
+openfeature_provider_flagd-0.1.5.dist-info/RECORD,,

{openfeature_provider_flagd-0.1.3.dist-info → openfeature_provider_flagd-0.1.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.1
+Generator: hatchling 1.22.5
 Root-Is-Purelib: true
 Tag: py3-none-any

openfeature/contrib/provider/flagd/defaults.py

@@ -1,5 +0,0 @@
-class Defaults:
-    HOST = "localhost"
-    PORT = 8013
-    SCHEMA = "http"
-    TIMEOUT = 2  # seconds