feat: Add initial implementation of provider

Author: keelerm84

Makefile

@@ -0,0 +1,24 @@
+.PHONY: help
+help: #! Show this help message
+	@echo 'Usage: make [target] ... '
+	@echo ''
+	@echo 'Targets:'
+	@grep -h -F '#!' $(MAKEFILE_LIST) | grep -v grep | sed 's/:.*#!/:/' | column -t -s":"
+
+.PHONY: install
+install:
+	@poetry install
+
+#
+# Quality control checks
+#
+
+.PHONY: test
+test: #! Run unit tests
+test: install
+	@poetry run pytest $(PYTEST_FLAGS)
+
+.PHONY: lint
+lint: #! Run type analysis and linting checks
+lint: install
+	@poetry run mypy ld_openfeature tests

client/__init__.py

@@ -0,0 +1,5 @@
+from ld_openfeature.provider import LaunchDarklyProvider
+
+__all__ = [
+    'LaunchDarklyProvider'
+]

ld_openfeature/__init__.py

@@ -0,0 +1,114 @@
+from logging import getLogger
+from typing import Any, Dict, List, Optional
+
+from ldclient.context import Context, ContextBuilder, ContextMultiBuilder
+from openfeature.provider.provider import EvaluationContext
+
+
+logger = getLogger("launchdarkly-openfeature-server")
+
+
+class EvaluationContextConverter:
+    def to_ld_context(self, context: EvaluationContext) -> Context:
+        """
+        Create an Context from an EvaluationContext.
+
+        A context will always be created, but the created context may be
+        invalid. Log messages will be written to indicate the source of the
+        problem.
+        """
+        attributes = context.attributes
+
+        kind = attributes.get('kind')
+        if kind == "multi":
+            return self.__build_multi_context(context)
+
+        if kind is not None and not isinstance(kind, str):
+            logger.warning("'kind' was set to a non-string value; defaulting to user")
+            kind = 'user'
+
+        targeting_key = context.targeting_key
+        key = attributes.get('key')
+        targeting_key = self.__get_targeting_key(targeting_key, key)
+
+        kind = "user" if kind is None else kind
+        return self.__build_single_context(attributes, kind, targeting_key)
+
+    def __get_targeting_key(self, targeting_key: Optional[str], key: Any) -> str:
+        # The targeting key may be set but empty. So we want to treat an empty
+        # string as a not defined one. Later it could become null, so we will
+        # need to check that.
+        if targeting_key is not None and targeting_key != "" and isinstance(key, str):
+            # There is both a targeting key and a key. It will work, but
+            # probably is not intentional.
+            logger.warning("EvaluationContext contained both a 'key' and 'targetingKey'.")
+
+        if key is not None and not isinstance(key, str):
+            logger.warning("A non-string 'key' attribute was provided.")
+
+        if key is not None and isinstance(key, str):
+            targeting_key = targeting_key if targeting_key else key
+
+        if targeting_key is None or targeting_key == "":
+            logger.error("The EvaluationContext must contain either a 'targetingKey' or a 'key' and the type must be a string.")
+
+        return targeting_key if targeting_key else ""
+
+    def __build_multi_context(self, context: EvaluationContext) -> Context:
+        builder = ContextMultiBuilder()
+
+        for kind, attributes in context.attributes.items():
+            if kind == 'kind':
+                continue
+
+            if not isinstance(attributes, Dict):
+                logger.warning("Top level attributes in a multi-kind context should be dictionaries")
+                continue
+
+            key = attributes.get('key')
+            targeting_key = attributes.get('targeting_key')
+
+            if targeting_key is not None and not isinstance(targeting_key, str):
+                continue
+
+            targeting_key = self.__get_targeting_key(targeting_key, key)
+            single_context = self.__build_single_context(attributes, kind, targeting_key)
+
+            builder.add(single_context)
+
+        return builder.build()
+
+    def __build_single_context(self, attributes: Dict, kind: str, key: str) -> Context:
+        builder = ContextBuilder(key)
+        builder.kind(kind)
+
+        for k, v in attributes.items():
+            # TODO: In PHP this was camel case. Is that the case for python? Check the docs.
+            if k == 'key' or k == 'targeting_key':
+                continue
+
+            if k == 'name' and isinstance(v, str):
+                builder.name(v)
+            elif k == 'name':
+                logger.error("The attribute 'name' must be a string")
+            elif k == 'anonymous' and isinstance(v, bool):
+                builder.anonymous(v)
+            elif k == 'anonymous':
+                logger.error("The attribute 'anonymous' must be a boolean")
+            elif k == 'privateAttributes' and isinstance(v, list):
+                private_attributes: List[str] = []
+                for private_attribute in v:
+                    if not isinstance(private_attribute, str):
+                        logger.error("'privateAttributes' must be an array of only string values")
+                        continue
+
+                    private_attributes.append(private_attribute)
+
+                if private_attributes:
+                    builder.private(*private_attributes)
+            elif k == 'privateAttributes':
+                logger.error("The attribute 'privateAttributes' must be an array")
+            else:
+                builder.set(k, v)
+
+        return builder.build()

ld_openfeature/impl/context_converter.py

@@ -0,0 +1,68 @@
+from typing import Optional
+
+from ldclient.evaluation import EvaluationDetail
+from openfeature.exception import ErrorCode
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+
+
+class ResolutionDetailsConverter:
+    def to_resolution_details(self, result: EvaluationDetail) -> FlagResolutionDetails:
+        value = result.value
+        is_default = result.is_default_value()
+        variation_index = result.variation_index
+
+        reason = result.reason
+        reason_kind = reason.get('kind')
+        reason_kind = reason_kind if isinstance(reason_kind, str) else ''
+
+        openfeature_reason = self.__kind_to_reason(reason_kind)
+
+        openfeature_error_code: Optional[ErrorCode] = None
+        if reason_kind == "ERROR":
+            openfeature_error_code = self.__error_kind_to_code(reason.get('errorKind'))
+
+        openfeature_variant: Optional[str] = None
+        if not is_default:
+            openfeature_variant = str(variation_index)
+
+        return FlagResolutionDetails(
+            value=value,
+            error_code=openfeature_error_code,
+            error_message=None,
+            reason=openfeature_reason,
+            variant=openfeature_variant
+            # flag_metadata = FlagMetadata = field(default_factory=dict)
+        )
+        pass
+
+    @staticmethod
+    def __kind_to_reason(kind: str) -> str:
+        if kind == 'OFF':
+            return Reason.DISABLED
+        elif kind == 'TARGET_MATCH':
+            return Reason.TARGETING_MATCH
+        elif kind == 'ERROR':
+            return Reason.ERROR
+
+        # NOTE: FALLTHROUGH, RULE_MATCH, PREREQUISITE_FAILED intentionally
+        # omitted
+
+        return kind
+
+    @staticmethod
+    def __error_kind_to_code(error_kind: Optional[str]) -> ErrorCode:
+        if error_kind is None:
+            return ErrorCode.GENERAL
+
+        if error_kind == 'CLIENT_NOT_READY':
+            return ErrorCode.PROVIDER_NOT_READY
+        elif error_kind == 'FLAG_NOT_FOUND':
+            return ErrorCode.FLAG_NOT_FOUND
+        elif error_kind == 'MALFORMED_FLAG':
+            return ErrorCode.PARSE_ERROR
+        elif error_kind == 'USER_NOT_SPECIFIED':
+            return ErrorCode.TARGETING_KEY_MISSING
+
+        # NOTE: EXCEPTION_ERROR intentionally omitted
+
+        return ErrorCode.GENERAL

ld_openfeature/impl/details_converter.py

@@ -0,0 +1,108 @@
+from typing import Any, List, Optional, Union
+
+from ldclient import LDClient
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import ErrorCode
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagType, Reason
+from openfeature.hook import Hook
+from openfeature.provider.metadata import Metadata
+from openfeature.provider.provider import AbstractProvider
+
+from ld_openfeature.impl.context_converter import EvaluationContextConverter
+from ld_openfeature.impl.details_converter import ResolutionDetailsConverter
+
+
+class LaunchDarklyProvider(AbstractProvider):
+    def __init__(self, client: LDClient):
+        self.__client = client
+
+        self.__context_converter = EvaluationContextConverter()
+        self.__details_converter = ResolutionDetailsConverter()
+
+    def get_metadata(self) -> Metadata:
+        return Metadata("launchdarkly-openfeature-server")
+
+    def get_provider_hooks(self) -> List[Hook]:
+        return []
+
+    def resolve_boolean_details(
+        self,
+        flag_key: str,
+        default_value: bool,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        """Resolves the flag value for the provided flag key as a boolean"""
+        return self.__resolve_value(FlagType(FlagType.BOOLEAN), flag_key, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        flag_key: str,
+        default_value: str,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        """Resolves the flag value for the provided flag key as a string"""
+        return self.__resolve_value(FlagType(FlagType.STRING), flag_key, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        flag_key: str,
+        default_value: int,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        """Resolves the flag value for the provided flag key as a integer"""
+        return self.__resolve_value(FlagType(FlagType.INTEGER), flag_key, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        flag_key: str,
+        default_value: float,
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        """Resolves the flag value for the provided flag key as a float"""
+        return self.__resolve_value(FlagType(FlagType.FLOAT), flag_key, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        flag_key: str,
+        default_value: Union[dict, list],
+        evaluation_context: Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[Union[dict, list]]:
+        """Resolves the flag value for the provided flag key as a list or dictionary"""
+        return self.__resolve_value(FlagType(FlagType.OBJECT), flag_key, default_value, evaluation_context)
+
+    def __resolve_value(self, flag_type: FlagType, flag_key: str, default_value: Any, evaluation_context: Optional[EvaluationContext] = None) -> FlagResolutionDetails:
+        if evaluation_context is None:
+            return FlagResolutionDetails(
+                value=default_value,
+                reason=Reason(Reason.ERROR),
+                error_code=ErrorCode.TARGETING_KEY_MISSING
+            )
+
+        ld_context = self.__context_converter.to_ld_context(evaluation_context)
+        result = self.__client.variation_detail(flag_key, ld_context, default_value)
+
+        if flag_type == FlagType.BOOLEAN and not isinstance(result.value, bool):
+            return self.__mismatched_type_details(default_value)
+        elif flag_type == FlagType.STRING and not isinstance(result.value, str):
+            return self.__mismatched_type_details(default_value)
+        elif flag_type == FlagType.INTEGER and isinstance(result.value, bool):
+            # Python treats boolean values as instances of int
+            return self.__mismatched_type_details(default_value)
+        elif flag_type == FlagType.FLOAT and isinstance(result.value, bool):
+            # Python treats boolean values as instances of int
+            return self.__mismatched_type_details(default_value)
+        elif flag_type == FlagType.INTEGER and not isinstance(result.value, int):
+            return self.__mismatched_type_details(default_value)
+        elif flag_type == FlagType.FLOAT and not isinstance(result.value, float) and not isinstance(result.value, int):
+            return self.__mismatched_type_details(default_value)
+        elif flag_type == FlagType.OBJECT and not isinstance(result.value, dict) and not isinstance(result.value, list):
+            return self.__mismatched_type_details(default_value)
+
+        return self.__details_converter.to_resolution_details(result)
+
+    def __mismatched_type_details(self, default_value: Any) -> FlagResolutionDetails:
+        return FlagResolutionDetails(
+            value=default_value,
+            reason=Reason(Reason.ERROR),
+            error_code=ErrorCode.TYPE_MISMATCH
+        )

ld_openfeature/provider.py

@@ -0,0 +1 @@
+

ld_openfeature/py.typed

@@ -21,7 +21,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries",
 ]
 packages = [
-    { include = "client" },
+    { include = "ld_openfeature" },
     { include = "tests" },
 ]
 
@@ -37,6 +37,7 @@ pytest = ">=2.8"
 pytest-cov = ">=2.4.0"
 pytest-mypy = "==0.10.3"
 mypy = "==1.8.0"
+isort = "^5.13.2"
 
 
 [tool.mypy]
@@ -45,6 +46,10 @@ install_types = true
 non_interactive = true
 
 
+[tool.isort]
+py_version=38
+
+
 [tool.pytest.ini_options]
 addopts = ["-ra"]