FFM-10393 Add get_flag_type and int_or_float_variation to Client API (#87)

Author: erdirowlands

examples/get_flag_type_example/get_flag_type.py

@@ -0,0 +1,48 @@
+import logging
+import time
+
+from featureflags.evaluations.auth_target import Target
+from featureflags.client import CfClient, FeatureFlagType
+from featureflags.util import log
+
+
+def main():
+    log.setLevel(logging.INFO)
+    log.info("Starting example")
+    api_key = "your_api_key"
+    client = CfClient(api_key)
+    # Don't continue until all flags and groups have been loaded into the
+    # cache.
+    log.info("Waiting to load all flags and groups before proceeding")
+    client.wait_for_initialization()
+
+    target = Target(identifier='harness')
+
+    flag_identifier = 'anyflag'
+
+    # Get the flag type
+    flag_type = client.get_flag_type(flag_identifier)
+    log.info("Flag '%s' is of type '%s'", flag_identifier, flag_type)
+
+    # Ensure the right variation method is called based on the flag type
+    variation_methods = {
+        FeatureFlagType.BOOLEAN: lambda: client.bool_variation(flag_identifier, target, False),
+
+        FeatureFlagType.STRING: lambda: client.string_variation(flag_identifier, target, "default"),
+
+        FeatureFlagType.INT_OR_FLOAT: lambda: client.int_or_float_variation(flag_identifier, target, 3.2),
+
+        FeatureFlagType.JSON: lambda: client.json_variation(flag_identifier, target, {}),
+
+        # If the flag cannot be found, log an error
+        FeatureFlagType.FLAG_NOT_FOUND: lambda: log.error("Flag %s was not found", flag_identifier)
+    }
+
+    while True:
+        result = variation_methods[flag_type]()
+        log.info("Result for flag type '%s' is %s", flag_type, result)
+        time.sleep(10)
+
+
+if __name__ == "__main__":
+    main()

featureflags/__init__.py

@@ -2,4 +2,4 @@
 
 __author__ = """Enver Bisevac"""
 __email__ = "[email protected]"
-__version__ = '1.3.0'
+__version__ = '1.4.0'

featureflags/analytics.py

@@ -33,7 +33,7 @@
 VARIATION_VALUE_ATTRIBUTE = 'variationValue'
 TARGET_ATTRIBUTE = 'target'
 SDK_VERSION_ATTRIBUTE = 'SDK_VERSION'
-SDK_VERSION = '1.3.0'
+SDK_VERSION = '1.4.0'
 SDK_TYPE_ATTRIBUTE = 'SDK_TYPE'
 SDK_TYPE = 'server'
 SDK_LANGUAGE_ATTRIBUTE = 'SDK_LANGUAGE'

featureflags/client.py

@@ -1,7 +1,8 @@
 """Client for interacting with Harness FF server"""
 
 import threading
-from typing import Any, Callable, Dict, Optional
+from enum import Enum
+from typing import Any, Callable, Dict, Optional, Union
 
 from tenacity import RetryError
 from jwt import decode
@@ -33,6 +34,14 @@ def __str__(self):
         return f"MissingOrEmptyAPIKeyException: {self.message}"
 
 
+class FeatureFlagType(str, Enum):
+    BOOLEAN = "boolean"
+    INT_OR_FLOAT = "int"
+    STRING = "string"
+    JSON = "json"
+    FLAG_NOT_FOUND = "flag_not_found"
+
+
 class CfClient(object):
     def __init__(
             self, sdk_key: str,
@@ -197,6 +206,21 @@ def authenticate(self):
             additional_headers["Harness-AccountID"] = decoded["accountID"]
         self._client = self._client.with_headers(additional_headers)
 
+    def get_flag_type(self, identifier) -> Optional[FeatureFlagType]:
+        if self._initialised_failed_reason[True] is not None:
+            log.warning(
+                "Failed to check flag type for flag '%s', reason: Client is "
+                "not initialized",
+                identifier)
+            return FeatureFlagType("flag_not_found")
+        kind = self._evaluator.get_kind(identifier)
+        if not kind:
+            log.warning(
+                "Failed to check flag kind for flag '%s', reason: flag not "
+                "found", identifier)
+            return FeatureFlagType("flag_not_found")
+        return FeatureFlagType(kind)
+
     def bool_variation(self, identifier: str, target: Target,
                        default: bool) -> bool:
         # If initialization has failed, then return the default variation
@@ -291,6 +315,40 @@ def number_variation(self, identifier: str, target: Target,
                 "Reason: '%s'", identifier, default, str(ex))
             return default
 
+    def int_or_float_variation(self, identifier: str, target: Target,
+                                default: Union[float, int]) -> Union[
+        float, int]:
+
+        # If initialization has failed, then return the default variation
+        # immediately
+        if self._initialised_failed_reason[True] is not None:
+            log.error(
+                "SDKCODE:6001: Failed to evaluate int_or_float variation for "
+                "flag '%s' and the default variation '%s' is being returned. "
+                "Reason: `Client is not initialized: %s'",
+                identifier, default, self._initialised_failed_reason[True])
+            return default
+
+        try:
+            variation = self._evaluator.evaluate(
+                identifier, target, "int")
+
+            # Only register metrics if analytics is enabled,
+            # and sometimes when the SDK starts up we can
+            # evaluate before the flag is cached which results in
+            # an empty identifier.
+            if self._config.enable_analytics and variation.identifier != "":
+                self._analytics.enqueue(target, identifier, variation)
+
+            return variation.int_or_float(target, identifier, default)
+
+        except FlagKindMismatchException as ex:
+            log.error(
+                "SDKCODE:6001: Failed to evaluate int_or_float variation for "
+                "flag '%s'  and the default variation '%s' is being returned. "
+                "Reason: '%s'", identifier, default, str(ex))
+            return default
+
     def string_variation(self, identifier: str, target: Target,
                          default: str) -> str:
 

featureflags/evaluations/evaluator.py

@@ -38,6 +38,12 @@ class Evaluator(object):
     def __init__(self, provider: QueryInterface):
         self.provider = provider
 
+    def get_kind(self, identifier) -> Optional[str]:
+        fc = self.provider.get_flag(identifier)
+        if not fc:
+            return None
+        return fc.kind
+
     def _find_variation(self, variations: List[Variation],
                         identifier: Optional[str]) -> Variation:
         if not identifier:

featureflags/evaluations/variation.py

@@ -79,6 +79,39 @@ def int(self, target: Target, flag_identifier: str,
             {"target": target, "flag": flag_identifier}, default)
         return default
 
+    def int_or_float(self, target: Target, flag_identifier: str,
+                     default: Union[int, float]) -> Union[int, float]:
+        if self.value:
+            try:
+                result = int(self.value)
+            except ValueError:
+                try:
+                    # If int conversion fails, try converting to float
+                    result = float(self.value)
+                except ValueError:
+                    # If both conversions fail, log an error and return the
+                    # default
+                    log.error(
+                        "SDKCODE:6001: Invalid number format for %s. "
+                        "Expected a number but got '%s'",
+                        {"flag": flag_identifier, "value": self.value}
+                    )
+                    return default
+
+            log.debug(
+                "SDKCODE:6000: Evaluated number variation successfully: %s",
+                {"result": result, "flag identifier": flag_identifier,
+                 "target": target}
+            )
+            return result
+
+        log.error(
+            "SDKCODE:6001: Failed to evaluate int_or_float variation for %s "
+            "and the "
+            "default variation '%s' is being returned",
+            {"target": target, "flag": flag_identifier}, default)
+        return default
+
     def json(self, target: Target, flag_identifier: str,
              default: dict) -> dict:
         if self.value:

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.3.0
+current_version = 1.4.0
 commit = True
 tag = True
 

setup.py

@@ -57,6 +57,6 @@
     test_suite="tests",
     tests_require=test_requirements,
     url="https://github.com/harness/ff-python-server-sdk",
-    version='1.3.0',
+    version='1.4.0',
     zip_safe=False,
 )

tests/unit/test_evaluator.py

@@ -274,3 +274,11 @@ def test_evaluate_flag_on(data_provider, feature, target, true_variation):
     got = evaluator._evaluate_flag(feature, target)
 
     assert got == true_variation
+
+
+def test_get_flag_kind(data_provider, feature, target, true_variation):
+    evaluator = Evaluator(data_provider)
+
+    got = evaluator.get_kind(feature.feature)
+
+    assert got == FeatureConfigKind.BOOLEAN