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

openfeature/schemas/protobuf/sync/v1/sync_service_pb2.pyi

@@ -0,0 +1,174 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+*
+DEPRECATED; use flagd.sync.v1
+Flag definition sync API
+
+This proto defines a simple API to synchronize a feature flag definition.
+It supports establishing a stream for getting notifications about changes in a flag definition.
+"""
+
+import builtins
+import google.protobuf.descriptor
+import google.protobuf.internal.enum_type_wrapper
+import google.protobuf.message
+import sys
+import typing
+
+if sys.version_info >= (3, 10):
+    import typing as typing_extensions
+else:
+    import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+class _SyncState:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _SyncStateEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_SyncState.ValueType], builtins.type):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    SYNC_STATE_UNSPECIFIED: _SyncState.ValueType  # 0
+    """Value is ignored by the listening flagd"""
+    SYNC_STATE_ALL: _SyncState.ValueType  # 1
+    """All the flags matching the request. This is the default response and other states can be ignored
+    by the implementation. Flagd internally replaces all existing flags for this response state.
+    """
+    SYNC_STATE_ADD: _SyncState.ValueType  # 2
+    """Convey an addition of a flag. Flagd internally handles this by combining new flags with existing ones"""
+    SYNC_STATE_UPDATE: _SyncState.ValueType  # 3
+    """Convey an update of a flag. Flagd internally attempts to update if the updated flag already exist OR if it does not,
+    it will get added
+    """
+    SYNC_STATE_DELETE: _SyncState.ValueType  # 4
+    """Convey a deletion of a flag. Flagd internally removes the flag"""
+    SYNC_STATE_PING: _SyncState.ValueType  # 5
+    """Optional server ping to check client connectivity. Handling is ignored by flagd and is to merely support live check"""
+
+class SyncState(_SyncState, metaclass=_SyncStateEnumTypeWrapper):
+    """SyncState conveys the state of the payload. These states are related to flagd isync.go type definitions but
+    contains extras to optimize grpc use case. Refer - https://github.com/open-feature/flagd/blob/main/pkg/sync/isync.go
+    """
+
+SYNC_STATE_UNSPECIFIED: SyncState.ValueType  # 0
+"""Value is ignored by the listening flagd"""
+SYNC_STATE_ALL: SyncState.ValueType  # 1
+"""All the flags matching the request. This is the default response and other states can be ignored
+by the implementation. Flagd internally replaces all existing flags for this response state.
+"""
+SYNC_STATE_ADD: SyncState.ValueType  # 2
+"""Convey an addition of a flag. Flagd internally handles this by combining new flags with existing ones"""
+SYNC_STATE_UPDATE: SyncState.ValueType  # 3
+"""Convey an update of a flag. Flagd internally attempts to update if the updated flag already exist OR if it does not,
+it will get added
+"""
+SYNC_STATE_DELETE: SyncState.ValueType  # 4
+"""Convey a deletion of a flag. Flagd internally removes the flag"""
+SYNC_STATE_PING: SyncState.ValueType  # 5
+"""Optional server ping to check client connectivity. Handling is ignored by flagd and is to merely support live check"""
+global___SyncState = SyncState
+
+@typing.final
+class SyncFlagsRequest(google.protobuf.message.Message):
+    """SyncFlagsRequest is the request initiating the sever-streaming rpc. Flagd sends this request, acting as the client"""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    PROVIDER_ID_FIELD_NUMBER: builtins.int
+    SELECTOR_FIELD_NUMBER: builtins.int
+    provider_id: builtins.str
+    """Optional: A unique identifier for flagd(grpc client) initiating the request. The server implementations may
+    utilize this identifier to uniquely identify, validate(ex:- enforce authentication/authorization) and filter
+    flag configurations that it can expose to this request. This field is intended to be optional. However server
+    implementations may enforce it.
+       ex:- provider_id: flagd-weatherapp-sidecar
+    """
+    selector: builtins.str
+    """Optional: A selector for the flag configuration request. The server implementation may utilize this to select
+    flag configurations from a collection, select the source of the flag or combine this to any desired underlying
+    filtering mechanism.
+       ex:- selector: 'source=database,app=weatherapp'
+    """
+    def __init__(
+        self,
+        *,
+        provider_id: builtins.str = ...,
+        selector: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["provider_id", b"provider_id", "selector", b"selector"]) -> None: ...
+
+global___SyncFlagsRequest = SyncFlagsRequest
+
+@typing.final
+class SyncFlagsResponse(google.protobuf.message.Message):
+    """SyncFlagsResponse is the server response containing feature flag configurations and the state"""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    FLAG_CONFIGURATION_FIELD_NUMBER: builtins.int
+    STATE_FIELD_NUMBER: builtins.int
+    flag_configuration: builtins.str
+    """flagd feature flag configuration. Must be validated to schema - https://raw.githubusercontent.com/open-feature/schemas/main/json/flagd-definitions.json"""
+    state: global___SyncState.ValueType
+    """State conveying the operation to be performed by flagd. See the descriptions of SyncState for an explanation of
+    supported values
+    """
+    def __init__(
+        self,
+        *,
+        flag_configuration: builtins.str = ...,
+        state: global___SyncState.ValueType = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["flag_configuration", b"flag_configuration", "state", b"state"]) -> None: ...
+
+global___SyncFlagsResponse = SyncFlagsResponse
+
+@typing.final
+class FetchAllFlagsRequest(google.protobuf.message.Message):
+    """FetchAllFlagsRequest is the request to fetch all flags. Flagd sends this request as the client in order to resync its internal state"""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    PROVIDER_ID_FIELD_NUMBER: builtins.int
+    SELECTOR_FIELD_NUMBER: builtins.int
+    provider_id: builtins.str
+    """Optional: A unique identifier for flagd(grpc client) initiating the request. The server implementations may
+    utilize this identifier to uniquely identify, validate(ex:- enforce authentication/authorization) and filter
+    flag configurations that it can expose to this request. This field is intended to be optional. However server
+    implementations may enforce it.
+       ex:- provider_id: flagd-weatherapp-sidecar
+    """
+    selector: builtins.str
+    """Optional: A selector for the flag configuration request. The server implementation may utilize this to select
+    flag configurations from a collection, select the source of the flag or combine this to any desired underlying
+    filtering mechanism.
+       ex:- selector: 'source=database,app=weatherapp'
+    """
+    def __init__(
+        self,
+        *,
+        provider_id: builtins.str = ...,
+        selector: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["provider_id", b"provider_id", "selector", b"selector"]) -> None: ...
+
+global___FetchAllFlagsRequest = FetchAllFlagsRequest
+
+@typing.final
+class FetchAllFlagsResponse(google.protobuf.message.Message):
+    """ FetchAllFlagsResponse is the server response containing feature flag configurations"""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    FLAG_CONFIGURATION_FIELD_NUMBER: builtins.int
+    flag_configuration: builtins.str
+    """flagd feature flag configuration. Must be validated to schema - https://raw.githubusercontent.com/open-feature/schemas/main/json/flagd-definitions.json"""
+    def __init__(
+        self,
+        *,
+        flag_configuration: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["flag_configuration", b"flag_configuration"]) -> None: ...
+
+global___FetchAllFlagsResponse = FetchAllFlagsResponse

openfeature/schemas/protobuf/sync/v1/sync_service_pb2_grpc.py

@@ -0,0 +1,143 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from openfeature.schemas.protobuf.sync.v1 import sync_service_pb2 as openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2
+
+GRPC_GENERATED_VERSION = '1.70.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in openfeature/schemas/protobuf/sync/v1/sync_service_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class FlagSyncServiceStub(object):
+    """FlagService implements a server streaming to provide realtime flag configurations
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.SyncFlags = channel.unary_stream(
+                '/sync.v1.FlagSyncService/SyncFlags',
+                request_serializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.SyncFlagsRequest.SerializeToString,
+                response_deserializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.SyncFlagsResponse.FromString,
+                _registered_method=True)
+        self.FetchAllFlags = channel.unary_unary(
+                '/sync.v1.FlagSyncService/FetchAllFlags',
+                request_serializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.FetchAllFlagsRequest.SerializeToString,
+                response_deserializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.FetchAllFlagsResponse.FromString,
+                _registered_method=True)
+
+
+class FlagSyncServiceServicer(object):
+    """FlagService implements a server streaming to provide realtime flag configurations
+    """
+
+    def SyncFlags(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def FetchAllFlags(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_FlagSyncServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'SyncFlags': grpc.unary_stream_rpc_method_handler(
+                    servicer.SyncFlags,
+                    request_deserializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.SyncFlagsRequest.FromString,
+                    response_serializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.SyncFlagsResponse.SerializeToString,
+            ),
+            'FetchAllFlags': grpc.unary_unary_rpc_method_handler(
+                    servicer.FetchAllFlags,
+                    request_deserializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.FetchAllFlagsRequest.FromString,
+                    response_serializer=openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.FetchAllFlagsResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'sync.v1.FlagSyncService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('sync.v1.FlagSyncService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class FlagSyncService(object):
+    """FlagService implements a server streaming to provide realtime flag configurations
+    """
+
+    @staticmethod
+    def SyncFlags(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/sync.v1.FlagSyncService/SyncFlags',
+            openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.SyncFlagsRequest.SerializeToString,
+            openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.SyncFlagsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def FetchAllFlags(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/sync.v1.FlagSyncService/FetchAllFlags',
+            openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.FetchAllFlagsRequest.SerializeToString,
+            openfeature_dot_schemas_dot_protobuf_dot_sync_dot_v1_dot_sync__service__pb2.FetchAllFlagsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

openfeature/schemas/protobuf/sync/v1/sync_service_pb2_grpc.pyi

@@ -0,0 +1,70 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+*
+DEPRECATED; use flagd.sync.v1
+Flag definition sync API
+
+This proto defines a simple API to synchronize a feature flag definition.
+It supports establishing a stream for getting notifications about changes in a flag definition.
+"""
+
+import abc
+import collections.abc
+import grpc
+import grpc.aio
+import openfeature.schemas.protobuf.sync.v1.sync_service_pb2
+import typing
+
+_T = typing.TypeVar("_T")
+
+class _MaybeAsyncIterator(collections.abc.AsyncIterator[_T], collections.abc.Iterator[_T], metaclass=abc.ABCMeta): ...
+
+class _ServicerContext(grpc.ServicerContext, grpc.aio.ServicerContext):  # type: ignore[misc, type-arg]
+    ...
+
+class FlagSyncServiceStub:
+    """FlagService implements a server streaming to provide realtime flag configurations"""
+
+    def __init__(self, channel: typing.Union[grpc.Channel, grpc.aio.Channel]) -> None: ...
+    SyncFlags: grpc.UnaryStreamMultiCallable[
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.SyncFlagsRequest,
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.SyncFlagsResponse,
+    ]
+
+    FetchAllFlags: grpc.UnaryUnaryMultiCallable[
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.FetchAllFlagsRequest,
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.FetchAllFlagsResponse,
+    ]
+
+class FlagSyncServiceAsyncStub:
+    """FlagService implements a server streaming to provide realtime flag configurations"""
+
+    SyncFlags: grpc.aio.UnaryStreamMultiCallable[
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.SyncFlagsRequest,
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.SyncFlagsResponse,
+    ]
+
+    FetchAllFlags: grpc.aio.UnaryUnaryMultiCallable[
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.FetchAllFlagsRequest,
+        openfeature.schemas.protobuf.sync.v1.sync_service_pb2.FetchAllFlagsResponse,
+    ]
+
+class FlagSyncServiceServicer(metaclass=abc.ABCMeta):
+    """FlagService implements a server streaming to provide realtime flag configurations"""
+
+    @abc.abstractmethod
+    def SyncFlags(
+        self,
+        request: openfeature.schemas.protobuf.sync.v1.sync_service_pb2.SyncFlagsRequest,
+        context: _ServicerContext,
+    ) -> typing.Union[collections.abc.Iterator[openfeature.schemas.protobuf.sync.v1.sync_service_pb2.SyncFlagsResponse], collections.abc.AsyncIterator[openfeature.schemas.protobuf.sync.v1.sync_service_pb2.SyncFlagsResponse]]: ...
+
+    @abc.abstractmethod
+    def FetchAllFlags(
+        self,
+        request: openfeature.schemas.protobuf.sync.v1.sync_service_pb2.FetchAllFlagsRequest,
+        context: _ServicerContext,
+    ) -> typing.Union[openfeature.schemas.protobuf.sync.v1.sync_service_pb2.FetchAllFlagsResponse, collections.abc.Awaitable[openfeature.schemas.protobuf.sync.v1.sync_service_pb2.FetchAllFlagsResponse]]: ...
+
+def add_FlagSyncServiceServicer_to_server(servicer: FlagSyncServiceServicer, server: typing.Union[grpc.Server, grpc.aio.Server]) -> None: ...

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: openfeature-provider-flagd
-Version: 0.1.5
+Version: 0.2.0
 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>
@@ -192,7 +192,7 @@ License:                                  Apache License
               same "printed page" as the copyright notice for easier
               identification within third-party archives.
         
-           Copyright The OpenTelemetry Authors
+           Copyright [yyyy] [name of copyright owner]
         
            Licensed under the Apache License, Version 2.0 (the "License");
            you may not use this file except in compliance with the License.
@@ -209,19 +209,20 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Requires-Dist: grpcio>=1.60.0
+Requires-Python: >=3.9
+Requires-Dist: cachebox
+Requires-Dist: grpcio>=1.68.1
 Requires-Dist: mmh3>=4.1.0
-Requires-Dist: openfeature-sdk>=0.4.0
+Requires-Dist: openfeature-sdk>=0.6.0
 Requires-Dist: panzi-json-logic>=1.0.1
-Requires-Dist: protobuf>=4.25.2
+Requires-Dist: protobuf>=4.29.2
 Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: semver<4,>=3
 Description-Content-Type: text/markdown
 
 # flagd Provider for OpenFeature
 
-This provider is designed to use flagd's [evaluation protocol](https://github.com/open-feature/schemas/blob/main/protobuf/schema/v1/schema.proto).
+This provider is designed to use flagd's [evaluation protocol](https://github.com/open-feature/schemas/blob/main/protobuf/schema/v1/schema.proto), or locally evaluate flags defined in a flagd [flag definition](https://github.com/open-feature/schemas/blob/main/json/flagd-definitions.json) via the OpenFeature Python SDK.
 
 ## Installation
 
@@ -231,6 +232,14 @@ pip install openfeature-provider-flagd
 
 ## Configuration and Usage
 
+The flagd provider can operate in two modes: [RPC](#remote-resolver-rpc) (evaluation takes place in flagd, via gRPC calls) or [in-process](#in-process-resolver) (evaluation takes place in-process, with the provider getting a ruleset from a compliant sync-source).
+
+### Remote resolver (RPC)
+
+This is the default mode of operation of the provider.
+In this mode, `FlagdProvider` communicates with [flagd](https://github.com/open-feature/flagd) via the gRPC protocol.
+Flag evaluations take place remotely at the connected flagd instance.
+
 Instantiate a new FlagdProvider instance and configure the OpenFeature SDK to use it:
 
 ```python
@@ -240,7 +249,11 @@ from openfeature.contrib.provider.flagd import FlagdProvider
 api.set_provider(FlagdProvider())
 ```
 
-To use in-process evaluation in offline mode with a file as source:
+### In-process resolver
+
+This mode performs flag evaluations locally (in-process). Flag configurations for evaluation are obtained via gRPC protocol using [sync protobuf schema](https://buf.build/open-feature/flagd/file/main:sync/v1/sync_service.proto) service definition.
+
+Consider the following example to create a `FlagdProvider` with in-process evaluations,
 
 ```python
 from openfeature import api
@@ -249,20 +262,108 @@ from openfeature.contrib.provider.flagd.config import ResolverType
 
 api.set_provider(FlagdProvider(
     resolver_type=ResolverType.IN_PROCESS,
+))
+```
+
+In the above example, in-process handlers attempt to connect to a sync service on address `localhost:8013` to obtain [flag definitions](https://github.com/open-feature/schemas/blob/main/json/flags.json).
+
+<!--
+#### Sync-metadata
+
+To support the injection of contextual data configured in flagd for in-process evaluation, the provider exposes a `getSyncMetadata` accessor which provides the most recent value returned by the [GetMetadata RPC](https://buf.build/open-feature/flagd/docs/main:flagd.sync.v1#flagd.sync.v1.FlagSyncService.GetMetadata).
+The value is updated with every (re)connection to the sync implementation.
+This can be used to enrich evaluations with such data.
+If the `in-process` mode is not used, and before the provider is ready, the `getSyncMetadata` returns an empty map.
+-->
+### File mode
+
+In-process resolvers can also work in an offline mode.
+To enable this mode, you should provide a valid flag configuration file with the option `offlineFlagSourcePath`.
+
+```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.FILE,
     offline_flag_source_path="my-flag.json",
 ))
 ```
 
+Provider will attempt to detect file changes using polling.
+Polling happens at 5 second intervals and this is currently unconfigurable.
+This mode is useful for local development, tests and offline applications.
+
 ### Configuration options
 
 The default options can be defined in the FlagdProvider constructor.
 
-| Option name    | Type & Values | Default   |
-|----------------|---------------|-----------|
-| host           | str           | localhost |
-| port           | int           | 8013      |
-| schema         | str           | http      |
-| timeout        | int           | 2         |
+| Option name              | Environment variable name      | Type & Values              | Default                       | Compatible resolver |
+|--------------------------|--------------------------------|----------------------------|-------------------------------|---------------------|
+| resolver_type            | FLAGD_RESOLVER                 | enum - `rpc`, `in-process` | rpc                           |                     |
+| host                     | FLAGD_HOST                     | str                        | localhost                     | rpc & in-process    |
+| port                     | FLAGD_PORT                     | int                        | 8013 (rpc), 8015 (in-process) | rpc & in-process    |
+| tls                      | FLAGD_TLS                      | bool                       | false                         | rpc & in-process    |
+| cert_path                | FLAGD_SERVER_CERT_PATH         | String                     | null                          | rpc & in-process    |
+| deadline                 | FLAGD_DEADLINE_MS              | int                        | 500                           | rpc & in-process    |
+| stream_deadline_ms       | FLAGD_STREAM_DEADLINE_MS       | int                        | 600000                        | rpc & in-process    |
+| keep_alive_time          | FLAGD_KEEP_ALIVE_TIME_MS       | int                        | 0                             | rpc & in-process    |
+| selector                 | FLAGD_SOURCE_SELECTOR          | str                        | null                          | in-process          |
+| cache_type               | FLAGD_CACHE                    | enum - `lru`, `disabled`   | lru                           | rpc                 |
+| max_cache_size           | FLAGD_MAX_CACHE_SIZE           | int                        | 1000                          | rpc                 |
+| retry_backoff_ms         | FLAGD_RETRY_BACKOFF_MS         | int                        | 1000                          | rpc                 |
+| offline_flag_source_path | FLAGD_OFFLINE_FLAG_SOURCE_PATH | str                        | null                          | in-process          |
+
+<!-- not implemented
+| target_uri               | FLAGD_TARGET_URI               | alternative to host/port, supporting custom name resolution | string    | null                | rpc & in-process |
+| socket_path              | FLAGD_SOCKET_PATH              | alternative to host port, unix socket                       | String    | null                | rpc & in-process |
+| context_enricher         | -                              | sync-metadata to evaluation context mapping function        | function  | identity function   | in-process       |
+| offline_pollIntervalMs   | FLAGD_OFFLINE_POLL_MS          | poll interval for reading offlineFlagSourcePath             | int       | 5000                | in-process       |
+ -->
+
+> [!NOTE]
+> Some configurations are only applicable for RPC resolver.
+
+<!--
+### Unix socket support
+Unix socket communication with flagd is facilitated by usaging of the linux-native `epoll` library on `linux-x86_64`
+only (ARM support is pending the release of `netty-transport-native-epoll` v5).
+Unix sockets are not supported on other platforms or architectures.
+-->
+
+### Reconnection
+
+Reconnection is supported by the underlying gRPC connections.
+If the connection to flagd is lost, it will reconnect automatically.
+A failure to connect will result in an [error event](https://openfeature.dev/docs/reference/concepts/events#provider_error) from the provider, though it will attempt to reconnect indefinitely.
+
+### Deadlines
+
+Deadlines are used to define how long the provider waits to complete initialization or flag evaluations.
+They behave differently based on the resolver type.
+
+#### Deadlines with Remote resolver (RPC)
+
+If the remote evaluation call is not completed within this deadline, the gRPC call is terminated with the error `DEADLINE_EXCEEDED`
+and the evaluation will default.
+
+### TLS
+
+TLS is available in situations where flagd is running on another host.
+
+
+You may optionally supply an X.509 certificate in PEM format. Otherwise, the default certificate store will be used.
+
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+
+api.set_provider(FlagdProvider(
+    tls=True,                        # use TLS
+    cert_path="etc/cert/ca.crt"      # PEM cert
+))
+```
 
 ## License
 

openfeature_provider_flagd-0.2.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+openfeature/.gitignore,sha256=1ZPH4VtVL4bMQmBJXQJxeAyUa74LCtqV1a_yjeDIzSQ,8
+openfeature/contrib/provider/flagd/__init__.py,sha256=WlrcPaCH31dEG1IvrvpeuhAaQ8Ni8LEzDpNM_x-qKOA,65
+openfeature/contrib/provider/flagd/config.py,sha256=ObWUUMVaRf199AWjfg4xrTOR7qcx5venyTNPUJkSTmA,7024
+openfeature/contrib/provider/flagd/flag_type.py,sha256=rZYfmqQEmtqVVTb8e-d8Wt8ZCnHtf7xPSmYxyU8w0R0,158
+openfeature/contrib/provider/flagd/provider.py,sha256=n0sRslXEOhFkXZnFXQguC5HkC18ekTFLKEmj7WSTJ50,6795
+openfeature/contrib/provider/flagd/resolvers/__init__.py,sha256=CzsnsfxJCaD_S1gBf15kkJBVD-gVLKIwDi4W1nE-dXw,181
+openfeature/contrib/provider/flagd/resolvers/grpc.py,sha256=lVwznNS8WU41xIBjazxhhpJKfCLTEgnon4CHDh0DY-g,13470
+openfeature/contrib/provider/flagd/resolvers/in_process.py,sha256=fUE6Q1dzwE4V7KYYpdp2_qKj7vrkL47fG906kyxubr8,4618
+openfeature/contrib/provider/flagd/resolvers/protocol.py,sha256=Wc7oUH6ytPuKg8Lj_3y-_LLkQkuvsow9IiSfmlM8I2o,1402
+openfeature/contrib/provider/flagd/resolvers/process/custom_ops.py,sha256=bZX1At0dRxhghhWz4g-8N-YPobcVfYSv9PTsYh-lZDc,4549
+openfeature/contrib/provider/flagd/resolvers/process/flags.py,sha256=nDXkl80DiJBlSrz0l7xT-DAr6zzZSS0mwOSjvUAV2gY,3255
+openfeature/contrib/provider/flagd/resolvers/process/targeting.py,sha256=qjYgfoJK9B1ghh19cUq7f-VEql7Hh1J7sh0BhnNc_h0,905
+openfeature/contrib/provider/flagd/resolvers/process/connector/__init__.py,sha256=hyYYxRYEnSho5F28M2hbhhtkG4DQTwJjD36ddI0Xs7M,289
+openfeature/contrib/provider/flagd/resolvers/process/connector/file_watcher.py,sha256=m_hscNJ0tHQgY5xuOriK20SiYKjz5FpLPoDfNJDDXKs,3889
+openfeature/contrib/provider/flagd/resolvers/process/connector/grpc_watcher.py,sha256=ZTHLpMZSIMl7doK75-rZF64XfxGCNmocr4Vf8UhLHTY,7276
+openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation_pb2.py,sha256=YPBimdlVBCfnVqxq9uek3H4nyaIR0MhggCAaR0XtIt4,7527
+openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation_pb2.pyi,sha256=afh-fdsmyfS62C-iq7EQsqr_5yZP_QxJXp81Q0Lcllk,18333
+openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation_pb2_grpc.py,sha256=AFwLCOCunFSWGnlt8Asj3pxORfcx168r4jVmt9CLB0I,17189
+openfeature/schemas/protobuf/flagd/evaluation/v1/evaluation_pb2_grpc.pyi,sha256=tQm-QOlsMdhdN_7i5LsrtLtBPu4qpL0qzTE7DbSvXFs,7731
+openfeature/schemas/protobuf/flagd/sync/v1/sync_pb2.py,sha256=OIhVrNkhXtwuCdvbahXiOx-mQ3XVVPx5gh0UHzKN0_M,3528
+openfeature/schemas/protobuf/flagd/sync/v1/sync_pb2.pyi,sha256=Qsqe0vz5AJRAAjARXhjiaPKyIFbLttr4gTWae2zyJfM,5967
+openfeature/schemas/protobuf/flagd/sync/v1/sync_pb2_grpc.py,sha256=7sU7da4Sd8_Jg_TXuGLvNKmgzV98dBcMFKLb_EWQ0jU,8335
+openfeature/schemas/protobuf/flagd/sync/v1/sync_pb2_grpc.pyi,sha256=APjDd-Yo6i6FE_kOusWhTqk-8B_0wIEMXcImCuGpQt8,3782
+openfeature/schemas/protobuf/schema/v1/schema_pb2.py,sha256=dfGpiAYJ2VuRBrctH7s21KkdrIr9rzIaWibUZ3So3g4,7255
+openfeature/schemas/protobuf/schema/v1/schema_pb2.pyi,sha256=14Z6i0kRpCAQO8aCpc4Qwre1OJ7_d_ZIPq8V1vTuYzU,18369
+openfeature/schemas/protobuf/schema/v1/schema_pb2_grpc.py,sha256=4I0h1IXFzqAFX15J-h7yC7PQAu1CEcWEVwK4bhKLsog,16227
+openfeature/schemas/protobuf/schema/v1/schema_pb2_grpc.pyi,sha256=EJ55jvso2Uzx50XryC7fsKGEOBi1bMOGCXaShl1TcJ4,7067
+openfeature/schemas/protobuf/sync/v1/sync_service_pb2.py,sha256=Sw0kLvO0wIRXsaFic8qmTuScMdf1-1WOHGWP4FOIB_s,3327
+openfeature/schemas/protobuf/sync/v1/sync_service_pb2.pyi,sha256=o3YpW_5iQJWjU7IFEsyspeqLyBDC4C_psBNErwziumE,7986
+openfeature/schemas/protobuf/sync/v1/sync_service_pb2_grpc.py,sha256=cAbP4qfaS2Dpze8BH3w-PAJfL7LCA7xZYJfFro5b_2I,6185
+openfeature/schemas/protobuf/sync/v1/sync_service_pb2_grpc.pyi,sha256=4NoAkGicVNxx4yVK5_JvvPn1OGlRdPhqM2wCpkwCjEI,3024
+openfeature_provider_flagd-0.2.0.dist-info/METADATA,sha256=aWH2j09cJBu_IzuRgwufwnMUs9DA0jBhncib01UIOHg,21635
+openfeature_provider_flagd-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+openfeature_provider_flagd-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openfeature_provider_flagd-0.2.0.dist-info/RECORD,,

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

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

{openfeature_provider_flagd-0.1.5.dist-info → openfeature_provider_flagd-0.2.0.dist-info}/licenses/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright The OpenTelemetry Authors
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.