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

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

@@ -0,0 +1,218 @@
+import json
+import logging
+import threading
+import time
+import typing
+
+import grpc
+from google.protobuf.json_format import MessageToDict
+
+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, dict], 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.provider_id = config.provider_id
+        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: list[tuple[str, typing.Any]] = [
+            ("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.default_authority is not None:
+            options.append(("grpc.default_authority", config.default_authority))
+
+        if config.channel_credentials is not None:
+            channel_args = {
+                "options": options,
+                "credentials": config.channel_credentials,
+            }
+            channel = grpc.secure_channel(target, **channel_args)
+
+        elif 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
+            or new_state == grpc.ChannelConnectivity.IDLE
+        ):
+            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 = {}
+        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
+
+        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 = MessageToDict(context_values_response)
+
+                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"
+                            ),
+                            context_values["metadata"],
+                        )
+                        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

@@ -1,5 +1,6 @@
 import logging
 import typing
+from dataclasses import dataclass
 
 import mmh3
 import semver
@@ -10,6 +11,12 @@ 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.")
@@ -32,28 +39,52 @@ def fractional(data: dict, *args: JsonLogicArg) -> typing.Optional[str]:
         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]
+    bucket = hash_ratio * 100
 
-    range_end = 0
-    for variant, weight in variant_weights:
-        range_end += weight
-        if bucket < range_end:
-            return variant
+    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)
@@ -99,8 +130,8 @@ def sem_ver(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:  # noqa:
     arg1, op, arg2 = args
 
     try:
-        v1 = semver.Version.parse(str(arg1))
-        v2 = semver.Version.parse(str(arg2))
+        v1 = parse_version(arg1)
+        v2 = parse_version(arg2)
     except ValueError as e:
         logger.exception(e)
         return None
@@ -124,3 +155,11 @@ def sem_ver(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:  # noqa:
     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

@@ -1,9 +1,45 @@
+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
@@ -32,19 +68,27 @@ class Flag:
 
     @classmethod
     def from_dict(cls, key: str, data: dict) -> "Flag":
-        data["default_variant"] = data["defaultVariant"]
-        del data["defaultVariant"]
-        flag = cls(key=key, **data)
+        if "defaultVariant" in data:
+            data["default_variant"] = data["defaultVariant"]
+            del data["defaultVariant"]
 
-        return flag
+        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) -> typing.Tuple[str, typing.Any]:
+    def default(self) -> 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]:
+    ) -> tuple[str, typing.Any]:
         if isinstance(variant_key, bool):
             variant_key = str(variant_key).lower()
 

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

@@ -0,0 +1,14 @@
+import typing
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.hook import Hook, HookContext, HookHints
+
+
+class SyncMetadataHook(Hook):
+    def __init__(self, context_supplier: typing.Callable[[], EvaluationContext]):
+        self.context_supplier = context_supplier
+
+    def before(
+        self, hook_context: HookContext, hints: HookHints
+    ) -> typing.Optional[EvaluationContext]:
+        return self.context_supplier()

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)