openfeature-provider-flagd 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

openfeature/contrib/provider/flagd/resolvers/process/connector/grpc_watcher.py

@@ -0,0 +1,192 @@
+import json
+import logging
+import threading
+import time
+import typing
+
+import grpc
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
+from openfeature.exception import ErrorCode, ParseError, ProviderNotReadyError
+from openfeature.schemas.protobuf.flagd.sync.v1 import (
+    sync_pb2,
+    sync_pb2_grpc,
+)
+
+from ....config import Config
+from ..connector import FlagStateConnector
+from ..flags import FlagStore
+
+logger = logging.getLogger("openfeature.contrib")
+
+
+class GrpcWatcher(FlagStateConnector):
+    def __init__(
+        self,
+        config: Config,
+        flag_store: FlagStore,
+        emit_provider_ready: typing.Callable[[ProviderEventDetails], None],
+        emit_provider_error: typing.Callable[[ProviderEventDetails], None],
+        emit_provider_stale: typing.Callable[[ProviderEventDetails], None],
+    ):
+        self.flag_store = flag_store
+        self.config = config
+
+        self.channel = self._generate_channel(config)
+        self.stub = sync_pb2_grpc.FlagSyncServiceStub(self.channel)
+        self.retry_backoff_seconds = config.retry_backoff_ms * 0.001
+        self.retry_backoff_max_seconds = config.retry_backoff_ms * 0.001
+        self.retry_grace_period = config.retry_grace_period
+        self.streamline_deadline_seconds = config.stream_deadline_ms * 0.001
+        self.deadline = config.deadline_ms * 0.001
+        self.selector = config.selector
+        self.emit_provider_ready = emit_provider_ready
+        self.emit_provider_error = emit_provider_error
+        self.emit_provider_stale = emit_provider_stale
+
+        self.connected = False
+        self.thread: typing.Optional[threading.Thread] = None
+        self.timer: typing.Optional[threading.Timer] = None
+
+        self.start_time = time.time()
+
+    def _generate_channel(self, config: Config) -> grpc.Channel:
+        target = f"{config.host}:{config.port}"
+        # Create the channel with the service config
+        options = [
+            ("grpc.keepalive_time_ms", config.keep_alive_time),
+            ("grpc.initial_reconnect_backoff_ms", config.retry_backoff_ms),
+            ("grpc.max_reconnect_backoff_ms", config.retry_backoff_max_ms),
+            ("grpc.min_reconnect_backoff_ms", config.stream_deadline_ms),
+        ]
+        if config.tls:
+            channel_args = {
+                "options": options,
+                "credentials": grpc.ssl_channel_credentials(),
+            }
+            if config.cert_path:
+                with open(config.cert_path, "rb") as f:
+                    channel_args["credentials"] = grpc.ssl_channel_credentials(f.read())
+
+            channel = grpc.secure_channel(target, **channel_args)
+
+        else:
+            channel = grpc.insecure_channel(
+                target,
+                options=options,
+            )
+
+        return channel
+
+    def initialize(self, context: EvaluationContext) -> None:
+        self.connect()
+
+    def connect(self) -> None:
+        self.active = True
+
+        # Run monitoring in a separate thread
+        self.monitor_thread = threading.Thread(
+            target=self.monitor, daemon=True, name="FlagdGrpcSyncServiceMonitorThread"
+        )
+        self.monitor_thread.start()
+        ## block until ready or deadline reached
+        timeout = self.deadline + time.time()
+        while not self.connected and time.time() < timeout:
+            time.sleep(0.05)
+        logger.debug("Finished blocking gRPC state initialization")
+
+        if not self.connected:
+            raise ProviderNotReadyError(
+                "Blocking init finished before data synced. Consider increasing startup deadline to avoid inconsistent evaluations."
+            )
+
+    def monitor(self) -> None:
+        self.channel.subscribe(self._state_change_callback, try_to_connect=True)
+
+    def _state_change_callback(self, new_state: grpc.ChannelConnectivity) -> None:
+        logger.debug(f"gRPC state change: {new_state}")
+        if new_state == grpc.ChannelConnectivity.READY:
+            if not self.thread or not self.thread.is_alive():
+                self.thread = threading.Thread(
+                    target=self.listen,
+                    daemon=True,
+                    name="FlagdGrpcSyncWorkerThread",
+                )
+                self.thread.start()
+
+            if self.timer and self.timer.is_alive():
+                logger.debug("gRPC error timer expired")
+                self.timer.cancel()
+
+        elif new_state == grpc.ChannelConnectivity.TRANSIENT_FAILURE:
+            # this is the failed reconnect attempt so we are going into stale
+            self.emit_provider_stale(
+                ProviderEventDetails(
+                    message="gRPC sync disconnected, reconnecting",
+                )
+            )
+            self.start_time = time.time()
+            # adding a timer, so we can emit the error event after time
+            self.timer = threading.Timer(self.retry_grace_period, self.emit_error)
+
+            logger.debug("gRPC error timer started")
+            self.timer.start()
+            self.connected = False
+
+    def emit_error(self) -> None:
+        logger.debug("gRPC error emitted")
+        self.emit_provider_error(
+            ProviderEventDetails(
+                message="gRPC sync disconnected, reconnecting",
+                error_code=ErrorCode.GENERAL,
+            )
+        )
+
+    def shutdown(self) -> None:
+        self.active = False
+        self.channel.close()
+
+    def listen(self) -> None:
+        call_args = (
+            {"timeout": self.streamline_deadline_seconds}
+            if self.streamline_deadline_seconds > 0
+            else {}
+        )
+        request_args = {"selector": self.selector} if self.selector is not None else {}
+
+        while self.active:
+            try:
+                request = sync_pb2.SyncFlagsRequest(**request_args)
+
+                logger.debug("Setting up gRPC sync flags connection")
+                for flag_rsp in self.stub.SyncFlags(
+                    request, wait_for_ready=True, **call_args
+                ):
+                    flag_str = flag_rsp.flag_configuration
+                    logger.debug(
+                        f"Received flag configuration - {abs(hash(flag_str)) % (10**8)}"
+                    )
+                    self.flag_store.update(json.loads(flag_str))
+
+                    if not self.connected:
+                        self.emit_provider_ready(
+                            ProviderEventDetails(
+                                message="gRPC sync connection established"
+                            )
+                        )
+                        self.connected = True
+
+                    if not self.active:
+                        logger.debug("Terminating gRPC sync thread")
+                        return
+            except grpc.RpcError as e:  # noqa: PERF203
+                logger.error(f"SyncFlags stream error, {e.code()=} {e.details()=}")
+            except json.JSONDecodeError:
+                logger.exception(
+                    f"Could not parse JSON flag data from SyncFlags endpoint: {flag_str=}"
+                )
+            except ParseError:
+                logger.exception(
+                    f"Could not parse flag data using flagd syntax: {flag_str=}"
+                )

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

@@ -0,0 +1,165 @@
+import logging
+import typing
+from dataclasses import dataclass
+
+import mmh3
+import semver
+
+JsonPrimitive = typing.Union[str, bool, float, int]
+JsonLogicArg = typing.Union[JsonPrimitive, typing.Sequence[JsonPrimitive]]
+
+logger = logging.getLogger("openfeature.contrib")
+
+
+@dataclass
+class Fraction:
+    variant: str
+    weight: int = 1
+
+
+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 = hash_ratio * 100
+
+    total_weight = 0
+    fractions = []
+    try:
+        for arg in args:
+            fraction = _parse_fraction(arg)
+            if fraction:
+                fractions.append(fraction)
+                total_weight += fraction.weight
+
+    except ValueError:
+        logger.debug(f"Invalid {args} configuration")
+        return None
+
+    range_end: float = 0
+    for fraction in fractions:
+        range_end += fraction.weight * 100 / total_weight
+        if bucket < range_end:
+            return fraction.variant
+    return None
+
+
+def _parse_fraction(arg: JsonLogicArg) -> Fraction:
+    if not isinstance(arg, (tuple, list)) or not arg or len(arg) > 2:
+        raise ValueError(
+            "Fractional variant weights must be (str, int) tuple or [str] list"
+        )
+
+    if not isinstance(arg[0], str):
+        raise ValueError(
+            "Fractional variant identifier (first element) isn't of type 'str'"
+        )
+
+    if len(arg) >= 2 and not isinstance(arg[1], int):
+        raise ValueError(
+            "Fractional variant weight value (second element) isn't of type 'int'"
+        )
+
+    fraction = Fraction(variant=arg[0])
+    if len(arg) >= 2:
+        fraction.weight = arg[1]
+
+    return fraction
+
+
+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 = parse_version(arg1)
+        v2 = parse_version(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
+
+
+def parse_version(arg: typing.Any) -> semver.Version:
+    version = str(arg)
+    if version.startswith(("v", "V")):
+        version = version[1:]
+
+    return semver.Version.parse(version)

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

@@ -0,0 +1,95 @@
+import json
+import re
+import typing
+from dataclasses import dataclass
+
+from openfeature.event import ProviderEventDetails
+from openfeature.exception import ParseError
+
+
+class FlagStore:
+    def __init__(
+        self,
+        emit_provider_configuration_changed: typing.Callable[
+            [ProviderEventDetails], None
+        ],
+    ):
+        self.emit_provider_configuration_changed = emit_provider_configuration_changed
+        self.flags: typing.Mapping[str, Flag] = {}
+
+    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", {})
+        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")
+        self.flags = {key: Flag.from_dict(key, data) for key, data in flags.items()}
+
+        self.emit_provider_configuration_changed(
+            ProviderEventDetails(flags_changed=list(self.flags.keys()))
+        )
+
+
+@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":
+        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"]
+        try:
+            flag = cls(key=key, **data)
+            return flag
+        except Exception as err:
+            raise ParseError from err
+
+    @property
+    def default(self) -> tuple[str, typing.Any]:
+        return self.get_variant(self.default_variant)
+
+    def get_variant(
+        self, variant_key: typing.Union[str, bool]
+    ) -> tuple[str, typing.Any]:
+        if isinstance(variant_key, bool):
+            variant_key = str(variant_key).lower()
+
+        return variant_key, self.variants.get(variant_key)

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

@@ -0,0 +1,35 @@
+import time
+import typing
+
+from json_logic import builtins, jsonLogic
+from json_logic.types import JsonValue
+
+from openfeature.evaluation_context import EvaluationContext
+
+from .custom_ops import (
+    ends_with,
+    fractional,
+    sem_ver,
+    starts_with,
+)
+
+OPERATORS = {
+    **builtins.BUILTINS,
+    "fractional": fractional,
+    "starts_with": starts_with,
+    "ends_with": ends_with,
+    "sem_ver": sem_ver,
+}
+
+
+def targeting(
+    key: str,
+    targeting: dict,
+    evaluation_context: typing.Optional[EvaluationContext] = None,
+) -> JsonValue:
+    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
+    )
+    return jsonLogic(targeting, json_logic_context, OPERATORS)

openfeature/contrib/provider/flagd/resolvers/protocol.py

@@ -0,0 +1,47 @@
+import typing
+
+from typing_extensions import Protocol
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.flag_evaluation import FlagResolutionDetails
+
+
+class AbstractResolver(Protocol):
+    def initialize(self, evaluation_context: EvaluationContext) -> None: ...
+
+    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]]: ...

openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation_pb2.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\nAopenfeature/schemas/protobuf/flagd/evaluation/v1/evaluation.proto\x12\x13\x66lagd.evaluation.v1\x1a\x1cgoogle/protobuf/struct.proto\"=\n\x11ResolveAllRequest\x12(\n\x07\x63ontext\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xa3\x01\n\x12ResolveAllResponse\x12\x41\n\x05\x66lags\x18\x01 \x03(\x0b\x32\x32.flagd.evaluation.v1.ResolveAllResponse.FlagsEntry\x1aJ\n\nFlagsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12+\n\x05value\x18\x02 \x01(\x0b\x32\x1c.flagd.evaluation.v1.AnyFlag:\x02\x38\x01\"\xaa\x01\n\x07\x41nyFlag\x12\x0e\n\x06reason\x18\x01 \x01(\t\x12\x0f\n\x07variant\x18\x02 \x01(\t\x12\x14\n\nbool_value\x18\x03 \x01(\x08H\x00\x12\x16\n\x0cstring_value\x18\x04 \x01(\tH\x00\x12\x16\n\x0c\x64ouble_value\x18\x05 \x01(\x01H\x00\x12/\n\x0cobject_value\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructH\x00\x42\x07\n\x05value\"S\n\x15ResolveBooleanRequest\x12\x10\n\x08\x66lag_key\x18\x01 \x01(\t\x12(\n\x07\x63ontext\x18\x02 \x01(\x0b\x32\x17.google.protobuf.Struct\"s\n\x16ResolveBooleanResponse\x12\r\n\x05value\x18\x01 \x01(\x08\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x0f\n\x07variant\x18\x03 \x01(\t\x12)\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"R\n\x14ResolveStringRequest\x12\x10\n\x08\x66lag_key\x18\x01 \x01(\t\x12(\n\x07\x63ontext\x18\x02 \x01(\x0b\x32\x17.google.protobuf.Struct\"r\n\x15ResolveStringResponse\x12\r\n\x05value\x18\x01 \x01(\t\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x0f\n\x07variant\x18\x03 \x01(\t\x12)\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"Q\n\x13ResolveFloatRequest\x12\x10\n\x08\x66lag_key\x18\x01 \x01(\t\x12(\n\x07\x63ontext\x18\x02 \x01(\x0b\x32\x17.google.protobuf.Struct\"q\n\x14ResolveFloatResponse\x12\r\n\x05value\x18\x01 \x01(\x01\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x0f\n\x07variant\x18\x03 \x01(\t\x12)\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"O\n\x11ResolveIntRequest\x12\x10\n\x08\x66lag_key\x18\x01 \x01(\t\x12(\n\x07\x63ontext\x18\x02 \x01(\x0b\x32\x17.google.protobuf.Struct\"o\n\x12ResolveIntResponse\x12\r\n\x05value\x18\x01 \x01(\x03\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x0f\n\x07variant\x18\x03 \x01(\t\x12)\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"R\n\x14ResolveObjectRequest\x12\x10\n\x08\x66lag_key\x18\x01 \x01(\t\x12(\n\x07\x63ontext\x18\x02 \x01(\x0b\x32\x17.google.protobuf.Struct\"\x8b\x01\n\x15ResolveObjectResponse\x12&\n\x05value\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x0f\n\x07variant\x18\x03 \x01(\t\x12)\n\x08metadata\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"J\n\x13\x45ventStreamResponse\x12\x0c\n\x04type\x18\x01 \x01(\t\x12%\n\x04\x64\x61ta\x18\x02 \x01(\x0b\x32\x17.google.protobuf.Struct\"\x14\n\x12\x45ventStreamRequest2\xd9\x05\n\x07Service\x12_\n\nResolveAll\x12&.flagd.evaluation.v1.ResolveAllRequest\x1a\'.flagd.evaluation.v1.ResolveAllResponse\"\x00\x12k\n\x0eResolveBoolean\x12*.flagd.evaluation.v1.ResolveBooleanRequest\x1a+.flagd.evaluation.v1.ResolveBooleanResponse\"\x00\x12h\n\rResolveString\x12).flagd.evaluation.v1.ResolveStringRequest\x1a*.flagd.evaluation.v1.ResolveStringResponse\"\x00\x12\x65\n\x0cResolveFloat\x12(.flagd.evaluation.v1.ResolveFloatRequest\x1a).flagd.evaluation.v1.ResolveFloatResponse\"\x00\x12_\n\nResolveInt\x12&.flagd.evaluation.v1.ResolveIntRequest\x1a\'.flagd.evaluation.v1.ResolveIntResponse\"\x00\x12h\n\rResolveObject\x12).flagd.evaluation.v1.ResolveObjectRequest\x1a*.flagd.evaluation.v1.ResolveObjectResponse\"\x00\x12\x64\n\x0b\x45ventStream\x12\'.flagd.evaluation.v1.EventStreamRequest\x1a(.flagd.evaluation.v1.EventStreamResponse\"\x00\x30\x01\x42\xc6\x01\n%dev.openfeature.flagd.grpc.evaluationZ\x13\x66lagd/evaluation/v1\xaa\x02!OpenFeature.Flagd.Grpc.Evaluation\xca\x02\x32OpenFeature\\Providers\\Flagd\\Schema\\Grpc\\Evaluation\xea\x02.OpenFeature::Flagd::Provider::Grpc::Evaluationb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'openfeature.schemas.protobuf.flagd.evaluation.v1.evaluation_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n%dev.openfeature.flagd.grpc.evaluationZ\023flagd/evaluation/v1\252\002!OpenFeature.Flagd.Grpc.Evaluation\312\0022OpenFeature\\Providers\\Flagd\\Schema\\Grpc\\Evaluation\352\002.OpenFeature::Flagd::Provider::Grpc::Evaluation'
+  _globals['_RESOLVEALLRESPONSE_FLAGSENTRY']._loaded_options = None
+  _globals['_RESOLVEALLRESPONSE_FLAGSENTRY']._serialized_options = b'8\001'
+  _globals['_RESOLVEALLREQUEST']._serialized_start=120
+  _globals['_RESOLVEALLREQUEST']._serialized_end=181
+  _globals['_RESOLVEALLRESPONSE']._serialized_start=184
+  _globals['_RESOLVEALLRESPONSE']._serialized_end=347
+  _globals['_RESOLVEALLRESPONSE_FLAGSENTRY']._serialized_start=273
+  _globals['_RESOLVEALLRESPONSE_FLAGSENTRY']._serialized_end=347
+  _globals['_ANYFLAG']._serialized_start=350
+  _globals['_ANYFLAG']._serialized_end=520
+  _globals['_RESOLVEBOOLEANREQUEST']._serialized_start=522
+  _globals['_RESOLVEBOOLEANREQUEST']._serialized_end=605
+  _globals['_RESOLVEBOOLEANRESPONSE']._serialized_start=607
+  _globals['_RESOLVEBOOLEANRESPONSE']._serialized_end=722
+  _globals['_RESOLVESTRINGREQUEST']._serialized_start=724
+  _globals['_RESOLVESTRINGREQUEST']._serialized_end=806
+  _globals['_RESOLVESTRINGRESPONSE']._serialized_start=808
+  _globals['_RESOLVESTRINGRESPONSE']._serialized_end=922
+  _globals['_RESOLVEFLOATREQUEST']._serialized_start=924
+  _globals['_RESOLVEFLOATREQUEST']._serialized_end=1005
+  _globals['_RESOLVEFLOATRESPONSE']._serialized_start=1007
+  _globals['_RESOLVEFLOATRESPONSE']._serialized_end=1120
+  _globals['_RESOLVEINTREQUEST']._serialized_start=1122
+  _globals['_RESOLVEINTREQUEST']._serialized_end=1201
+  _globals['_RESOLVEINTRESPONSE']._serialized_start=1203
+  _globals['_RESOLVEINTRESPONSE']._serialized_end=1314
+  _globals['_RESOLVEOBJECTREQUEST']._serialized_start=1316
+  _globals['_RESOLVEOBJECTREQUEST']._serialized_end=1398
+  _globals['_RESOLVEOBJECTRESPONSE']._serialized_start=1401
+  _globals['_RESOLVEOBJECTRESPONSE']._serialized_end=1540
+  _globals['_EVENTSTREAMRESPONSE']._serialized_start=1542
+  _globals['_EVENTSTREAMRESPONSE']._serialized_end=1616
+  _globals['_EVENTSTREAMREQUEST']._serialized_start=1618
+  _globals['_EVENTSTREAMREQUEST']._serialized_end=1638
+  _globals['_SERVICE']._serialized_start=1641
+  _globals['_SERVICE']._serialized_end=2370
+# @@protoc_insertion_point(module_scope)