fixup: changing to mypy-protobuf

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

.github/workflows/build.yml

@@ -38,16 +38,15 @@ jobs:
           python-version: ${{ matrix.python-version }}
           cache: "pip"
 
-      - uses: bufbuild/buf-action@v1
-        with:
-          github_token: ${{ github.token }}
-          setup_only: true
-
       - name: Install hatch
         run: pip install hatch
 
+      - name: Building first to generate files
+        run: hatch build
+        working-directory: ${{ matrix.package }}
+
       - name: Test with pytest
-        run: hatch run cov
+        run: hatch test -c
         working-directory: ${{ matrix.package }}
 
       - if: matrix.python-version == '3.11'

.gitmodules

@@ -1,9 +1,9 @@
 [submodule "schemas"]
-	path = providers/openfeature-provider-flagd/schemas
+	path = providers/openfeature-provider-flagd/openfeature/schemas
 	url = https://github.com/open-feature/schemas
 [submodule "providers/openfeature-provider-flagd/test-harness"]
-	path = providers/openfeature-provider-flagd/test-harness
+	path = providers/openfeature-provider-flagd/openfeature/test-harness
 	url = [email protected]:open-feature/flagd-testbed.git
 [submodule "providers/openfeature-provider-flagd/spec"]
-	path = providers/openfeature-provider-flagd/spec
+	path = providers/openfeature-provider-flagd/openfeature/spec
 	url = https://github.com/open-feature/spec

CONTRIBUTING.md

@@ -18,9 +18,13 @@ To install Hatch, just run `pip install hatch`.
 
 You will also need to setup the `pre-commit` hooks. Run `pre-commit install` in the root directory of the repository. If you don't have `pre-commit` installed, you can install it with `pip install pre-commit`.
 
+> **Note**
+> Currently our protobuf files will be generated during `hatch build`
+> Please run this command once, to generate all necessary files.
+
 ### Testing
 
-Run tests by entering the package directory and running `hatch run test`.
+Run tests by entering the package directory and running `hatch test`.
 
 We use `pytest` for our unit testing, making use of `parametrized` to inject cases at scale.
 

providers/openfeature-provider-flagd/README.md

@@ -10,6 +10,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
@@ -19,7 +27,9 @@ 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).
 
 ```python
 from openfeature import api
@@ -36,12 +46,72 @@ api.set_provider(FlagdProvider(
 
 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    |
+| 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 |
+| cert_path                | FLAGD_SERVER_CERT_PATH         | tls cert path                                               | String    | null                | rpc & in-process |
+| max_event_stream_retries | FLAGD_MAX_EVENT_STREAM_RETRIES | int                                                         | 5         | rpc                 |
+| 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.
+```java
+FlagdProvider flagdProvider = new FlagdProvider(
+        FlagdOptions.builder()
+                .host("myflagdhost")
+                .tls(true)                      // use TLS
+                .certPath("etc/cert/ca.crt")    // PEM cert
+                .build());
+```
+-->
 
 ## License
 

providers/openfeature-provider-flagd/schemas renamed to providers/openfeature-provider-flagd/openfeature/schemas

@@ -18,7 +18,7 @@ classifiers = [
 keywords = []
 dependencies = [
   "openfeature-sdk>=0.4.0",
-  "grpcio>=1.60.0",
+  "grpcio>=1.68.0",
   "protobuf>=4.25.2",
   "mmh3>=4.1.0",
   "panzi-json-logic>=1.0.1",
@@ -32,7 +32,7 @@ Homepage = "https://github.com/open-feature/python-sdk-contrib"
 
 [tool.hatch]
 
-[tool.hatch.envs.default]
+[tool.hatch.envs.hatch-test]
 dependencies = [
   "coverage[toml]>=6.5",
   "pytest",
@@ -41,28 +41,47 @@ dependencies = [
   "asserts",
   "grpcio-health-checking==1.60.0",
 ]
+pre-install-commands = [
+  "hatch build",
+]
 
-[tool.hatch.envs.default.scripts]
-test = "pytest {args:tests}"
-test-cov = "coverage run -m pytest {args:tests}"
+[tool.hatch.envs.hatch-test.scripts]
+run = "pytest {args:tests}"
+run-cov = "coverage run -m pytest {args:tests}"
+cov-combine = "coverage combine"
 cov-report = [
   "coverage xml",
   "coverage html",
+  "coverage report",
 ]
 cov = [
   "test-cov",
   "cov-report",
 ]
 
 [tool.hatch.build.hooks.protobuf]
-dependencies = ["hatch-protobuf"]
-paths = ["schemas/protobuf/schema/v1/schema.proto", "schemas/protobuf/sync/v1/sync_service.proto"]
-output_path = "src"
+generate_pyi = false
+dependencies = [
+    "hatch-protobuf",
+    "mypy-protobuf~=3.0",
+]
+proto_paths = [
+  ".",
+]
+output_path = "src/"
+
+[[tool.hatch.build.hooks.protobuf.generators]]
+name = "mypy"
+outputs = ["{proto_path}/{proto_name}_pb2.pyi"]
+
+[[tool.hatch.build.hooks.protobuf.generators]]
+name = "mypy_grpc"
+outputs = ["{proto_path}/{proto_name}_pb2_grpc.pyi"]
 
 [tool.hatch.build.targets.sdist]
 exclude = [
   ".gitignore",
-  "schemas",
+  "/openfeature",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -71,6 +90,6 @@ packages = ["src/openfeature"]
 [tool.coverage.run]
 omit = [
   # exclude generated files
-  "src/openfeature/contrib/provider/flagd/proto/*",
+  "src/openfeature/schemas/*",
   "tests/**",
 ]

providers/openfeature-provider-flagd/spec renamed to providers/openfeature-provider-flagd/openfeature/spec

@@ -0,0 +1,2 @@
+
+schemas

providers/openfeature-provider-flagd/test-harness renamed to providers/openfeature-provider-flagd/openfeature/test-harness

@@ -2,6 +2,33 @@
 import typing
 from enum import Enum
 
+
+class ResolverType(Enum):
+    RPC = "rpc"
+    IN_PROCESS = "in-process"
+
+
+DEFAULT_DEADLINE = 500
+DEFAULT_HOST = "localhost"
+DEFAULT_KEEP_ALIVE = 0
+DEFAULT_OFFLINE_SOURCE_PATH: typing.Optional[str] = None
+DEFAULT_PORT_IN_PROCESS = 8015
+DEFAULT_PORT_RPC = 8013
+DEFAULT_RESOLVER_TYPE = ResolverType.RPC
+DEFAULT_RETRY_BACKOFF = 1000
+DEFAULT_STREAM_DEADLINE = 600000
+DEFAULT_TLS = False
+
+ENV_VAR_DEADLINE_MS = "FLAGD_DEADLINE_MS"
+ENV_VAR_HOST = "FLAGD_HOST"
+ENV_VAR_KEEP_ALIVE_TIME_MS = "FLAGD_KEEP_ALIVE_TIME_MS"
+ENV_VAR_OFFLINE_FLAG_SOURCE_PATH = "FLAGD_OFFLINE_FLAG_SOURCE_PATH"
+ENV_VAR_PORT = "FLAGD_PORT"
+ENV_VAR_RESOLVER_TYPE = "FLAGD_RESOLVER_TYPE"
+ENV_VAR_RETRY_BACKOFF_MS = "FLAGD_RETRY_BACKOFF_MS"
+ENV_VAR_STREAM_DEADLINE_MS = "FLAGD_STREAM_DEADLINE_MS"
+ENV_VAR_TLS = "FLAGD_TLS"
+
 T = typing.TypeVar("T")
 
 
@@ -18,42 +45,79 @@ def env_or_default(
     return val if cast is None else cast(val)
 
 
-class ResolverType(Enum):
-    GRPC = "grpc"
-    IN_PROCESS = "in-process"
-
-
 class Config:
     def __init__(  # noqa: PLR0913
         self,
         host: typing.Optional[str] = None,
         port: typing.Optional[int] = None,
         tls: typing.Optional[bool] = None,
-        timeout: typing.Optional[int] = None,
         resolver_type: typing.Optional[ResolverType] = None,
         offline_flag_source_path: typing.Optional[str] = None,
-        offline_poll_interval_seconds: typing.Optional[float] = None,
+        retry_backoff_ms: typing.Optional[int] = None,
+        deadline: typing.Optional[int] = None,
+        stream_deadline_ms: typing.Optional[int] = None,
+        keep_alive_time: typing.Optional[int] = None,
     ):
-        self.host = env_or_default("FLAGD_HOST", "localhost") if host is None else host
-        self.port = (
-            env_or_default("FLAGD_PORT", 8013, cast=int) if port is None else port
-        )
+        self.host = env_or_default(ENV_VAR_HOST, DEFAULT_HOST) if host is None else host
         self.tls = (
-            env_or_default("FLAGD_TLS", False, cast=str_to_bool) if tls is None else tls
+            env_or_default(ENV_VAR_TLS, DEFAULT_TLS, cast=str_to_bool)
+            if tls is None
+            else tls
+        )
+        self.retry_backoff_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_RETRY_BACKOFF_MS, DEFAULT_RETRY_BACKOFF, cast=int
+                )
+            )
+            if retry_backoff_ms is None
+            else retry_backoff_ms
         )
-        self.timeout = 5 if timeout is None else timeout
+
         self.resolver_type = (
-            ResolverType(env_or_default("FLAGD_RESOLVER_TYPE", "grpc"))
+            ResolverType(env_or_default(ENV_VAR_RESOLVER_TYPE, DEFAULT_RESOLVER_TYPE))
             if resolver_type is None
             else resolver_type
         )
+
+        default_port = (
+            DEFAULT_PORT_RPC
+            if self.resolver_type is ResolverType.RPC
+            else DEFAULT_PORT_IN_PROCESS
+        )
+        self.port: int = (
+            int(env_or_default(ENV_VAR_PORT, default_port, cast=int))
+            if port is None
+            else port
+        )
         self.offline_flag_source_path = (
-            env_or_default("FLAGD_OFFLINE_FLAG_SOURCE_PATH", None)
+            env_or_default(
+                ENV_VAR_OFFLINE_FLAG_SOURCE_PATH, DEFAULT_OFFLINE_SOURCE_PATH
+            )
             if offline_flag_source_path is None
             else offline_flag_source_path
         )
-        self.offline_poll_interval_seconds = (
-            float(env_or_default("FLAGD_OFFLINE_POLL_INTERVAL_SECONDS", 1.0))
-            if offline_poll_interval_seconds is None
-            else offline_poll_interval_seconds
+
+        self.deadline: int = (
+            int(env_or_default(ENV_VAR_DEADLINE_MS, DEFAULT_DEADLINE, cast=int))
+            if deadline is None
+            else deadline
+        )
+
+        self.stream_deadline_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_STREAM_DEADLINE_MS, DEFAULT_STREAM_DEADLINE, cast=int
+                )
+            )
+            if stream_deadline_ms is None
+            else stream_deadline_ms
+        )
+
+        self.keep_alive_time: int = (
+            int(
+                env_or_default(ENV_VAR_KEEP_ALIVE_TIME_MS, DEFAULT_KEEP_ALIVE, cast=int)
+            )
+            if keep_alive_time is None
+            else keep_alive_time
         )