launchdarkly-openfeature-server 0.1.0__tar.gz

launchdarkly_openfeature_server-0.1.0/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2024 Catamorphic, Co.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

launchdarkly_openfeature_server-0.1.0/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.1
+Name: launchdarkly-openfeature-server
+Version: 0.1.0
+Summary: An OpenFeature provider for the LaunchDarkly Python server SDK
+Home-page: https://github.com/launchdarkly/openfeature-python-server
+License: Apache-2.0
+Author: LaunchDarkly
+Author-email: dev@launchdarkly.com
+Requires-Python: >=3.8,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: launchdarkly-server-sdk (<10)
+Requires-Dist: openfeature-sdk (==0.4.2)
+Project-URL: Documentation, https://launchdarkly-openfeature-server.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/launchdarkly/openfeature-python-server
+Description-Content-Type: text/markdown
+
+# LaunchDarkly OpenFeature provider for the Server-Side SDK for Python
+
+[![Quality control checks](https://github.com/launchdarkly/openfeature-python-server/actions/workflows/ci.yml/badge.svg)](https://github.com/launchdarkly/openfeature-python-server/actions/workflows/ci.yml)
+[![Packagist](https://img.shields.io/packagist/v/launchdarkly/openfeature-server.svg?style=flat-square)](https://packagist.org/packages/launchdarkly/openfeature-server)
+[![readthedocs](https://readthedocs.org/projects/launchdarkly-openfeature-server/badge/)](https://launchdarkly-openfeature-server.readthedocs.io/en/latest/)
+
+This provider allows for using LaunchDarkly with the OpenFeature SDK for Python.
+
+This provider is designed primarily for use in multi-user systems such as web servers and applications. It follows the server-side LaunchDarkly model for multi-user contexts. It is not intended for use in desktop and embedded systems applications.
+
+This provider is a beta version and should not be considered ready for production use while this message is visible.
+
+# LaunchDarkly overview
+
+[LaunchDarkly](https://www.launchdarkly.com) is a feature management platform that serves trillions of feature flags daily to help teams build better software, faster. [Get started](https://docs.launchdarkly.com/home/getting-started) using LaunchDarkly today!
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/launchdarkly.svg?style=social&label=Follow&maxAge=2592000)](https://twitter.com/intent/follow?screen_name=launchdarkly)
+
+## Supported Python versions
+
+This version of the LaunchDarkly provider works with Python 3.8 and above.
+
+## Getting started
+
+### Requisites
+
+Install the library via pip
+
+```shell
+$ pip install launchdarkly-openfeature-server
+```
+
+### Usage
+
+```python
+from ldclient import Config, LDClient
+from ld_openfeature import LaunchDarklyProvider
+from openfeature.evaluation_context import EvaluationContext
+from openfeature import api
+
+ld_client = LDClient(config=Config("sdk-key"))
+openfeature_provider = LaunchDarklyProvider(ld_client)
+
+api.set_provider(openfeature_provider)
+
+# Refer to OpenFeature documentation for getting a client and performing evaluations.
+```
+
+Refer to the [SDK reference guide](https://docs.launchdarkly.com/sdk/server-side/python) for instructions on getting started with using the SDK.
+
+For information on using the OpenFeature client please refer to the [OpenFeature Documentation](https://docs.openfeature.dev/docs/reference/concepts/evaluation-api/).
+
+## OpenFeature Specific Considerations
+
+LaunchDarkly evaluates contexts, and it can either evaluate a single-context, or a multi-context. When using OpenFeature both single and multi-contexts must be encoded into a single `EvaluationContext`. This is accomplished by looking for an attribute named `kind` in the `EvaluationContext`.
+
+There are 4 different scenarios related to the `kind`:
+1. There is no `kind` attribute. In this case the provider will treat the context as a single context containing a "user" kind.
+2. There is a `kind` attribute, and the value of that attribute is "multi". This will indicate to the provider that the context is a multi-context.
+3. There is a `kind` attribute, and the value of that attribute is a string other than "multi". This will indicate to the provider a single context of the kind specified.
+4. There is a `kind` attribute, and the attribute is not a string. In this case the value of the attribute will be discarded, and the context will be treated as a "user". An error message will be logged.
+
+The `kind` attribute should be a string containing only contain ASCII letters, numbers, `.`, `_` or `-`.
+
+The OpenFeature specification allows for an optional targeting key, but LaunchDarkly requires a key for evaluation. A targeting key must be specified for each context being evaluated. It may be specified using either `targetingKey`, as it is in the OpenFeature specification, or `key`, which is the typical LaunchDarkly identifier for the targeting key. If a `targetingKey` and a `key` are specified, then the `targetingKey` will take precedence.
+
+There are several other attributes which have special functionality within a single or multi-context.
+- A key of `privateAttributes`. Must be an array of string values. [Equivalent to the 'private' builder method in the SDK.](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.ContextBuilder.private)
+- A key of `anonymous`. Must be a boolean value.  [Equivalent to the 'anonymous' builder method in the SDK.](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.ContextBuilder.anonymous)
+- A key of `name`. Must be a string. [Equivalent to the 'name' builder method in the SDK.](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.ContextBuilder.name)
+
+### Examples
+
+#### A single user context
+
+```python
+context = EvaluationContext("the-key")
+```
+
+#### A single context of kind "organization"
+
+```python
+context = EvaluationContext("org-key", {"kind": "organization"});
+```
+
+#### A multi-context containing a "user" and an "organization"
+
+```python
+attributes = {
+    "kind": "multi",
+    "organization": {
+        "name": "the-org-name",
+        "targetingKey", "my-org-key",
+        "myCustomAttribute", "myAttributeValue"
+    },
+    "user": {
+        "key": "my-user-key",
+        "anonymous", true
+    }
+}
+context = EvaluationContext(null, attributes)
+```
+
+#### Setting private attributes in a single context
+
+```python
+attributes = {
+    "kind": "organization",
+    "myCustomAttribute": "myAttributeValue",
+    "privateAttributes": ["myCustomAttribute"]
+}
+
+context = EvaluationContext("org-key", attributes)
+```
+
+#### Setting private attributes in a multi-context
+
+```python
+attributes = {
+    "kind": "organization",
+    "organization": {
+        "name": "the-org-name",
+        "targetingKey": "my-org-key",
+        # This will ONLY apply to the "organization" attributes.
+        "privateAttributes": ["myCustomAttribute"],
+        # This attribute will be private.
+        "myCustomAttribute": "myAttributeValue",
+    },
+    "user": [
+        "key": "my-user-key",
+        "anonymous" = > true,
+        # This attribute will not be private.
+        "myCustomAttribute": "myAttributeValue",
+    ]
+}
+
+context = EvaluationContext(null, attributes)
+```
+
+## Learn more
+
+Check out our [documentation](http://docs.launchdarkly.com) for in-depth instructions on configuring and using LaunchDarkly. You can also head straight to the [complete reference guide for this SDK](https://docs.launchdarkly.com/sdk/server-side/python).
+
+The authoritative description of all properties and methods is in the [python documentation](https://launchdarkly.github.io/python-server-sdk/).
+
+## Contributing
+
+We encourage pull requests and other contributions from the community. Check out our [contributing guidelines](CONTRIBUTING.md) for instructions on how to contribute to this SDK.
+
+## About LaunchDarkly
+
+* LaunchDarkly is a continuous delivery platform that provides feature flags as a service and allows developers to iterate quickly and safely. We allow you to easily flag your features and manage them from the LaunchDarkly dashboard.  With LaunchDarkly, you can:
+    * Roll out a new feature to a subset of your users (like a group of users who opt-in to a beta tester group), gathering feedback and bug reports from real-world use cases.
+    * Gradually roll out a feature to an increasing percentage of users, and track the effect that the feature has on key metrics (for instance, how likely is a user to complete a purchase if they have feature A versus feature B?).
+    * Turn off a feature that you realize is causing performance problems in production, without needing to re-deploy, or even restart the application with a changed configuration file.
+    * Grant access to certain features based on user attributes, like payment plan (eg: users on the ‘gold’ plan get access to more features than users in the ‘silver’ plan). Disable parts of your application to facilitate maintenance, without taking everything offline.
+* LaunchDarkly provides feature flag SDKs for a wide variety of languages and technologies. Check out [our documentation](https://docs.launchdarkly.com/sdk) for a complete list.
+* Explore LaunchDarkly
+    * [launchdarkly.com](https://www.launchdarkly.com/ "LaunchDarkly Main Website") for more information
+    * [docs.launchdarkly.com](https://docs.launchdarkly.com/  "LaunchDarkly Documentation") for our documentation and SDK reference guides
+    * [apidocs.launchdarkly.com](https://apidocs.launchdarkly.com/  "LaunchDarkly API Documentation") for our API documentation
+    * [blog.launchdarkly.com](https://blog.launchdarkly.com/  "LaunchDarkly Blog Documentation") for the latest product updates
+

launchdarkly_openfeature_server-0.1.0/README.md

@@ -0,0 +1,162 @@
+# LaunchDarkly OpenFeature provider for the Server-Side SDK for Python
+
+[![Quality control checks](https://github.com/launchdarkly/openfeature-python-server/actions/workflows/ci.yml/badge.svg)](https://github.com/launchdarkly/openfeature-python-server/actions/workflows/ci.yml)
+[![Packagist](https://img.shields.io/packagist/v/launchdarkly/openfeature-server.svg?style=flat-square)](https://packagist.org/packages/launchdarkly/openfeature-server)
+[![readthedocs](https://readthedocs.org/projects/launchdarkly-openfeature-server/badge/)](https://launchdarkly-openfeature-server.readthedocs.io/en/latest/)
+
+This provider allows for using LaunchDarkly with the OpenFeature SDK for Python.
+
+This provider is designed primarily for use in multi-user systems such as web servers and applications. It follows the server-side LaunchDarkly model for multi-user contexts. It is not intended for use in desktop and embedded systems applications.
+
+This provider is a beta version and should not be considered ready for production use while this message is visible.
+
+# LaunchDarkly overview
+
+[LaunchDarkly](https://www.launchdarkly.com) is a feature management platform that serves trillions of feature flags daily to help teams build better software, faster. [Get started](https://docs.launchdarkly.com/home/getting-started) using LaunchDarkly today!
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/launchdarkly.svg?style=social&label=Follow&maxAge=2592000)](https://twitter.com/intent/follow?screen_name=launchdarkly)
+
+## Supported Python versions
+
+This version of the LaunchDarkly provider works with Python 3.8 and above.
+
+## Getting started
+
+### Requisites
+
+Install the library via pip
+
+```shell
+$ pip install launchdarkly-openfeature-server
+```
+
+### Usage
+
+```python
+from ldclient import Config, LDClient
+from ld_openfeature import LaunchDarklyProvider
+from openfeature.evaluation_context import EvaluationContext
+from openfeature import api
+
+ld_client = LDClient(config=Config("sdk-key"))
+openfeature_provider = LaunchDarklyProvider(ld_client)
+
+api.set_provider(openfeature_provider)
+
+# Refer to OpenFeature documentation for getting a client and performing evaluations.
+```
+
+Refer to the [SDK reference guide](https://docs.launchdarkly.com/sdk/server-side/python) for instructions on getting started with using the SDK.
+
+For information on using the OpenFeature client please refer to the [OpenFeature Documentation](https://docs.openfeature.dev/docs/reference/concepts/evaluation-api/).
+
+## OpenFeature Specific Considerations
+
+LaunchDarkly evaluates contexts, and it can either evaluate a single-context, or a multi-context. When using OpenFeature both single and multi-contexts must be encoded into a single `EvaluationContext`. This is accomplished by looking for an attribute named `kind` in the `EvaluationContext`.
+
+There are 4 different scenarios related to the `kind`:
+1. There is no `kind` attribute. In this case the provider will treat the context as a single context containing a "user" kind.
+2. There is a `kind` attribute, and the value of that attribute is "multi". This will indicate to the provider that the context is a multi-context.
+3. There is a `kind` attribute, and the value of that attribute is a string other than "multi". This will indicate to the provider a single context of the kind specified.
+4. There is a `kind` attribute, and the attribute is not a string. In this case the value of the attribute will be discarded, and the context will be treated as a "user". An error message will be logged.
+
+The `kind` attribute should be a string containing only contain ASCII letters, numbers, `.`, `_` or `-`.
+
+The OpenFeature specification allows for an optional targeting key, but LaunchDarkly requires a key for evaluation. A targeting key must be specified for each context being evaluated. It may be specified using either `targetingKey`, as it is in the OpenFeature specification, or `key`, which is the typical LaunchDarkly identifier for the targeting key. If a `targetingKey` and a `key` are specified, then the `targetingKey` will take precedence.
+
+There are several other attributes which have special functionality within a single or multi-context.
+- A key of `privateAttributes`. Must be an array of string values. [Equivalent to the 'private' builder method in the SDK.](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.ContextBuilder.private)
+- A key of `anonymous`. Must be a boolean value.  [Equivalent to the 'anonymous' builder method in the SDK.](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.ContextBuilder.anonymous)
+- A key of `name`. Must be a string. [Equivalent to the 'name' builder method in the SDK.](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.ContextBuilder.name)
+
+### Examples
+
+#### A single user context
+
+```python
+context = EvaluationContext("the-key")
+```
+
+#### A single context of kind "organization"
+
+```python
+context = EvaluationContext("org-key", {"kind": "organization"});
+```
+
+#### A multi-context containing a "user" and an "organization"
+
+```python
+attributes = {
+    "kind": "multi",
+    "organization": {
+        "name": "the-org-name",
+        "targetingKey", "my-org-key",
+        "myCustomAttribute", "myAttributeValue"
+    },
+    "user": {
+        "key": "my-user-key",
+        "anonymous", true
+    }
+}
+context = EvaluationContext(null, attributes)
+```
+
+#### Setting private attributes in a single context
+
+```python
+attributes = {
+    "kind": "organization",
+    "myCustomAttribute": "myAttributeValue",
+    "privateAttributes": ["myCustomAttribute"]
+}
+
+context = EvaluationContext("org-key", attributes)
+```
+
+#### Setting private attributes in a multi-context
+
+```python
+attributes = {
+    "kind": "organization",
+    "organization": {
+        "name": "the-org-name",
+        "targetingKey": "my-org-key",
+        # This will ONLY apply to the "organization" attributes.
+        "privateAttributes": ["myCustomAttribute"],
+        # This attribute will be private.
+        "myCustomAttribute": "myAttributeValue",
+    },
+    "user": [
+        "key": "my-user-key",
+        "anonymous" = > true,
+        # This attribute will not be private.
+        "myCustomAttribute": "myAttributeValue",
+    ]
+}
+
+context = EvaluationContext(null, attributes)
+```
+
+## Learn more
+
+Check out our [documentation](http://docs.launchdarkly.com) for in-depth instructions on configuring and using LaunchDarkly. You can also head straight to the [complete reference guide for this SDK](https://docs.launchdarkly.com/sdk/server-side/python).
+
+The authoritative description of all properties and methods is in the [python documentation](https://launchdarkly.github.io/python-server-sdk/).
+
+## Contributing
+
+We encourage pull requests and other contributions from the community. Check out our [contributing guidelines](CONTRIBUTING.md) for instructions on how to contribute to this SDK.
+
+## About LaunchDarkly
+
+* LaunchDarkly is a continuous delivery platform that provides feature flags as a service and allows developers to iterate quickly and safely. We allow you to easily flag your features and manage them from the LaunchDarkly dashboard.  With LaunchDarkly, you can:
+    * Roll out a new feature to a subset of your users (like a group of users who opt-in to a beta tester group), gathering feedback and bug reports from real-world use cases.
+    * Gradually roll out a feature to an increasing percentage of users, and track the effect that the feature has on key metrics (for instance, how likely is a user to complete a purchase if they have feature A versus feature B?).
+    * Turn off a feature that you realize is causing performance problems in production, without needing to re-deploy, or even restart the application with a changed configuration file.
+    * Grant access to certain features based on user attributes, like payment plan (eg: users on the ‘gold’ plan get access to more features than users in the ‘silver’ plan). Disable parts of your application to facilitate maintenance, without taking everything offline.
+* LaunchDarkly provides feature flag SDKs for a wide variety of languages and technologies. Check out [our documentation](https://docs.launchdarkly.com/sdk) for a complete list.
+* Explore LaunchDarkly
+    * [launchdarkly.com](https://www.launchdarkly.com/ "LaunchDarkly Main Website") for more information
+    * [docs.launchdarkly.com](https://docs.launchdarkly.com/  "LaunchDarkly Documentation") for our documentation and SDK reference guides
+    * [apidocs.launchdarkly.com](https://apidocs.launchdarkly.com/  "LaunchDarkly API Documentation") for our API documentation
+    * [blog.launchdarkly.com](https://blog.launchdarkly.com/  "LaunchDarkly Blog Documentation") for the latest product updates

launchdarkly_openfeature_server-0.1.0/ld_openfeature/__init__.py

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

launchdarkly_openfeature_server-0.1.0/ld_openfeature/impl/context_converter.py

@@ -0,0 +1,113 @@
+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('targetingKey')
+
+            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():
+            if k == 'key' or k == 'targetingKey':
+                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()

launchdarkly_openfeature_server-0.1.0/ld_openfeature/impl/details_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

launchdarkly_openfeature_server-0.1.0/ld_openfeature/provider.py

@@ -0,0 +1,111 @@
+from typing import Any, List, Optional, Union
+
+from ldclient import LDClient, Config
+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, config: Config):
+        self.__client = LDClient(config)
+
+        self.__context_converter = EvaluationContextConverter()
+        self.__details_converter = ResolutionDetailsConverter()
+
+    def shutdown(self):
+        self.__client.close()
+
+    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
+        )

launchdarkly_openfeature_server-0.1.0/ld_openfeature/py.typed

@@ -0,0 +1 @@
+

launchdarkly_openfeature_server-0.1.0/pyproject.toml

@@ -0,0 +1,74 @@
+[tool.poetry]
+name = "launchdarkly-openfeature-server"
+version = "0.1.0"
+description = "An OpenFeature provider for the LaunchDarkly Python server SDK"
+authors = ["LaunchDarkly <dev@launchdarkly.com>"]
+license = "Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/launchdarkly/openfeature-python-server"
+documentation = "https://launchdarkly-openfeature-server.readthedocs.io/en/latest/"
+classifiers = [
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries",
+]
+packages = [
+    { include = "ld_openfeature" },
+    { include = "tests" },
+]
+
+
+[tool.poetry.dependencies]
+python = "^3.8"
+openfeature-sdk = "0.4.2"
+launchdarkly-server-sdk = "<10"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=2.8"
+pytest-cov = ">=2.4.0"
+pytest-mypy = "==0.10.3"
+mypy = "==1.8.0"
+isort = "^5.13.2"
+
+
+[tool.poetry.group.docs]
+optional = true
+
+[tool.poetry.group.docs.dependencies]
+sphinx = "^6.0.0"
+sphinx-rtd-theme = ">=1.3,<3.0"
+certifi = ">=2018.4.16"
+expiringdict = ">=1.1.4"
+pyrfc3339 = ">=1.0"
+jsonpickle = ">1.4.1"
+semver = ">=2.7.9"
+urllib3 = ">=1.22.0"
+jinja2 = "3.1.3"
+
+
+[tool.mypy]
+python_version = "3.8"
+install_types = true
+non_interactive = true
+
+
+[tool.isort]
+py_version=38
+
+
+[tool.pytest.ini_options]
+addopts = ["-ra"]
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

launchdarkly_openfeature_server-0.1.0/tests/impl/test_context_converter.py

@@ -0,0 +1,185 @@
+import pytest
+from openfeature.evaluation_context import EvaluationContext
+
+from ld_openfeature.impl.context_converter import EvaluationContextConverter
+
+
+@pytest.fixture
+def context_converter() -> EvaluationContextConverter:
+    return EvaluationContextConverter()
+
+
+def test_create_context_with_only_targeting_key(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("user-key")
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'user-key'
+    assert ld_context.kind == 'user'
+
+
+def test_create_context_with_invalid_key(context_converter: EvaluationContextConverter, caplog):
+    context = EvaluationContext(None, {"key": False})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is False
+    assert ld_context.key == ''
+
+    assert caplog.records[0].message == "A non-string 'key' attribute was provided."
+
+
+def test_invalid_private_attribute_types_are_ignored(context_converter: EvaluationContextConverter, caplog):
+    context = EvaluationContext("user-key", {"privateAttributes": [True]})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'user-key'
+
+    assert caplog.records[0].message == "'privateAttributes' must be an array of only string values"
+
+
+def test_create_multi_context_with_invalid_targeting_key(context_converter: EvaluationContextConverter):
+    attributes = {
+        'kind': 'multi',
+        'user': {'targetingKey': False, 'key': 'user-key', 'name': 'User name'},
+        'org': {'key': 'org-key', 'name': 'Org name'},
+    }
+    context = EvaluationContext(None, attributes)
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'org-key'
+    assert ld_context.kind == 'org'
+
+
+def test_create_context_with_only_key(context_converter: EvaluationContextConverter):
+    context = EvaluationContext(None, {"key": "user-key"})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'user-key'
+    assert ld_context.kind == 'user'
+
+
+def test_targeting_key_takes_precedence_over_attribute_key(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("should-use", {"kind": "org", "key": "do-not-use"})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'should-use'
+    assert ld_context.kind == 'org'
+
+
+def test_targeting_key_in_attributes_is_ignored(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("should-use", {"kind": "org", "key": "do-not-use", "targetingKey": "also-do-not-use"})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'should-use'
+    assert ld_context.kind == 'org'
+
+
+def test_create_context_with_key_and_kind(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("org-key", {"kind": "org"})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'org-key'
+    assert ld_context.kind == 'org'
+
+
+def test_invalid_kind_resets_to_user(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("org-key", {"kind": False})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'org-key'
+    assert ld_context.kind == 'user'
+
+
+def test_attributes_are_referenced_correctly(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("user-key", {"kind": "user", "anonymous": True, "name": "Sandy", "lastName": "Beaches"})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'user-key'
+    assert ld_context.kind == 'user'
+    assert ld_context.anonymous is True
+    assert ld_context.name == 'Sandy'
+    assert ld_context.get('lastName') == 'Beaches'
+
+
+def test_invalid_attributes_are_ignored(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("user-key", {"kind": "user", "anonymous": "True", "name": 30, "privateAttributes": "testing"})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'user-key'
+    assert ld_context.kind == 'user'
+    assert ld_context.anonymous is False
+    assert ld_context.name is None
+    assert ld_context.private_attributes == ()
+
+
+def test_private_attributes_are_processed_correctly(context_converter: EvaluationContextConverter):
+    context = EvaluationContext("user-key", {"kind": "user", "address": {"street": "123 Easy St", "city": "Anytown"}, "name": "Sandy", "privateAttributes": ["name", "/address/city"]})
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.key == 'user-key'
+    assert ld_context.kind == 'user'
+    assert ld_context.private_attributes == ["name", "/address/city"]
+
+
+def test_can_create_multi_kind_context(context_converter: EvaluationContextConverter):
+    attributes = {
+        'kind': 'multi',
+        'user': {'key': 'user-key', 'name': 'User name'},
+        'org': {'key': 'org-key', 'name': 'Org name'},
+    }
+    context = EvaluationContext(None, attributes)
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.multiple is True
+
+    user_context = ld_context.get_individual_context('user')
+    assert user_context is not None
+    assert user_context.key == 'user-key'
+    assert user_context.kind == 'user'
+    assert user_context.name == 'User name'
+
+    org_context = ld_context.get_individual_context('org')
+    assert org_context is not None
+    assert org_context.key == 'org-key'
+    assert org_context.kind == 'org'
+    assert org_context.name == 'Org name'
+
+
+def test_multi_context_discards_invalid_single_kind(context_converter: EvaluationContextConverter):
+    attributes = {
+        'kind': 'multi',
+        'user': False,
+        'org': {'key': 'org-key', 'name': 'Org name'},
+    }
+    context = EvaluationContext(None, attributes)
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is True
+    assert ld_context.multiple is False
+    assert ld_context.key == 'org-key'
+    assert ld_context.kind == 'org'
+    assert ld_context.name == 'Org name'
+
+
+def test_handles_invalid_nested_contexts(context_converter: EvaluationContextConverter):
+    attributes = {
+        'kind': 'multi',
+        'user': 'invalid format',
+        'org': False
+    }
+    context = EvaluationContext(None, attributes)
+    ld_context = context_converter.to_ld_context(context)
+
+    assert ld_context.valid is False
+    assert ld_context.multiple is False

launchdarkly_openfeature_server-0.1.0/tests/impl/test_details_converter.py

@@ -0,0 +1,48 @@
+from typing import Optional, Union
+
+import pytest
+from ldclient.evaluation import EvaluationDetail
+from openfeature.exception import ErrorCode
+from openfeature.flag_evaluation import Reason
+
+from ld_openfeature.impl.details_converter import ResolutionDetailsConverter
+
+
+@pytest.fixture
+def details_converter() -> ResolutionDetailsConverter:
+    return ResolutionDetailsConverter()
+
+
+@pytest.mark.parametrize(
+    'detail_kind,reason',
+    [
+        pytest.param('OFF', Reason.DISABLED),
+        pytest.param('TARGET_MATCH', Reason.TARGETING_MATCH),
+        pytest.param('ERROR', Reason.ERROR),
+        pytest.param('FALLTHROUGH', 'FALLTHROUGH'),
+        pytest.param('RULE_MATCH', 'RULE_MATCH'),
+        pytest.param('PREREQUISITE_FAILED', 'PREREQUISITE_FAILED'),
+    ],
+)
+def test_ld_to_openfeature_kind_mappings(detail_kind: str, reason: Union[str, Reason], details_converter: ResolutionDetailsConverter):
+    detail = EvaluationDetail(True, None, {'kind': detail_kind})
+    resolution_details = details_converter.to_resolution_details(detail)
+    assert resolution_details.reason == reason
+
+
+@pytest.mark.parametrize(
+    'error_kind,error_code',
+    [
+        pytest.param(None, ErrorCode.GENERAL),
+        pytest.param('CLIENT_NOT_READY', ErrorCode.PROVIDER_NOT_READY),
+        pytest.param('FLAG_NOT_FOUND', ErrorCode.FLAG_NOT_FOUND),
+        pytest.param('MALFORMED_FLAG', ErrorCode.PARSE_ERROR),
+        pytest.param('USER_NOT_SPECIFIED', ErrorCode.TARGETING_KEY_MISSING),
+        pytest.param('EXCEPTION_ERROR', ErrorCode.GENERAL),
+    ],
+)
+def test_ld_to_openfeature_error_kind_mappings(error_kind: Optional[str], error_code: ErrorCode, details_converter: ResolutionDetailsConverter):
+    detail = EvaluationDetail(True, None, {'kind': 'ERROR', 'errorKind': error_kind})
+    resolution_details = details_converter.to_resolution_details(detail)
+    assert resolution_details.reason == Reason.ERROR
+    assert resolution_details.error_code == error_code

launchdarkly_openfeature_server-0.1.0/tests/test_provider.py

@@ -0,0 +1,130 @@
+from typing import List, Union
+from unittest.mock import patch
+
+import pytest
+from ldclient import Config, LDClient
+from ldclient.evaluation import EvaluationDetail
+from ldclient.integrations.test_data import TestData
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import ErrorCode
+from openfeature.flag_evaluation import Reason
+
+from ld_openfeature import LaunchDarklyProvider
+
+
+@pytest.fixture
+def test_data_source() -> TestData:
+    td = TestData.data_source()
+    td.update(td.flag("fallthrough-boolean").variation_for_all(True))
+    return td
+
+
+@pytest.fixture
+def evaluation_context() -> EvaluationContext:
+    return EvaluationContext('user-key')
+
+
+@pytest.fixture
+def config(test_data_source: TestData) -> Config:
+    return Config("example-key", update_processor_class=test_data_source, send_events=False)
+
+
+@pytest.fixture
+def provider(config) -> LaunchDarklyProvider:
+    return LaunchDarklyProvider(config)
+
+
+def test_metadata_name_is_correct(provider: LaunchDarklyProvider):
+    assert provider.get_metadata().name == "launchdarkly-openfeature-server"
+
+
+def test_not_providing_context_returns_error(provider: LaunchDarklyProvider):
+    resolution_details = provider.resolve_boolean_details("flag-key", True, None)
+
+    assert resolution_details.value is True
+    assert resolution_details.reason == Reason.ERROR
+    assert resolution_details.variant is None
+    assert resolution_details.error_code == ErrorCode.TARGETING_KEY_MISSING
+
+
+def test_evaluation_results_are_converted_to_details(provider: LaunchDarklyProvider, evaluation_context: EvaluationContext):
+    resolution_details = provider.resolve_boolean_details("fallthrough-boolean", True, evaluation_context)
+
+    assert resolution_details.value is True
+    assert resolution_details.reason == 'FALLTHROUGH'
+    assert resolution_details.variant == '0'
+    assert resolution_details.error_code is None
+
+
+def test_evaluation_error_results_are_converted_correctly(provider: LaunchDarklyProvider, evaluation_context: EvaluationContext):
+    detail = EvaluationDetail(True, None, {'kind': 'ERROR', 'errorKind': 'CLIENT_NOT_READY'})
+    with patch.object(LDClient, 'variation_detail', lambda self, _key, _context, _default: detail):
+        resolution_details = provider.resolve_boolean_details("flag-key", True, evaluation_context)
+
+    assert resolution_details.value is True
+    assert resolution_details.reason == Reason.ERROR
+    assert resolution_details.variant is None
+    assert resolution_details.error_code == ErrorCode.PROVIDER_NOT_READY
+
+
+def test_invalid_types_generate_type_mismatch_results(provider: LaunchDarklyProvider, evaluation_context: EvaluationContext):
+    resolution_details = provider.resolve_string_details("fallthrough-boolean", "default-value", evaluation_context)
+
+    assert resolution_details.value == "default-value"
+    assert resolution_details.reason == Reason.ERROR
+    assert resolution_details.variant is None
+    assert resolution_details.error_code == ErrorCode.TYPE_MISMATCH
+
+
+@pytest.mark.parametrize(
+    "default_value,return_value,expected_value,method_name",
+    [
+        pytest.param(True, False, False, 'resolve_boolean_details'),
+        pytest.param(False, True, True, 'resolve_boolean_details'),
+        pytest.param(False, 1, False, 'resolve_boolean_details'),
+        pytest.param(False, "True", False, 'resolve_boolean_details'),
+        pytest.param(True, [], True, 'resolve_boolean_details'),
+
+        pytest.param('default-string', 'return-string', 'return-string', 'resolve_string_details'),
+        pytest.param('default-string', 1, 'default-string', 'resolve_string_details'),
+        pytest.param('default-string', True, 'default-string', 'resolve_string_details'),
+
+        pytest.param(1, 2, 2, 'resolve_integer_details'),
+        pytest.param(1, True, 1, 'resolve_integer_details'),
+        pytest.param(1, False, 1, 'resolve_integer_details'),
+        pytest.param(1, "", 1, 'resolve_integer_details'),
+
+        pytest.param(1.0, 2.0, 2.0, 'resolve_float_details'),
+        pytest.param(1.0, 2, 2.0, 'resolve_float_details'),
+        pytest.param(1.0, True, 1.0, 'resolve_float_details'),
+        pytest.param(1.0, 'return-string', 1.0, 'resolve_float_details'),
+
+        pytest.param(['default-value'], ['return-string'], ['return-string'], 'resolve_object_details'),
+        pytest.param(['default-value'], True, ['default-value'], 'resolve_object_details'),
+        pytest.param(['default-value'], 1, ['default-value'], 'resolve_object_details'),
+        pytest.param(['default-value'], 'return-string', ['default-value'], 'resolve_object_details'),
+    ],
+)
+def test_check_method_and_result_match_type(
+        # start of parameterized values
+        default_value: Union[bool, str, int, float, List],
+        return_value: Union[bool, str, int, float, List],
+        expected_value: Union[bool, str, int, float, List],
+        method_name: str,
+        # end of parameterized values
+        test_data_source: TestData,
+        provider: LaunchDarklyProvider,
+        evaluation_context: EvaluationContext):
+    test_data_source.update(test_data_source.flag("check-method-flag").variations(return_value).variation_for_all(0))
+
+    method = getattr(provider, method_name)
+    resolution_details = method("check-method-flag", default_value, evaluation_context)
+
+    assert resolution_details.value == expected_value
+
+
+def test_logger_changes_should_cascade_to_evaluation_converter(provider: LaunchDarklyProvider, caplog):
+    _ = provider.resolve_boolean_details("fallthrough-boolean", False, EvaluationContext('user-key', {'kind': False}))
+
+    assert len(caplog.records) == 1
+    assert caplog.records[0].message == "'kind' was set to a non-string value; defaulting to user"