feat: implement basic functionality of OFREP provider

.pre-commit-config.yaml

@@ -25,6 +25,7 @@ repos:
           - opentelemetry-api
           - types-protobuf
           - types-PyYAML
+          - types-requests
           - mmh3
           - semver
           - panzi-json-logic

providers/openfeature-provider-ofrep/pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
 keywords = []
 dependencies = [
   "openfeature-sdk>=0.7.0",
+  "requests"
 ]
 requires-python = ">=3.8"
 
@@ -30,6 +31,8 @@ Homepage = "https://github.com/open-feature/python-sdk-contrib"
 dependencies = [
   "coverage[toml]>=6.5",
   "pytest",
+  "requests-mock",
+  "types-requests",
 ]
 
 [tool.hatch.envs.default.scripts]

providers/openfeature-provider-ofrep/src/openfeature/contrib/provider/ofrep/__init__.py

@@ -1,49 +1,180 @@
-from typing import List, Optional, Union
+import re
+from datetime import datetime, timedelta, timezone
+from email.utils import parsedate_to_datetime
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import urljoin
+
+import requests
+from requests.exceptions import JSONDecodeError
 
 from openfeature.evaluation_context import EvaluationContext
-from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.exception import (
+    ErrorCode,
+    FlagNotFoundError,
+    GeneralError,
+    InvalidContextError,
+    OpenFeatureError,
+    ParseError,
+    TargetingKeyMissingError,
+)
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
 from openfeature.hook import Hook
 from openfeature.provider import AbstractProvider, Metadata
 
+__all__ = ["OFREPProvider"]
+
 
 class OFREPProvider(AbstractProvider):
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: float = 5.0,
+    ):
+        self.base_url = base_url
+        self.headers = headers
+        self.timeout = timeout
+        self.retry_after: Optional[datetime] = None
+        self.session = requests.Session()
+        self.session.headers["User-Agent"] = "OpenFeature/1.0.0"
+        if headers:
+            self.session.headers.update(headers)
+
     def get_metadata(self) -> Metadata:
         return Metadata(name="OpenFeature Remote Evaluation Protocol Provider")
 
     def get_provider_hooks(self) -> List[Hook]:
         return []
 
-    def resolve_boolean_details(  # type: ignore[empty-body]
+    def resolve_boolean_details(
         self,
         flag_key: str,
         default_value: bool,
         evaluation_context: Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[bool]: ...
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(flag_key, default_value, evaluation_context)
 
-    def resolve_string_details(  # type: ignore[empty-body]
+    def resolve_string_details(
         self,
         flag_key: str,
         default_value: str,
         evaluation_context: Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[str]: ...
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(flag_key, default_value, evaluation_context)
 
-    def resolve_integer_details(  # type: ignore[empty-body]
+    def resolve_integer_details(
         self,
         flag_key: str,
         default_value: int,
         evaluation_context: Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[int]: ...
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(flag_key, default_value, evaluation_context)
 
-    def resolve_float_details(  # type: ignore[empty-body]
+    def resolve_float_details(
         self,
         flag_key: str,
         default_value: float,
         evaluation_context: Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[float]: ...
+    ) -> FlagResolutionDetails[float]:
+        return self._resolve(flag_key, default_value, evaluation_context)
 
-    def resolve_object_details(  # type: ignore[empty-body]
+    def resolve_object_details(
         self,
         flag_key: str,
         default_value: Union[dict, list],
         evaluation_context: Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[Union[dict, list]]: ...
+    ) -> FlagResolutionDetails[Union[dict, list]]:
+        return self._resolve(flag_key, default_value, evaluation_context)
+
+    def _resolve(
+        self,
+        flag_key: str,
+        default_value: Union[bool, str, int, float, dict, list],
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[Any]:
+        now = datetime.now(timezone.utc)
+        if self.retry_after and now <= self.retry_after:
+            raise GeneralError(
+                f"OFREP evaluation paused due to TooManyRequests until {self.retry_after}"
+            )
+        elif self.retry_after:
+            self.retry_after = None
+
+        try:
+            response = self.session.post(
+                urljoin(self.base_url, f"/ofrep/v1/evaluate/flags/{flag_key}"),
+                json=_build_request_data(evaluation_context),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+
+        except requests.RequestException as e:
+            self._handle_error(e)
+
+        try:
+            data = response.json()
+        except JSONDecodeError as e:
+            raise ParseError(str(e)) from e
+
+        return FlagResolutionDetails(
+            value=data["value"],
+            reason=Reason[data["reason"]],
+            variant=data["variant"],
+            flag_metadata=data["metadata"],
+        )
+
+    def _handle_error(self, exception: requests.RequestException) -> None:
+        response = exception.response
+        if response is None:
+            raise GeneralError(str(exception)) from exception
+
+        if response.status_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            self.retry_after = _parse_retry_after(retry_after)
+            raise GeneralError(
+                f"Rate limited, retry after: {retry_after}"
+            ) from exception
+
+        try:
+            data = response.json()
+        except JSONDecodeError:
+            raise ParseError(str(exception)) from exception
+
+        error_code = ErrorCode(data["errorCode"])
+        error_details = data["errorDetails"]
+
+        if response.status_code == 404:
+            raise FlagNotFoundError(error_details) from exception
+
+        if error_code == ErrorCode.PARSE_ERROR:
+            raise ParseError(error_details) from exception
+        if error_code == ErrorCode.TARGETING_KEY_MISSING:
+            raise TargetingKeyMissingError(error_details) from exception
+        if error_code == ErrorCode.INVALID_CONTEXT:
+            raise InvalidContextError(error_details) from exception
+        if error_code == ErrorCode.GENERAL:
+            raise GeneralError(error_details) from exception
+
+        raise OpenFeatureError(error_code, error_details) from exception
+
+
+def _build_request_data(
+    evaluation_context: Optional[EvaluationContext],
+) -> Dict[str, Any]:
+    data: Dict[str, Any] = {}
+    if evaluation_context:
+        data["context"] = {}
+        if evaluation_context.targeting_key:
+            data["context"]["targetingKey"] = evaluation_context.targeting_key
+        data["context"].update(evaluation_context.attributes)
+    return data
+
+
+def _parse_retry_after(retry_after: Optional[str]) -> Optional[datetime]:
+    if retry_after is None:
+        return None
+    if re.match(r"^\s*[0-9]+\s*$", retry_after):
+        seconds = int(retry_after)
+        return datetime.now(timezone.utc) + timedelta(seconds=seconds)
+    return parsedate_to_datetime(retry_after)

providers/openfeature-provider-ofrep/tests/conftest.py

@@ -0,0 +1,8 @@
+import pytest
+
+from openfeature.contrib.provider.ofrep import OFREPProvider
+
+
+@pytest.fixture
+def ofrep_provider():
+    return OFREPProvider("http://localhost:8080")

providers/openfeature-provider-ofrep/tests/test_provider.py

@@ -0,0 +1,119 @@
+import pytest
+
+from openfeature.contrib.provider.ofrep import OFREPProvider
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import (
+    FlagNotFoundError,
+    GeneralError,
+    InvalidContextError,
+    ParseError,
+)
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+
+
+def test_provider_init():
+    OFREPProvider("http://localhost:8080", headers={"Authorization": "Bearer token"})
+
+
+def test_provider_successful_resolution(ofrep_provider, requests_mock):
+    requests_mock.post(
+        "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key",
+        json={
+            "key": "flag_key",
+            "reason": "TARGETING_MATCH",
+            "variant": "true",
+            "metadata": {"foo": "bar"},
+            "value": True,
+        },
+    )
+
+    resolution = ofrep_provider.resolve_boolean_details("flag_key", False)
+
+    assert resolution == FlagResolutionDetails(
+        value=True,
+        reason=Reason.TARGETING_MATCH,
+        variant="true",
+        flag_metadata={"foo": "bar"},
+    )
+
+
+def test_provider_flag_not_found(ofrep_provider, requests_mock):
+    requests_mock.post(
+        "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key",
+        status_code=404,
+        json={
+            "key": "flag_key",
+            "errorCode": "FLAG_NOT_FOUND",
+            "errorDetails": "Flag 'flag_key' not found",
+        },
+    )
+
+    with pytest.raises(FlagNotFoundError):
+        ofrep_provider.resolve_boolean_details("flag_key", False)
+
+
+def test_provider_invalid_context(ofrep_provider, requests_mock):
+    requests_mock.post(
+        "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key",
+        status_code=400,
+        json={
+            "key": "flag_key",
+            "errorCode": "INVALID_CONTEXT",
+            "errorDetails": "Invalid context provided",
+        },
+    )
+
+    with pytest.raises(InvalidContextError):
+        ofrep_provider.resolve_boolean_details("flag_key", False)
+
+
+def test_provider_invalid_response(ofrep_provider, requests_mock):
+    requests_mock.post(
+        "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key", text="invalid"
+    )
+
+    with pytest.raises(ParseError):
+        ofrep_provider.resolve_boolean_details("flag_key", False)
+
+
+def test_provider_evaluation_context(ofrep_provider, requests_mock):
+    def match_request_json(request):
+        return request.json() == {"context": {"targetingKey": "1", "foo": "bar"}}
+
+    requests_mock.post(
+        "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key",
+        json={
+            "key": "flag_key",
+            "reason": "TARGETING_MATCH",
+            "variant": "true",
+            "metadata": {},
+            "value": True,
+        },
+        additional_matcher=match_request_json,
+    )
+
+    context = EvaluationContext("1", {"foo": "bar"})
+    resolution = ofrep_provider.resolve_boolean_details(
+        "flag_key", False, evaluation_context=context
+    )
+
+    assert resolution == FlagResolutionDetails(
+        value=True,
+        reason=Reason.TARGETING_MATCH,
+        variant="true",
+    )
+
+
+def test_provider_retry_after_shortcircuit_resolution(ofrep_provider, requests_mock):
+    requests_mock.post(
+        "http://localhost:8080/ofrep/v1/evaluate/flags/flag_key",
+        status_code=429,
+        headers={"Retry-After": "1"},
+    )
+
+    with pytest.raises(GeneralError, match="Rate limited, retry after: 1"):
+        ofrep_provider.resolve_boolean_details("flag_key", False)
+    with pytest.raises(
+        GeneralError, match="OFREP evaluation paused due to TooManyRequests"
+    ):
+        ofrep_provider.resolve_boolean_details("flag_key", False)