FeatureManagement 1.0.0__tar.gz → 2.0.0__tar.gz

featuremanagement-2.0.0/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Release History
+
+See [Release Notes](https://github.com/Azure/AppConfiguration/blob/main/releaseNotes/PythonFeatureManagement.md) for the full release history.

{featuremanagement-1.0.0 → featuremanagement-2.0.0/FeatureManagement.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FeatureManagement
-Version: 1.0.0
+Version: 2.0.0
 Summary: A library for enabling/disabling features at runtime.
 Home-page: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/appconfiguration/feature-management
 Author: Microsoft Corporation
@@ -41,9 +41,8 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Provides-Extra: appinsights
-Requires-Dist: azure-monitor-opentelemetry<2.0.0,>=1.3.0; extra == "appinsights"
-Requires-Dist: azure-monitor-events-extension<2.0.0; extra == "appinsights"
+Provides-Extra: azuremonitor
+Requires-Dist: azure-monitor-events-extension<2.0.0; extra == "azuremonitor"
 
 # Microsoft Feature Management for Python
 
@@ -60,6 +59,7 @@ Feature management provides a way to develop and expose application functionalit
 ## Examples
 
 * [Python Application](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_flag_sample.py)
+* [Python Application with Feature Variants](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_variant_sample.py)
 * [Python Application with Azure App Configuration](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_flag_with_azure_app_configuration_sample.py)
 * [Django Application](https://github.com/Azure/AppConfiguration/tree/main/examples/Python/python-django-webapp-sample)
 * [Flask Application](https://github.com/Azure/AppConfiguration/tree/main/examples/Python/python-flask-webapp-sample)

{featuremanagement-1.0.0 → featuremanagement-2.0.0}/FeatureManagement.egg-info/SOURCES.txt

@@ -17,20 +17,30 @@ featuremanagement/__init__.py
 featuremanagement/_defaultfilters.py
 featuremanagement/_featurefilters.py
 featuremanagement/_featuremanager.py
+featuremanagement/_featuremanagerbase.py
 featuremanagement/_version.py
 featuremanagement/py.typed
 featuremanagement/_models/__init__.py
+featuremanagement/_models/_allocation.py
 featuremanagement/_models/_constants.py
 featuremanagement/_models/_evaluation_event.py
 featuremanagement/_models/_feature_conditions.py
 featuremanagement/_models/_feature_flag.py
 featuremanagement/_models/_targeting_context.py
+featuremanagement/_models/_telemetry.py
+featuremanagement/_models/_variant.py
+featuremanagement/_models/_variant_assignment_reason.py
+featuremanagement/_models/_variant_reference.py
 featuremanagement/aio/__init__.py
 featuremanagement/aio/_defaultfilters.py
 featuremanagement/aio/_featurefilters.py
 featuremanagement/aio/_featuremanager.py
+featuremanagement/azuremonitor/__init__.py
+featuremanagement/azuremonitor/_send_telemetry.py
 samples/feature_flag_sample.py
 samples/feature_flag_with_azure_app_configuration_sample.py
+samples/feature_variant_sample.py
+samples/feature_variant_sample_with_telemetry.py
 samples/formatted_feature_flags.json
 samples/random_filter.py
 tests/test_default_feature_flags.py
@@ -38,4 +48,7 @@ tests/test_default_feature_flags_async.py
 tests/test_feature_manager.py
 tests/test_feature_manager_async.py
 tests/test_feature_manager_refresh.py
+tests/test_feature_variants.py
+tests/test_feature_variants_async.py
+tests/test_send_telemetry_appinsights.py
 tests/validation_tests/test_json_validations.py

featuremanagement-2.0.0/FeatureManagement.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[AzureMonitor]
+azure-monitor-events-extension<2.0.0

{featuremanagement-1.0.0/FeatureManagement.egg-info → featuremanagement-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FeatureManagement
-Version: 1.0.0
+Version: 2.0.0
 Summary: A library for enabling/disabling features at runtime.
 Home-page: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/appconfiguration/feature-management
 Author: Microsoft Corporation
@@ -41,9 +41,8 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Provides-Extra: appinsights
-Requires-Dist: azure-monitor-opentelemetry<2.0.0,>=1.3.0; extra == "appinsights"
-Requires-Dist: azure-monitor-events-extension<2.0.0; extra == "appinsights"
+Provides-Extra: azuremonitor
+Requires-Dist: azure-monitor-events-extension<2.0.0; extra == "azuremonitor"
 
 # Microsoft Feature Management for Python
 
@@ -60,6 +59,7 @@ Feature management provides a way to develop and expose application functionalit
 ## Examples
 
 * [Python Application](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_flag_sample.py)
+* [Python Application with Feature Variants](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_variant_sample.py)
 * [Python Application with Azure App Configuration](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_flag_with_azure_app_configuration_sample.py)
 * [Django Application](https://github.com/Azure/AppConfiguration/tree/main/examples/Python/python-django-webapp-sample)
 * [Flask Application](https://github.com/Azure/AppConfiguration/tree/main/examples/Python/python-flask-webapp-sample)

{featuremanagement-1.0.0 → featuremanagement-2.0.0}/README.md

@@ -13,6 +13,7 @@ Feature management provides a way to develop and expose application functionalit
 ## Examples
 
 * [Python Application](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_flag_sample.py)
+* [Python Application with Feature Variants](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_variant_sample.py)
 * [Python Application with Azure App Configuration](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_flag_with_azure_app_configuration_sample.py)
 * [Django Application](https://github.com/Azure/AppConfiguration/tree/main/examples/Python/python-django-webapp-sample)
 * [Flask Application](https://github.com/Azure/AppConfiguration/tree/main/examples/Python/python-flask-webapp-sample)

{featuremanagement-1.0.0 → featuremanagement-2.0.0}/featuremanagement/__init__.py

@@ -6,7 +6,7 @@
 from ._featuremanager import FeatureManager
 from ._featurefilters import FeatureFilter
 from ._defaultfilters import TimeWindowFilter, TargetingFilter
-from ._models import TargetingContext
+from ._models import FeatureFlag, Variant, EvaluationEvent, VariantAssignmentReason, TargetingContext
 
 from ._version import VERSION
 
@@ -16,5 +16,9 @@ __all__ = [
     "TimeWindowFilter",
     "TargetingFilter",
     "FeatureFilter",
+    "FeatureFlag",
+    "Variant",
+    "EvaluationEvent",
+    "VariantAssignmentReason",
     "TargetingContext",
 ]

{featuremanagement-1.0.0 → featuremanagement-2.0.0}/featuremanagement/_defaultfilters.py

@@ -5,10 +5,9 @@
 # -------------------------------------------------------------------------
 import logging
 import hashlib
-
 from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
-
+from typing import cast, List, Mapping, Optional, Dict, Any
 from ._featurefilters import FeatureFilter
 
 FEATURE_FLAG_NAME_KEY = "feature_name"
@@ -45,7 +44,7 @@ class TimeWindowFilter(FeatureFilter):
     Feature Filter that determines if the current time is within the time window.
     """
 
-    def evaluate(self, context, **kwargs):
+    def evaluate(self, context: Mapping[Any, Any], **kwargs: Any) -> bool:
         """
         Determine if the feature flag is enabled for the given context.
 
@@ -75,7 +74,7 @@ class TargetingFilter(FeatureFilter):
     """
 
     @staticmethod
-    def _is_targeted(context_id, rollout_percentage):
+    def _is_targeted(context_id: str, rollout_percentage: int) -> bool:
         """Determine if the user is targeted for the given context"""
         # Always return true if rollout percentage is 100
         if rollout_percentage == 100:
@@ -87,7 +86,9 @@ class TargetingFilter(FeatureFilter):
         percentage = (context_marker / (2**32 - 1)) * 100
         return percentage < rollout_percentage
 
-    def _target_group(self, target_user, target_group, group, feature_flag_name):
+    def _target_group(
+        self, target_user: Optional[str], target_group: str, group: Mapping[str, Any], feature_flag_name: str
+    ) -> bool:
         group_rollout_percentage = group.get(ROLLOUT_PERCENTAGE_KEY, 0)
         if not target_user:
             target_user = ""
@@ -95,7 +96,7 @@ class TargetingFilter(FeatureFilter):
 
         return self._is_targeted(audience_context_id, group_rollout_percentage)
 
-    def evaluate(self, context, **kwargs):
+    def evaluate(self, context: Mapping[Any, Any], **kwargs: Any) -> bool:
         """
         Determine if the feature flag is enabled for the given context.
 
@@ -103,8 +104,11 @@ class TargetingFilter(FeatureFilter):
         :return: True if the user is targeted for the feature flag.
         :rtype: bool
         """
-        target_user = kwargs.get(TARGETED_USER_KEY, None)
-        target_groups = kwargs.get(TARGETED_GROUPS_KEY, [])
+        target_user: Optional[str] = cast(
+            str,
+            kwargs.get(TARGETED_USER_KEY, None),
+        )
+        target_groups: List[str] = cast(List[str], kwargs.get(TARGETED_GROUPS_KEY, []))
 
         if not target_user and not (target_groups and len(target_groups) > 0):
             logging.warning("%s: Name or Groups are required parameters", TargetingFilter.__name__)
@@ -152,11 +156,11 @@ class TargetingFilter(FeatureFilter):
         return self._is_targeted(context_id, default_rollout_percentage)
 
     @staticmethod
-    def _validate(groups, default_rollout_percentage):
+    def _validate(groups: List[Dict[str, Any]], default_rollout_percentage: int) -> None:
         # Validate the audience settings
         if default_rollout_percentage < 0 or default_rollout_percentage > 100:
             raise TargetingException("DefaultRolloutPercentage must be between 0 and 100")
 
         for group in groups:
-            if group.get(ROLLOUT_PERCENTAGE_KEY) < 0 or group.get(ROLLOUT_PERCENTAGE_KEY) > 100:
+            if group.get(ROLLOUT_PERCENTAGE_KEY, 0) < 0 or group.get(ROLLOUT_PERCENTAGE_KEY, 100) > 100:
                 raise TargetingException("RolloutPercentage must be between 0 and 100")

{featuremanagement-1.0.0 → featuremanagement-2.0.0}/featuremanagement/_featurefilters.py

@@ -4,6 +4,7 @@
 # license information.
 # -------------------------------------------------------------------------
 from abc import ABC, abstractmethod
+from typing import Mapping, Callable, Any, Optional
 
 
 class FeatureFilter(ABC):
@@ -11,8 +12,10 @@ class FeatureFilter(ABC):
     Parent class for all feature filters.
     """
 
+    _alias: Optional[str] = None
+
     @abstractmethod
-    def evaluate(self, context, **kwargs):
+    def evaluate(self, context: Mapping[Any, Any], **kwargs: Any) -> bool:
         """
         Determine if the feature flag is enabled for the given context.
 
@@ -20,28 +23,28 @@ class FeatureFilter(ABC):
         """
 
     @property
-    def name(self):
+    def name(self) -> str:
         """
         Get the name of the filter.
 
         :return: Name of the filter, or alias if it exists.
         :rtype: str
         """
-        if hasattr(self, "_alias"):
+        if hasattr(self, "_alias") and self._alias:
             return self._alias
         return self.__class__.__name__
 
     @staticmethod
-    def alias(alias):
+    def alias(alias: str) -> Callable[..., Any]:
         """
         Decorator to set the alias for the filter.
 
         :param str alias: Alias for the filter.
         :return: Decorator.
-        :rtype: callable
+        :rtype: Callable
         """
 
-        def wrapper(cls):
+        def wrapper(cls: "FeatureFilter") -> Any:
             cls._alias = alias  # pylint: disable=protected-access
             return cls
 

featuremanagement-2.0.0/featuremanagement/_featuremanager.py

@@ -0,0 +1,155 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from typing import cast, overload, Any, Optional, Dict, Mapping, List
+from ._defaultfilters import TimeWindowFilter, TargetingFilter
+from ._featurefilters import FeatureFilter
+from ._models import EvaluationEvent, Variant, TargetingContext
+from ._featuremanagerbase import (
+    FeatureManagerBase,
+    PROVIDED_FEATURE_FILTERS,
+    REQUIREMENT_TYPE_ALL,
+    FEATURE_FILTER_NAME,
+)
+
+
+class FeatureManager(FeatureManagerBase):
+    """
+    Feature Manager that determines if a feature flag is enabled for the given context.
+
+    :param Mapping configuration: Configuration object.
+    :keyword list[FeatureFilter] feature_filters: Custom filters to be used for evaluating feature flags.
+    :keyword Callable[EvaluationEvent] on_feature_evaluated: Callback function to be called when a feature flag is
+    evaluated.
+    """
+
+    def __init__(self, configuration: Mapping[str, Any], **kwargs: Any):
+        super().__init__(configuration, **kwargs)
+        self._filters: Dict[str, FeatureFilter] = {}
+        filters = [TimeWindowFilter(), TargetingFilter()] + cast(
+            List[FeatureFilter], kwargs.pop(PROVIDED_FEATURE_FILTERS, [])
+        )
+
+        for feature_filter in filters:
+            if not isinstance(feature_filter, FeatureFilter):
+                raise ValueError("Custom filter must be a subclass of FeatureFilter")
+            self._filters[feature_filter.name] = feature_filter
+
+    @overload  # type: ignore
+    def is_enabled(self, feature_flag_id: str, user_id: str, **kwargs: Any) -> bool:
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :param str feature_flag_id: Name of the feature flag.
+        :param str user_id: User identifier.
+        :return: True if the feature flag is enabled for the given context.
+        :rtype: bool
+        """
+
+    def is_enabled(self, feature_flag_id: str, *args: Any, **kwargs: Any) -> bool:
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :param str feature_flag_id: Name of the feature flag.
+        :return: True if the feature flag is enabled for the given context.
+        :rtype: bool
+        """
+        targeting_context = self._build_targeting_context(args)
+
+        result = self._check_feature(feature_flag_id, targeting_context, **kwargs)
+        if (
+            self._on_feature_evaluated
+            and result.feature
+            and result.feature.telemetry.enabled
+            and callable(self._on_feature_evaluated)
+        ):
+            result.user = targeting_context.user_id
+            self._on_feature_evaluated(result)
+        return result.enabled
+
+    @overload  # type: ignore
+    def get_variant(self, feature_flag_id: str, user_id: str, **kwargs: Any) -> Optional[Variant]:
+        """
+        Determine the variant for the given context.
+
+        :param str feature_flag_id: Name of the feature flag.
+        :param str user_id: User identifier.
+        :return: return: Variant instance.
+        :rtype: Variant
+        """
+
+    def get_variant(self, feature_flag_id: str, *args: Any, **kwargs: Any) -> Optional[Variant]:
+        """
+        Determine the variant for the given context.
+
+        :param str feature_flag_id: Name of the feature flag
+        :keyword TargetingContext targeting_context: Targeting context.
+        :return: Variant instance.
+        :rtype: Variant
+        """
+        targeting_context = self._build_targeting_context(args)
+
+        result = self._check_feature(feature_flag_id, targeting_context, **kwargs)
+        if (
+            self._on_feature_evaluated
+            and result.feature
+            and result.feature.telemetry.enabled
+            and callable(self._on_feature_evaluated)
+        ):
+            result.user = targeting_context.user_id
+            self._on_feature_evaluated(result)
+        return result.variant
+
+    def _check_feature_filters(
+        self, evaluation_event: EvaluationEvent, targeting_context: TargetingContext, **kwargs: Any
+    ) -> None:
+        feature_flag = evaluation_event.feature
+        if not feature_flag:
+            return
+        feature_conditions = feature_flag.conditions
+        feature_filters = feature_conditions.client_filters
+
+        if len(feature_filters) == 0:
+            # Feature flags without any filters return evaluate
+            evaluation_event.enabled = True
+        else:
+            # The assumed value is no filters is based on the requirement type.
+            # Requirement type Any assumes false until proven true, All assumes true until proven false
+            evaluation_event.enabled = feature_conditions.requirement_type == REQUIREMENT_TYPE_ALL
+
+        for feature_filter in feature_filters:
+            filter_name = feature_filter[FEATURE_FILTER_NAME]
+            kwargs["user"] = targeting_context.user_id
+            kwargs["groups"] = targeting_context.groups
+            if filter_name not in self._filters:
+                raise ValueError(f"Feature flag {feature_flag.name} has unknown filter {filter_name}")
+            if feature_conditions.requirement_type == REQUIREMENT_TYPE_ALL:
+                if not self._filters[filter_name].evaluate(feature_filter, **kwargs):
+                    evaluation_event.enabled = False
+                    break
+            elif self._filters[filter_name].evaluate(feature_filter, **kwargs):
+                evaluation_event.enabled = True
+                break
+
+    def _check_feature(
+        self, feature_flag_id: str, targeting_context: TargetingContext, **kwargs: Any
+    ) -> EvaluationEvent:
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :param str feature_flag_id: Name of the feature flag.
+        :param TargetingContext targeting_context: Targeting context.
+        :return: EvaluationEvent for the given context.
+        :rtype: EvaluationEvent
+        """
+        evaluation_event, done = super()._check_feature_base(feature_flag_id)
+
+        if done:
+            return evaluation_event
+
+        self._check_feature_filters(evaluation_event, targeting_context, **kwargs)
+
+        self._assign_allocation(evaluation_event, targeting_context)
+        return evaluation_event