Merge branch 'main' into feat/gherkin_and_testcontainers

Author: aepfli

.github/workflows/build.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
         package:
           - "hooks/openfeature-hooks-opentelemetry"
           - "providers/openfeature-provider-flagd"
@@ -38,9 +38,10 @@ jobs:
           python-version: ${{ matrix.python-version }}
           cache: "pip"
 
-      - uses: bufbuild/buf-setup-action@v1.28.1
+      - uses: bufbuild/buf-action@v1
         with:
           github_token: ${{ github.token }}
+          setup_only: true
 
       - name: Install hatch
         run: pip install hatch
@@ -49,8 +50,9 @@ jobs:
         run: hatch run cov
         working-directory: ${{ matrix.package }}
 
-      - name: Upload coverage to Codecov
-        uses: codecov/[email protected]
+      - if: matrix.python-version == '3.11'
+        name: Upload coverage to Codecov
+        uses: codecov/[email protected]
         with:
           name: Code Coverage for ${{ matrix.package }} on Python ${{ matrix.python-version }}
           directory: ${{ matrix.package }}
@@ -69,7 +71,7 @@ jobs:
           cache: "pip"
 
       - name: Run pre-commit
-        uses: pre-commit/[email protected].0
+        uses: pre-commit/[email protected].1
 
   sast:
     runs-on: ubuntu-latest

.pre-commit-config.yaml

@@ -1,22 +1,22 @@
 default_stages: [commit]
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.3.3
+    rev: v0.6.3
     hooks:
       - id: ruff
         args: [--fix]
       - id: ruff-format
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v4.6.0
     hooks:
       - id: check-toml
       - id: check-yaml
       - id: trailing-whitespace
       - id: check-merge-conflict
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.9.0
+    rev: v1.11.2
     hooks:
       - id: mypy
         args: [--python-version=3.8]
@@ -25,6 +25,7 @@ repos:
           - opentelemetry-api
           - types-protobuf
           - types-PyYAML
+          - types-requests
           - mmh3
           - semver
           - panzi-json-logic

.release-please-manifest.json

@@ -1,4 +1,5 @@
 {
   "hooks/openfeature-hooks-opentelemetry": "0.1.3",
-  "providers/openfeature-provider-flagd": "0.1.5"
+  "providers/openfeature-provider-flagd": "0.1.5",
+  "providers/openfeature-provider-ofrep": "0.1.0"
 }

providers/openfeature-provider-flagd/src/openfeature/contrib/provider/flagd/resolvers/__init__.py

@@ -1,15 +1,13 @@
 import typing
 
-from typing_extensions import Protocol
-
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.flag_evaluation import FlagResolutionDetails
 
 from .grpc import GrpcResolver
 from .in_process import InProcessResolver
 
 
-class AbstractResolver(Protocol):
+class AbstractResolver(typing.Protocol):
     def shutdown(self) -> None: ...
 
     def resolve_boolean_details(

providers/openfeature-provider-flagd/src/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 @@
 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,51 @@ 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)
+    bucket = hash_ratio * 100
 
+    total_weight = 0
+    fractions = []
     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]
-
-    range_end = 0
-    for variant, weight in variant_weights:
-        range_end += weight
+        fraction = _parse_fraction(arg)
+        if fraction:
+            fractions.append(fraction)
+            total_weight += fraction.weight
+
+    range_end: float = 0
+    for fraction in fractions:
+        range_end += fraction.weight * 100 / total_weight
         if bucket < range_end:
-            return variant
+            return fraction.variant
 
     return None
 
 
+def _parse_fraction(arg: JsonLogicArg) -> typing.Optional[Fraction]:
+    if not isinstance(arg, (tuple, list)) or not arg:
+        logger.error(
+            "Fractional variant weights must be (str, int) tuple or [str] list"
+        )
+        return None
+
+    if not isinstance(arg[0], str):
+        logger.error(
+            "Fractional variant identifier (first element) isn't of type 'str'"
+        )
+        return None
+
+    if len(arg) >= 2 and not isinstance(arg[1], int):
+        logger.error(
+            "Fractional variant weight value (second element) isn't of type 'int'"
+        )
+        return None
+
+    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)

providers/openfeature-provider-flagd/tests/e2eGherkin/conftest.py

@@ -1,5 +1,34 @@
 import typing
 
+import pytest
+from testcontainers.core.container import DockerContainer
+from tests.e2eGherkin.flagd_container import FlagDContainer
 from tests.e2eGherkin.steps import *  # noqa: F403
 
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+from openfeature.contrib.provider.flagd.config import ResolverType
+
 JsonPrimitive = typing.Union[str, bool, float, int]
+
+
+@pytest.fixture(autouse=True, scope="package")
+def setup(request, port, image):
+    container: DockerContainer = FlagDContainer(
+        image=image,
+        port=port,
+    )
+    # Setup code
+    c = container.start()
+    api.set_provider(
+        FlagdProvider(
+            resolver_type=ResolverType.GRPC,
+            port=int(container.get_exposed_port(port)),
+        )
+    )
+
+    def fin():
+        c.stop()
+
+    # Teardown code
+    request.addfinalizer(fin)

providers/openfeature-provider-flagd/tests/e2eGherkin/flagd_container.py

@@ -1,8 +1,5 @@
 import time
-from time import sleep
 
-import grpc
-from grpc_health.v1 import health_pb2, health_pb2_grpc
 from testcontainers.core.container import DockerContainer
 from testcontainers.core.waiting_utils import wait_container_is_ready, wait_for_logs
 
@@ -12,7 +9,7 @@
 class FlagDContainer(DockerContainer):
     def __init__(
         self,
-        image: str = "ghcr.io/open-feature/flagd-testbed:v0.5.10",
+        image: str = "ghcr.io/open-feature/flagd-testbed:v0.5.13",
         port: int = 8013,
         **kwargs,
     ) -> None:
@@ -30,31 +27,31 @@ def _checker(self, host: str, port: int) -> None:
         # First we wait for Flagd to say it's listening
         wait_for_logs(
             self,
-            "Flag IResolver listening at",
+            "listening",
             5,
         )
 
         time.sleep(1)
-        # Second we use the GRPC health check endpoint
-        with grpc.insecure_channel(host + ":" + port) as channel:
-            health_stub = health_pb2_grpc.HealthStub(channel)
-
-            def health_check_call(stub: health_pb2_grpc.HealthStub):
-                request = health_pb2.HealthCheckRequest()
-                resp = stub.Check(request)
-                if resp.status == health_pb2.HealthCheckResponse.SERVING:
-                    return True
-                elif resp.status == health_pb2.HealthCheckResponse.NOT_SERVING:
-                    return False
-
-            # Should succeed
-            # Check health status every 1 second for 30 seconds
-            ok = False
-            for _ in range(30):
-                ok = health_check_call(health_stub)
-                if ok:
-                    break
-                sleep(1)
-
-            if not ok:
-                raise ConnectionError("flagD not ready in time")
+        # # Second we use the GRPC health check endpoint
+        # with grpc.insecure_channel(host + ":" + port) as channel:
+        #     health_stub = health_pb2_grpc.HealthStub(channel)
+        #
+        #     def health_check_call(stub: health_pb2_grpc.HealthStub):
+        #         request = health_pb2.HealthCheckRequest()
+        #         resp = stub.Check(request)
+        #         if resp.status == health_pb2.HealthCheckResponse.SERVING:
+        #             return True
+        #         elif resp.status == health_pb2.HealthCheckResponse.NOT_SERVING:
+        #             return False
+        #
+        #     # Should succeed
+        #     # Check health status every 1 second for 30 seconds
+        #     ok = False
+        #     for _ in range(30):
+        #         ok = health_check_call(health_stub)
+        #         if ok:
+        #             break
+        #         sleep(1)
+        #
+        #     if not ok:
+        #         raise ConnectionError("flagD not ready in time")