Merge pull request #1 from Flagsmith/init

feat(init): initial work on OpenFeature provider for Flagsmith

Author: matthewelwell

.github/workflows/publish.yml

@@ -0,0 +1,46 @@
+name: Publish Pypi Package
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.x"
+
+      - name: build release distributions
+        run: |
+          pip install poetry
+          poetry build -f sdist
+
+      - name: upload windows dists
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      id-token: write
+    environment: release
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

.github/workflows/pytest.yml

@@ -0,0 +1,39 @@
+name: Formatting and Tests
+
+on:
+  - pull_request
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    name: Pytest and formatting
+
+    strategy:
+      max-parallel: 4
+      matrix:
+        python-version: ['3.9', '3.10', '3.11', '3.12']
+
+    steps:
+      - name: Cloning repo
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install poetry
+          poetry install
+
+      - name: Check Formatting
+        run: |
+          poetry run ruff format --check
+          poetry run ruff check
+
+      - name: Run Tests
+        run: poetry run pytest

.gitignore

@@ -157,4 +157,4 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+.idea/

.pre-commit-config.yaml

@@ -0,0 +1,9 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.3.2
+    hooks:
+      # lint
+      - id: ruff
+        args: [ --fix ]
+      # format
+      - id: ruff-format

openfeature_flagsmith/__init__.py

@@ -0,0 +1,13 @@
+from openfeature.exception import OpenFeatureError, ProviderFatalError
+
+
+class FlagsmithProviderError(OpenFeatureError):
+    pass
+
+
+class FlagsmithConfigurationError(ProviderFatalError):
+    """
+    This exception should be raised when the Flagsmith provider has not been set up correctly
+    """
+
+    pass

openfeature_flagsmith/exceptions.py

@@ -0,0 +1,132 @@
+import json
+import typing
+from json import JSONDecodeError
+
+from flagsmith.exceptions import FlagsmithClientError
+from flagsmith.flagsmith import Flagsmith
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.exception import (
+    ErrorCode,
+    FlagNotFoundError,
+    ParseError,
+    TypeMismatchError,
+)
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagType
+from openfeature.provider import Metadata
+from openfeature.provider.provider import AbstractProvider
+
+from openfeature_flagsmith.exceptions import FlagsmithProviderError
+
+_BASIC_FLAG_TYPE_MAPPINGS = {
+    FlagType.BOOLEAN: bool,
+    FlagType.INTEGER: int,
+    FlagType.FLOAT: float,
+    FlagType.STRING: str,
+}
+
+
+class FlagsmithProvider(AbstractProvider):
+    def __init__(
+        self,
+        client: Flagsmith,
+        use_boolean_config_value: bool = False,
+        return_value_for_disabled_flags: bool = False,
+        use_flagsmith_defaults: bool = False,
+    ):
+        self._client = client
+        self.return_value_for_disabled_flags = return_value_for_disabled_flags
+        self.use_flagsmith_defaults = use_flagsmith_defaults
+        self.use_boolean_config_value = use_boolean_config_value
+
+    def get_metadata(self) -> Metadata:
+        return Metadata(name="FlagsmithProvider")
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: EvaluationContext = EvaluationContext(),
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(key, FlagType.BOOLEAN, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: EvaluationContext = EvaluationContext(),
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(key, FlagType.STRING, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: EvaluationContext = EvaluationContext(),
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(key, FlagType.INTEGER, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: EvaluationContext = EvaluationContext(),
+    ) -> FlagResolutionDetails[float]:
+        return self._resolve(key, FlagType.FLOAT, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: EvaluationContext = EvaluationContext(),
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
+
+    def _resolve(
+        self,
+        key: str,
+        flag_type: FlagType,
+        default_value: typing.Any,
+        evaluation_context: EvaluationContext,
+    ) -> FlagResolutionDetails:
+        try:
+            flag = self._get_flags(evaluation_context).get_flag(key)
+        except FlagsmithClientError as e:
+            raise FlagsmithProviderError(
+                error_code=ErrorCode.GENERAL,
+                error_message="An error occurred retrieving flags from Flagsmith client.",
+            ) from e
+
+        if flag.is_default and not self.use_flagsmith_defaults:
+            raise FlagNotFoundError(error_message="Flag '%s' was not found." % key)
+
+        if flag_type == FlagType.BOOLEAN and not self.use_boolean_config_value:
+            return FlagResolutionDetails(value=flag.enabled)
+
+        if not (self.return_value_for_disabled_flags or flag.enabled):
+            raise FlagsmithProviderError(
+                error_code=ErrorCode.GENERAL,
+                error_message="Flag '%s' is not enabled." % key,
+            )
+
+        required_type = _BASIC_FLAG_TYPE_MAPPINGS.get(flag_type)
+        if required_type and isinstance(flag.value, required_type):
+            return FlagResolutionDetails(value=flag.value)
+        elif flag_type is FlagType.OBJECT and isinstance(flag.value, str):
+            try:
+                return FlagResolutionDetails(value=json.loads(flag.value))
+            except JSONDecodeError as e:
+                msg = "Unable to parse object from value for flag '%s'" % key
+                raise ParseError(error_message=msg) from e
+
+        raise TypeMismatchError(
+            error_message="Value for flag '%s' is not of type '%s'"
+            % (key, flag_type.value)
+        )
+
+    def _get_flags(self, evaluation_context: EvaluationContext = EvaluationContext()):
+        if targeting_key := evaluation_context.targeting_key:
+            return self._client.get_identity_flags(
+                identifier=targeting_key,
+                traits=evaluation_context.attributes.get("traits", {}),
+            )
+        return self._client.get_environment_flags()