openfeature-provider-flagd 0.1.3__tar.gz → 0.1.5__tar.gz

openfeature_provider_flagd-0.1.5/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+## [0.1.5](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.1.4...openfeature-provider-flagd/v0.1.5) (2024-04-11)
+
+
+### ✨ New Features
+
+* in-process offline flagd resolver ([#74](https://github.com/open-feature/python-sdk-contrib/issues/74)) ([8cea506](https://github.com/open-feature/python-sdk-contrib/commit/8cea5066ee96f637f3108a9dc3a7539c450a14be))
+
+## [0.1.4](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.1.3...openfeature-provider-flagd/v0.1.4) (2024-03-26)
+
+
+### 🐛 Bug Fixes
+
+* include targetingKey in flagd serialized evaluation context ([#58](https://github.com/open-feature/python-sdk-contrib/issues/58)) ([ddd79a4](https://github.com/open-feature/python-sdk-contrib/commit/ddd79a49b765aa0679a2c1938447c61b37b6d0fe))
+* respect timeout setting in grpc method calls ([#60](https://github.com/open-feature/python-sdk-contrib/issues/60)) ([0149cf7](https://github.com/open-feature/python-sdk-contrib/commit/0149cf7ced8116f54a9b220549834a1970460bd9))
+* return proper metadata object in FlagdProvider ([#59](https://github.com/open-feature/python-sdk-contrib/issues/59)) ([6508234](https://github.com/open-feature/python-sdk-contrib/commit/6508234486ba0b650e849cbee22505988233131a))
+
+
+### ✨ New Features
+
+* implement environment-variable based config ([#62](https://github.com/open-feature/python-sdk-contrib/issues/62)) ([a8b78b2](https://github.com/open-feature/python-sdk-contrib/commit/a8b78b28fe44ca712b00db04ac1a23a9c9bc6d9b))
+* replace schema with tls argument in FlagdProvider constructor ([#61](https://github.com/open-feature/python-sdk-contrib/issues/61)) ([7a7210f](https://github.com/open-feature/python-sdk-contrib/commit/7a7210f6f63a9cba886f4d512c01ebac39d910a9))
+
+
+### 🧹 Chore
+
+* exclude generated protobuf files from coverage report ([#51](https://github.com/open-feature/python-sdk-contrib/issues/51)) ([660a0cb](https://github.com/open-feature/python-sdk-contrib/commit/660a0cbc9bb932ac0dd9cb09f1d75177b161601b))
+
+
+### 🔄 Refactoring
+
+* add mypy and fix typing issues ([#72](https://github.com/open-feature/python-sdk-contrib/issues/72)) ([b405925](https://github.com/open-feature/python-sdk-contrib/commit/b4059255045cdb7054a35bc338207e23c42ce068))
+
+## [0.1.3](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.1.2...openfeature-provider-flagd/v0.1.3) (2024-02-23)
+
+
+### 🐛 Bug Fixes
+
+* include proto file in build for openfeature-provider-flagd ([#45](https://github.com/open-feature/python-sdk-contrib/issues/45)) ([7783cc8](https://github.com/open-feature/python-sdk-contrib/commit/7783cc8e7fb8fe0f9b812938efcd1f4c07e3ff68))
+
+## [0.1.2](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd-v0.1.1...openfeature-provider-flagd/v0.1.2) (2024-02-22)
+
+
+### 🐛 Bug Fixes
+
+* remove mention of local eval in readme ([41df80e](https://github.com/open-feature/python-sdk-contrib/commit/41df80e1b3044356e3b228a484f3a13c92068d91))
+* remove setup from flagd tests ([#39](https://github.com/open-feature/python-sdk-contrib/issues/39)) ([85661ff](https://github.com/open-feature/python-sdk-contrib/commit/85661ff170b378d37b0a3d5d0a955dad3417f538))
+
+
+### 🧹 Chore
+
+* **main:** release providers/flagd 0.1.1 ([#40](https://github.com/open-feature/python-sdk-contrib/issues/40)) ([d42ee1e](https://github.com/open-feature/python-sdk-contrib/commit/d42ee1e531249e0023456dbe46db2f4f0c52a5c5))
+
+## [0.1.1](https://github.com/open-feature/python-sdk-contrib/compare/providers/flagd-v0.1.0...providers/flagd/v0.1.1) (2024-02-22)
+
+
+### 🐛 Bug Fixes
+
+* remove setup from flagd tests ([#39](https://github.com/open-feature/python-sdk-contrib/issues/39)) ([85661ff](https://github.com/open-feature/python-sdk-contrib/commit/85661ff170b378d37b0a3d5d0a955dad3417f538))

{openfeature_provider_flagd-0.1.3 → openfeature_provider_flagd-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: openfeature-provider-flagd
-Version: 0.1.3
+Version: 0.1.5
 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>
@@ -211,8 +211,12 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Requires-Dist: grpcio>=1.60.0
+Requires-Dist: mmh3>=4.1.0
 Requires-Dist: openfeature-sdk>=0.4.0
+Requires-Dist: panzi-json-logic>=1.0.1
 Requires-Dist: protobuf>=4.25.2
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: semver<4,>=3
 Description-Content-Type: text/markdown
 
 # flagd Provider for OpenFeature
@@ -236,6 +240,19 @@ from openfeature.contrib.provider.flagd import FlagdProvider
 api.set_provider(FlagdProvider())
 ```
 
+To use in-process evaluation in offline mode with a file as source:
+
+```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.IN_PROCESS,
+    offline_flag_source_path="my-flag.json",
+))
+```
+
 ### Configuration options
 
 The default options can be defined in the FlagdProvider constructor.

{openfeature_provider_flagd-0.1.3 → openfeature_provider_flagd-0.1.5}/README.md

@@ -19,6 +19,19 @@ from openfeature.contrib.provider.flagd import FlagdProvider
 api.set_provider(FlagdProvider())
 ```
 
+To use in-process evaluation in offline mode with a file as source:
+
+```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.IN_PROCESS,
+    offline_flag_source_path="my-flag.json",
+))
+```
+
 ### Configuration options
 
 The default options can be defined in the FlagdProvider constructor.

{openfeature_provider_flagd-0.1.3 → openfeature_provider_flagd-0.1.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openfeature-provider-flagd"
-version = "0.1.3"
+version = "0.1.5"
 description = "OpenFeature provider for the flagd flag evaluation engine"
 readme = "README.md"
 authors = [{ name = "OpenFeature", email = "openfeature-core@groups.io" }]
@@ -20,6 +20,10 @@ dependencies = [
   "openfeature-sdk>=0.4.0",
   "grpcio>=1.60.0",
   "protobuf>=4.25.2",
+  "mmh3>=4.1.0",
+  "panzi-json-logic>=1.0.1",
+  "semver>=3,<4",
+  "pyyaml>=6.0.1",
 ]
 requires-python = ">=3.8"
 
@@ -32,6 +36,7 @@ Homepage = "https://github.com/open-feature/python-sdk-contrib"
 dependencies = [
   "coverage[toml]>=6.5",
   "pytest",
+  "pytest-bdd",
 ]
 post-install-commands = [
   "./scripts/gen_protos.sh"
@@ -42,6 +47,7 @@ test = "pytest {args:tests}"
 test-cov = "coverage run -m pytest {args:tests}"
 cov-report = [
   "coverage xml",
+  "coverage html",
 ]
 cov = [
   "test-cov",
@@ -56,3 +62,10 @@ exclude = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/openfeature"]
+
+[tool.coverage.run]
+omit = [
+  # exclude generated files
+  "src/openfeature/contrib/provider/flagd/proto/*",
+  "tests/**",
+]

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/config.py

@@ -0,0 +1,59 @@
+import os
+import typing
+from enum import Enum
+
+T = typing.TypeVar("T")
+
+
+def str_to_bool(val: str) -> bool:
+    return val.lower() == "true"
+
+
+def env_or_default(
+    env_var: str, default: T, cast: typing.Optional[typing.Callable[[str], T]] = None
+) -> typing.Union[str, T]:
+    val = os.environ.get(env_var)
+    if val is None:
+        return 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,
+    ):
+        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.tls = (
+            env_or_default("FLAGD_TLS", False, cast=str_to_bool) if tls is None else tls
+        )
+        self.timeout = 5 if timeout is None else timeout
+        self.resolver_type = (
+            ResolverType(env_or_default("FLAGD_RESOLVER_TYPE", "grpc"))
+            if resolver_type is None
+            else resolver_type
+        )
+        self.offline_flag_source_path = (
+            env_or_default("FLAGD_OFFLINE_FLAG_SOURCE_PATH", None)
+            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
+        )

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/provider.py

@@ -0,0 +1,136 @@
+"""
+# This is a Python Provider to interact with flagd
+#
+# -- Usage --
+# open_feature_api.set_provider(flagd_provider.FlagdProvider())
+# flag_value =  open_feature_client.get_string_value(
+#                   key="foo",
+#                   default_value="missingflag"
+#               )
+# print(f"Flag Value is: {flag_value}")
+#   OR the more verbose option
+# flag = open_feature_client.get_string_details(key="foo", default_value="missingflag")
+# print(f"Flag is: {flag.value}")
+#   OR
+# print(f"Flag Details: {vars(flag)}"")
+#
+# -- Customisation --
+# Follows flagd defaults: 'http' protocol on 'localhost' on port '8013'
+# But can be overridden:
+# provider = open_feature_api.get_provider()
+# provider.initialise(schema="https",endpoint="example.com",port=1234,timeout=10)
+"""
+
+import typing
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.provider.metadata import Metadata
+from openfeature.provider.provider import AbstractProvider
+
+from .config import Config, ResolverType
+from .resolvers import AbstractResolver, GrpcResolver, InProcessResolver
+
+T = typing.TypeVar("T")
+
+
+class FlagdProvider(AbstractProvider):
+    """Flagd OpenFeature Provider"""
+
+    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,
+    ):
+        """
+        Create an instance of the FlagdProvider
+
+        :param host: the host to make requests to
+        :param port: the port the flagd service is available on
+        :param tls: enable/disable secure TLS connectivity
+        :param timeout: the maximum to wait before a request times out
+        """
+        self.config = Config(
+            host=host,
+            port=port,
+            tls=tls,
+            timeout=timeout,
+            resolver_type=resolver_type,
+            offline_flag_source_path=offline_flag_source_path,
+            offline_poll_interval_seconds=offline_poll_interval_seconds,
+        )
+
+        self.resolver = self.setup_resolver()
+
+    def setup_resolver(self) -> AbstractResolver:
+        if self.config.resolver_type == ResolverType.GRPC:
+            return GrpcResolver(self.config)
+        elif self.config.resolver_type == ResolverType.IN_PROCESS:
+            return InProcessResolver(self.config, self)
+        else:
+            raise ValueError(
+                f"`resolver_type` parameter invalid: {self.config.resolver_type}"
+            )
+
+    def shutdown(self) -> None:
+        if self.resolver:
+            self.resolver.shutdown()
+
+    def get_metadata(self) -> Metadata:
+        """Returns provider metadata"""
+        return Metadata(name="FlagdProvider")
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self.resolver.resolve_boolean_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self.resolver.resolve_string_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        return self.resolver.resolve_float_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self.resolver.resolve_integer_details(
+            key, default_value, evaluation_context
+        )
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self.resolver.resolve_object_details(
+            key, default_value, evaluation_context
+        )

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/resolvers/__init__.py

@@ -0,0 +1,51 @@
+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):
+    def shutdown(self) -> None: ...
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]: ...
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]: ...
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]: ...
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]: ...
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]: ...
+
+
+__all__ = ["AbstractResolver", "GrpcResolver", "InProcessResolver"]

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/resolvers/grpc.py

@@ -0,0 +1,145 @@
+import typing
+
+import grpc
+from google.protobuf.struct_pb2 import Struct
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import (
+    FlagNotFoundError,
+    GeneralError,
+    InvalidContextError,
+    ParseError,
+    TypeMismatchError,
+)
+from openfeature.flag_evaluation import FlagResolutionDetails
+
+from ..config import Config
+from ..flag_type import FlagType
+from ..proto.schema.v1 import schema_pb2, schema_pb2_grpc
+
+T = typing.TypeVar("T")
+
+
+class GrpcResolver:
+    def __init__(self, config: Config):
+        self.config = config
+        channel_factory = (
+            grpc.secure_channel if self.config.tls else grpc.insecure_channel
+        )
+        self.channel = channel_factory(f"{self.config.host}:{self.config.port}")
+        self.stub = schema_pb2_grpc.ServiceStub(self.channel)
+
+    def shutdown(self) -> None:
+        self.channel.close()
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(key, FlagType.BOOLEAN, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(key, FlagType.STRING, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        return self._resolve(key, FlagType.FLOAT, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(key, FlagType.INTEGER, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
+
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: T,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[T]:
+        context = self._convert_context(evaluation_context)
+        call_args = {"timeout": self.config.timeout}
+        try:
+            if flag_type == FlagType.BOOLEAN:
+                request = schema_pb2.ResolveBooleanRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveBoolean(request, **call_args)
+            elif flag_type == FlagType.STRING:
+                request = schema_pb2.ResolveStringRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveString(request, **call_args)
+            elif flag_type == FlagType.OBJECT:
+                request = schema_pb2.ResolveObjectRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveObject(request, **call_args)
+            elif flag_type == FlagType.FLOAT:
+                request = schema_pb2.ResolveFloatRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveFloat(request, **call_args)
+            elif flag_type == FlagType.INTEGER:
+                request = schema_pb2.ResolveIntRequest(  # type:ignore[attr-defined]
+                    flag_key=flag_key, context=context
+                )
+                response = self.stub.ResolveInt(request, **call_args)
+            else:
+                raise ValueError(f"Unknown flag type: {flag_type}")
+
+        except grpc.RpcError as e:
+            code = e.code()
+            message = f"received grpc status code {code}"
+
+            if code == grpc.StatusCode.NOT_FOUND:
+                raise FlagNotFoundError(message) from e
+            elif code == grpc.StatusCode.INVALID_ARGUMENT:
+                raise TypeMismatchError(message) from e
+            elif code == grpc.StatusCode.DATA_LOSS:
+                raise ParseError(message) from e
+            raise GeneralError(message) from e
+
+        # Got a valid flag and valid type. Return it.
+        return FlagResolutionDetails(
+            value=response.value,
+            reason=response.reason,
+            variant=response.variant,
+        )
+
+    def _convert_context(
+        self, evaluation_context: typing.Optional[EvaluationContext]
+    ) -> Struct:
+        s = Struct()
+        if evaluation_context:
+            try:
+                s["targetingKey"] = evaluation_context.targeting_key
+                s.update(evaluation_context.attributes)
+            except ValueError as exc:
+                message = (
+                    "could not serialize evaluation context to google.protobuf.Struct"
+                )
+                raise InvalidContextError(message) from exc
+        return s

openfeature_provider_flagd-0.1.5/src/openfeature/contrib/provider/flagd/resolvers/in_process.py

@@ -0,0 +1,122 @@
+import time
+import typing
+
+from json_logic import builtins, jsonLogic  # type: ignore[import-untyped]
+
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import FlagNotFoundError, ParseError
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.provider.provider import AbstractProvider
+
+from ..config import Config
+from .process.custom_ops import ends_with, fractional, sem_ver, starts_with
+from .process.file_watcher import FileWatcherFlagStore
+
+T = typing.TypeVar("T")
+
+
+class InProcessResolver:
+    OPERATORS: typing.ClassVar[dict] = {
+        **builtins.BUILTINS,
+        "fractional": fractional,
+        "starts_with": starts_with,
+        "ends_with": ends_with,
+        "sem_ver": sem_ver,
+    }
+
+    def __init__(self, config: Config, provider: AbstractProvider):
+        self.config = config
+        self.provider = provider
+        if not self.config.offline_flag_source_path:
+            raise ValueError(
+                "offline_flag_source_path must be provided when using in-process resolver"
+            )
+        self.flag_store = FileWatcherFlagStore(
+            self.config.offline_flag_source_path,
+            self.provider,
+            self.config.offline_poll_interval_seconds,
+        )
+
+    def shutdown(self) -> None:
+        self.flag_store.shutdown()
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def _resolve(
+        self,
+        key: str,
+        default_value: T,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[T]:
+        flag = self.flag_store.get_flag(key)
+        if not flag:
+            raise FlagNotFoundError(f"Flag with key {key} not present in flag store.")
+
+        if flag.state == "DISABLED":
+            return FlagResolutionDetails(default_value, reason=Reason.DISABLED)
+
+        if not flag.targeting:
+            variant, value = flag.default
+            return FlagResolutionDetails(value, variant=variant, reason=Reason.STATIC)
+
+        json_logic_context = 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
+        )
+        variant = jsonLogic(flag.targeting, json_logic_context, self.OPERATORS)
+        if variant is None:
+            variant, value = flag.default
+            return FlagResolutionDetails(value, variant=variant, reason=Reason.DEFAULT)
+        if not isinstance(variant, (str, bool)):
+            raise ParseError(
+                "Parsed JSONLogic targeting did not return a string or bool"
+            )
+
+        variant, value = flag.get_variant(variant)
+        if not value:
+            raise ParseError(f"Resolved variant {variant} not in variants config.")
+
+        return FlagResolutionDetails(
+            value,
+            variant=variant,
+            reason=Reason.TARGETING_MATCH,
+        )