openfeature-provider-flagd 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

openfeature/contrib/provider/flagd/provider.py

@@ -28,7 +28,7 @@ import grpc
 
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import ProviderEventDetails
-from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType
 from openfeature.hook import Hook
 from openfeature.provider import AbstractProvider
 from openfeature.provider.metadata import Metadata
@@ -75,6 +75,9 @@ class FlagdProvider(AbstractProvider):
         :param deadline_ms: the maximum to wait before a request times out
         :param timeout: the maximum time to wait before a request times out
         :param retry_backoff_ms: the number of milliseconds to backoff
+        :param selector: filter flag configurations by source (in-process mode only)
+                         Passed via both flagd-selector gRPC metadata header and request body
+                         for backward compatibility with all flagd versions.
         :param offline_flag_source_path: the path to the flag source file
         :param stream_deadline_ms: the maximum time to wait before a request times out
         :param keep_alive_time: the number of milliseconds to keep alive
@@ -199,9 +202,13 @@ class FlagdProvider(AbstractProvider):
     def resolve_object_details(
         self,
         flag_key: str,
-        default_value: typing.Union[dict, list],
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
         evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]:
         return self.resolver.resolve_object_details(
             flag_key, default_value, evaluation_context
         )

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

@@ -21,7 +21,7 @@ from openfeature.exception import (
     ProviderNotReadyError,
     TypeMismatchError,
 )
-from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType, Reason
 from openfeature.schemas.protobuf.flagd.evaluation.v1 import (
     evaluation_pb2,
     evaluation_pb2_grpc,
@@ -29,6 +29,7 @@ from openfeature.schemas.protobuf.flagd.evaluation.v1 import (
 
 from ..config import CacheType, Config
 from ..flag_type import FlagType
+from .types import GrpcMultiCallableArgs
 
 if typing.TYPE_CHECKING:
     from google.protobuf.message import Message
@@ -71,8 +72,6 @@ class GrpcResolver:
         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
@@ -121,15 +120,16 @@ class GrpcResolver:
             ),
         ]
         if config.tls:
-            channel_args = {
-                "options": options,
-                "credentials": grpc.ssl_channel_credentials(),
-            }
+            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())
+                    credentials = grpc.ssl_channel_credentials(f.read())
 
-            channel = grpc.secure_channel(target, **channel_args)
+            channel = grpc.secure_channel(
+                target,
+                credentials=credentials,
+                options=options,
+            )
 
         else:
             channel = grpc.insecure_channel(
@@ -161,8 +161,8 @@ class GrpcResolver:
         )
         self.monitor_thread.start()
         ## block until ready or deadline reached
-        timeout = self.deadline + time.time()
-        while not self.connected and time.time() < timeout:
+        timeout = self.deadline + time.monotonic()
+        while not self.connected and time.monotonic() < timeout:
             time.sleep(0.05)
         logger.debug("Finished blocking gRPC state initialization")
 
@@ -199,7 +199,6 @@ class GrpcResolver:
                     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)
 
@@ -220,20 +219,16 @@ class GrpcResolver:
 
     def listen(self) -> None:
         logger.debug("gRPC starting listener thread")
-        call_args = (
-            {"timeout": self.streamline_deadline_seconds}
-            if self.streamline_deadline_seconds > 0
-            else {}
-        )
+        call_args: GrpcMultiCallableArgs = {"wait_for_ready": True}
+        if self.streamline_deadline_seconds > 0:
+            call_args["timeout"] = self.streamline_deadline_seconds
         request = evaluation_pb2.EventStreamRequest()
 
         # defining a never ending loop to recreate the stream
         while self.active:
             try:
                 logger.debug("Setting up gRPC sync flags connection")
-                for message in self.stub.EventStream(
-                    request, wait_for_ready=True, **call_args
-                ):
+                for message in self.stub.EventStream(request, **call_args):
                     if message.type == "provider_ready":
                         self.emit_provider_ready(
                             ProviderEventDetails(
@@ -300,25 +295,81 @@ class GrpcResolver:
     def resolve_object_details(
         self,
         key: str,
-        default_value: typing.Union[dict, list],
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
         evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]:
         return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
 
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[bool]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[int]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[float]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[str]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]: ...
+
     def _resolve(  # noqa: PLR0915 C901
         self,
         flag_key: str,
         flag_type: FlagType,
-        default_value: T,
+        default_value: FlagValueType,
         evaluation_context: typing.Optional[EvaluationContext],
-    ) -> FlagResolutionDetails[T]:
+    ) -> FlagResolutionDetails[FlagValueType]:
         if self.cache is not None and flag_key in self.cache:
-            cached_flag: FlagResolutionDetails[T] = self.cache[flag_key]
+            cached_flag: FlagResolutionDetails[FlagValueType] = self.cache[flag_key]
             cached_flag.reason = Reason.CACHED
             return cached_flag
 
         context = self._convert_context(evaluation_context)
-        call_args = {"timeout": self.deadline, "wait_for_ready": True}
+        call_args: GrpcMultiCallableArgs = {
+            "timeout": self.deadline,
+            "wait_for_ready": True,
+        }
         try:
             request: Message
             if flag_type == FlagType.BOOLEAN:
@@ -387,7 +438,11 @@ class GrpcResolver:
         if evaluation_context:
             try:
                 s["targetingKey"] = evaluation_context.targeting_key
-                s.update(evaluation_context.attributes)
+                s.update(
+                    typing.cast(
+                        "typing.Mapping[str, typing.Any]", evaluation_context.attributes
+                    )
+                )
             except ValueError as exc:
                 message = (
                     "could not serialize evaluation context to google.protobuf.Struct"

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

@@ -5,13 +5,13 @@ from openfeature.contrib.provider.flagd.resolvers.process.connector.file_watcher
 )
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import ProviderEventDetails
-from openfeature.exception import FlagNotFoundError, ParseError
-from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.exception import ErrorCode, FlagNotFoundError, GeneralError, ParseError
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType, Reason
 
 from ..config import Config
 from .process.connector import FlagStateConnector
 from .process.connector.grpc_watcher import GrpcWatcher
-from .process.flags import FlagStore
+from .process.flags import Flag, FlagStore
 from .process.targeting import targeting
 
 T = typing.TypeVar("T")
@@ -105,9 +105,13 @@ class InProcessResolver:
     def resolve_object_details(
         self,
         key: str,
-        default_value: typing.Union[dict, list],
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
         evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]:
         return self._resolve(key, default_value, evaluation_context)
 
     def _resolve(
@@ -128,26 +132,30 @@ class InProcessResolver:
             )
 
         if not flag.targeting:
-            variant, value = flag.default
-            return FlagResolutionDetails(
-                value, variant=variant, flag_metadata=metadata, reason=Reason.STATIC
-            )
+            return _default_resolve(flag, metadata, Reason.STATIC)
 
-        variant = targeting(flag.key, flag.targeting, evaluation_context)
+        try:
+            variant = targeting(flag.key, flag.targeting, evaluation_context)
+            if variant is None:
+                return _default_resolve(flag, metadata, Reason.DEFAULT)
 
-        if variant is None:
-            variant, value = flag.default
-            return FlagResolutionDetails(
-                value, variant=variant, flag_metadata=metadata, reason=Reason.DEFAULT
-            )
-        if not isinstance(variant, (str, bool)):
-            raise ParseError(
-                "Parsed JSONLogic targeting did not return a string or bool"
-            )
+            # convert to string to support shorthand (boolean in python is with capital T hence the special case)
+            if isinstance(variant, bool):
+                variant = str(variant).lower()
+            elif not isinstance(variant, str):
+                variant = str(variant)
+
+            if variant not in flag.variants:
+                raise GeneralError(
+                    f"Resolved variant {variant} not in variants config."
+                )
+
+        except ReferenceError:
+            raise ParseError(f"Invalid targeting {targeting}") from ReferenceError
 
         variant, value = flag.get_variant(variant)
         if value is None:
-            raise ParseError(f"Resolved variant {variant} not in variants config.")
+            raise GeneralError(f"Resolved variant {variant} not in variants config.")
 
         return FlagResolutionDetails(
             value,
@@ -155,3 +163,24 @@ class InProcessResolver:
             reason=Reason.TARGETING_MATCH,
             flag_metadata=metadata,
         )
+
+
+def _default_resolve(
+    flag: Flag,
+    metadata: typing.Mapping[str, typing.Union[float, int, str, bool]],
+    reason: Reason,
+) -> FlagResolutionDetails:
+    variant, value = flag.default
+    if variant is None:
+        return FlagResolutionDetails(
+            value,
+            variant=variant,
+            reason=Reason.ERROR,
+            error_code=ErrorCode.FLAG_NOT_FOUND,
+            flag_metadata=metadata,
+        )
+    if variant not in flag.variants:
+        raise GeneralError(f"Resolved variant {variant} not in variants config.")
+    return FlagResolutionDetails(
+        value, variant=variant, flag_metadata=metadata, reason=reason
+    )

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

@@ -6,7 +6,7 @@ import typing
 
 import grpc
 from google.protobuf.json_format import MessageToDict
-from google.protobuf.struct_pb2 import Struct
+from grpc import StatusCode
 
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import ProviderEventDetails
@@ -17,6 +17,7 @@ from openfeature.schemas.protobuf.flagd.sync.v1 import (
 )
 
 from ....config import Config
+from ...types import GrpcMultiCallableArgs
 from ..connector import FlagStateConnector
 from ..flags import FlagStore
 
@@ -52,8 +53,6 @@ class GrpcWatcher(FlagStateConnector):
         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
@@ -105,22 +104,23 @@ class GrpcWatcher(FlagStateConnector):
             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)
+            channel = grpc.secure_channel(
+                target,
+                credentials=config.channel_credentials,
+                options=options,
+            )
 
         elif config.tls:
-            channel_args = {
-                "options": options,
-                "credentials": grpc.ssl_channel_credentials(),
-            }
+            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())
+                    credentials = grpc.ssl_channel_credentials(f.read())
 
-            channel = grpc.secure_channel(target, **channel_args)
+            channel = grpc.secure_channel(
+                target,
+                credentials=credentials,
+                options=options,
+            )
 
         else:
             channel = grpc.insecure_channel(
@@ -142,8 +142,8 @@ class GrpcWatcher(FlagStateConnector):
         )
         self.monitor_thread.start()
         ## block until ready or deadline reached
-        timeout = self.deadline + time.time()
-        while not self.connected and time.time() < timeout:
+        timeout = self.deadline + time.monotonic()
+        while not self.connected and time.monotonic() < timeout:
             time.sleep(0.05)
         logger.debug("Finished blocking gRPC state initialization")
 
@@ -180,7 +180,6 @@ class GrpcWatcher(FlagStateConnector):
                     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)
 
@@ -203,6 +202,8 @@ class GrpcWatcher(FlagStateConnector):
 
     def _create_request_args(self) -> dict:
         request_args = {}
+        # Pass selector in both request body (legacy) and metadata header (new) for backward compatibility
+        # This ensures compatibility with both older and newer flagd versions
         if self.selector is not None:
             request_args["selector"] = self.selector
         if self.provider_id is not None:
@@ -210,47 +211,68 @@ class GrpcWatcher(FlagStateConnector):
 
         return request_args
 
+    def _create_metadata(self) -> typing.Optional[tuple[tuple[str, str]]]:
+        """Create gRPC metadata headers for the request.
+
+        Returns gRPC metadata as a tuples of tuples containing header key-value pairs.
+        The selector is passed via the 'flagd-selector' header per flagd v0.11.0+ specification,
+        while also being included in the request body for backward compatibility with older flagd versions.
+        """
+        if self.selector is None:
+            return None
+
+        return (("flagd-selector", self.selector),)
+
+    def _fetch_metadata(self) -> typing.Optional[sync_pb2.GetMetadataResponse]:
+        if self.config.sync_metadata_disabled:
+            return None
+
+        context_values_request = sync_pb2.GetMetadataRequest()
+        try:
+            context_values_response: sync_pb2.GetMetadataResponse = (
+                self.stub.GetMetadata(context_values_request, wait_for_ready=True)
+            )
+            return context_values_response
+        except grpc.RpcError as e:
+            if e.code() == StatusCode.UNIMPLEMENTED:
+                logger.debug(f"Error getting sync metadata: {e}")
+                return None
+            else:
+                raise e
+
     def listen(self) -> None:
-        call_args = (
-            {"timeout": self.streamline_deadline_seconds}
-            if self.streamline_deadline_seconds > 0
-            else {}
-        )
+        call_args = self.generate_grpc_call_args()
+
         request_args = self._create_request_args()
 
         while self.active:
             try:
-                context_values_response: sync_pb2.GetMetadataResponse
-                if self.config.sync_metadata_disabled:
-                    context_values_response = sync_pb2.GetMetadataResponse(
-                        metadata=Struct()
-                    )
-                else:
-                    context_values_request = sync_pb2.GetMetadataRequest()
-                    context_values_response = self.stub.GetMetadata(
-                        context_values_request, wait_for_ready=True
-                    )
-
-                context_values = MessageToDict(context_values_response)
+                context_values_response = self._fetch_metadata()
 
                 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
-                ):
+                for flag_rsp in self.stub.SyncFlags(request, **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))
 
+                    context_values = {}
+                    if flag_rsp.sync_context:
+                        context_values = MessageToDict(flag_rsp.sync_context)
+                    elif context_values_response:
+                        context_values = MessageToDict(context_values_response)[
+                            "metadata"
+                        ]
+
                     if not self.connected:
                         self.emit_provider_ready(
                             ProviderEventDetails(
                                 message="gRPC sync connection established"
                             ),
-                            context_values["metadata"],
+                            context_values,
                         )
                         self.connected = True
 
@@ -267,3 +289,13 @@ class GrpcWatcher(FlagStateConnector):
                 logger.exception(
                     f"Could not parse flag data using flagd syntax: {flag_str=}"
                 )
+
+    def generate_grpc_call_args(self) -> GrpcMultiCallableArgs:
+        call_args: GrpcMultiCallableArgs = {"wait_for_ready": True}
+        if self.streamline_deadline_seconds > 0:
+            call_args["timeout"] = self.streamline_deadline_seconds
+        # Add selector via gRPC metadata header (flagd v0.11.0+ preferred approach)
+        metadata = self._create_metadata()
+        if metadata is not None:
+            call_args["metadata"] = metadata
+        return call_args

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

@@ -72,30 +72,22 @@ class Flag:
     key: str
     state: str
     variants: typing.Mapping[str, typing.Any]
-    default_variant: typing.Union[bool, str]
+    default_variant: typing.Optional[typing.Union[bool, str]] = None
     targeting: typing.Optional[dict] = None
     metadata: typing.Optional[
         typing.Mapping[str, typing.Union[float, int, str, bool]]
     ] = None
 
     def __post_init__(self) -> None:
-        if not self.state or not isinstance(self.state, str):
+        if not self.state or not (self.state == "ENABLED" or self.state == "DISABLED"):
             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)
-        ):
+        if self.default_variant and 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")
-
         if self.metadata:
             if not isinstance(self.metadata, dict):
                 raise ParseError("Flag metadata is not a valid json object")
@@ -106,6 +98,8 @@ class Flag:
     def from_dict(cls, key: str, data: dict) -> "Flag":
         if "defaultVariant" in data:
             data["default_variant"] = data["defaultVariant"]
+            if data["default_variant"] == "":
+                data["default_variant"] = None
             del data["defaultVariant"]
 
         data.pop("source", None)
@@ -119,13 +113,16 @@ class Flag:
             raise ParseError from err
 
     @property
-    def default(self) -> tuple[str, typing.Any]:
+    def default(self) -> tuple[typing.Optional[str], typing.Any]:
         return self.get_variant(self.default_variant)
 
     def get_variant(
-        self, variant_key: typing.Union[str, bool]
-    ) -> tuple[str, typing.Any]:
+        self, variant_key: typing.Union[str, bool, None]
+    ) -> tuple[typing.Optional[str], typing.Any]:
         if isinstance(variant_key, bool):
             variant_key = str(variant_key).lower()
 
+        if not variant_key:
+            return None, None
+
         return variant_key, self.variants.get(variant_key)

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import time
 import typing
 
@@ -5,6 +7,7 @@ from json_logic import builtins, jsonLogic
 from json_logic.types import JsonValue
 
 from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import ParseError
 
 from .custom_ops import (
     ends_with,
@@ -27,7 +30,12 @@ def targeting(
     targeting: dict,
     evaluation_context: typing.Optional[EvaluationContext] = None,
 ) -> JsonValue:
-    json_logic_context = evaluation_context.attributes if evaluation_context else {}
+    if not isinstance(targeting, dict):
+        raise ParseError(f"Invalid 'targeting' value in flag: {targeting}")
+
+    json_logic_context: dict[str, typing.Any] = (
+        dict(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

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

@@ -3,7 +3,7 @@ import typing
 from typing_extensions import Protocol
 
 from openfeature.evaluation_context import EvaluationContext
-from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType
 
 
 class AbstractResolver(Protocol):
@@ -42,6 +42,10 @@ class AbstractResolver(Protocol):
     def resolve_object_details(
         self,
         key: str,
-        default_value: typing.Union[dict, list],
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
         evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[typing.Union[dict, list]]: ...
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]: ...

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

@@ -0,0 +1,7 @@
+import typing
+
+
+class GrpcMultiCallableArgs(typing.TypedDict, total=False):
+    timeout: typing.Optional[float]
+    wait_for_ready: typing.Optional[bool]
+    metadata: typing.Optional[tuple[tuple[str, str]]]