FeatureManagement 1.0.0__py3-none-any.whl

FeatureManagement-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

FeatureManagement-1.0.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: FeatureManagement
+Version: 1.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
+Author-email: Microsoft Corporation <appconfig@microsoft.com>
+License: MIT License
+        
+            Copyright (c) Microsoft Corporation.
+        
+            Permission is hereby granted, free of charge, to any person obtaining a copy
+            of this software and associated documentation files (the "Software"), to deal
+            in the Software without restriction, including without limitation the rights
+            to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+            copies of the Software, and to permit persons to whom the Software is
+            furnished to do so, subject to the following conditions:
+        
+            The above copyright notice and this permission notice shall be included in all
+            copies or substantial portions of the Software.
+        
+            THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+            IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+            FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+            AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+            LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+            OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+            SOFTWARE
+        
+Project-URL: Homepage, https://github.com/microsoft/FeatureManagement-Python
+Project-URL: Issues, https://github.com/microsoft/FeatureManagement-Python/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+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: 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'
+
+# Microsoft Feature Management for Python
+
+[![FeatureManagement](https://img.shields.io/pypi/v/FeatureManagement?label=FeatureManagement)](https://pypi.org/project/FeatureManagement/)
+
+Feature management provides a way to develop and expose application functionality based on features. Many applications have special requirements when a new feature is developed such as when the feature should be enabled and under what conditions. This library provides a way to define these relationships, and also integrates into common Python code patterns to make exposing these features possible.
+
+## Get Started
+
+[Quickstart](https://learn.microsoft.com/azure/azure-app-configuration/quickstart-feature-flag-python): A quickstart guide is available to learn how to integrate feature flags from Azure App Configuration into your Python applications.
+
+[API Reference](https://microsoft.github.io/FeatureManagement-Python/): This API reference details the API surface of the libraries contained within this repository.
+
+## Examples
+
+* [Python Application](https://github.com/microsoft/FeatureManagement-Python/blob/main/samples/feature_flag_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)
+
+## Contributing
+
+This project welcomes contributions and suggestions.  Most contributions require you to agree to a
+Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
+the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
+
+When you submit a pull request, a CLA bot will automatically determine whether you need to provide
+a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
+provided by the bot. You will only need to do this once across all repos using our CLA.
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
+contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+## Trademarks
+
+This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft 
+trademarks or logos is subject to and must follow 
+[Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+Any use of third-party trademarks or logos are subject to those third-party's policies.

FeatureManagement-1.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+featuremanagement/__init__.py,sha256=h5PFIFzLm68Gt_KDtJeTgdh88XwrOUZvV5v9Clpd8qM,678
+featuremanagement/_defaultfilters.py,sha256=NAc85ckoD3gfnl4SXvRZNQ9gN6iIPwOz4vJX_PHJv9M,6121
+featuremanagement/_featurefilters.py,sha256=xuvXzw4p6ECkHavDpnnvedJhvGLhTHtEWK4kdwKhM_M,1294
+featuremanagement/_featuremanager.py,sha256=uDMbl2w0SSt7isBRnY0P0ScaMXzqC86D5yl-CZQX40E,7661
+featuremanagement/_version.py,sha256=ArUlT5NPQY8GDMm3itZPB_sXzGtCLRvso3E0KoXHegA,327
+featuremanagement/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featuremanagement/_models/__init__.py,sha256=S-xzmIgVGw7GO1lZGob8h_9WBXpXFNg98kJypZ8uSbk,591
+featuremanagement/_models/_constants.py,sha256=puNDkZHUoB2eCOQ4CeP4LL9xwogPdIP9uRAmTpOSM9c,621
+featuremanagement/_models/_evaluation_event.py,sha256=p2OGowvhY5cSHs6LhpsziOAtztn29Z5EwGWg1OECtDg,713
+featuremanagement/_models/_feature_conditions.py,sha256=hNEslIhv1Zdiue4mXhuLZNg0uQdw5deyhoFAgCcgxX0,2482
+featuremanagement/_models/_feature_flag.py,sha256=JC4AW7BsL17YELJ4cVZSRjnYJPFODOGqKgBmg10Ik0I,3139
+featuremanagement/_models/_targeting_context.py,sha256=pD8yc7dO94WcC0TKW_Z3pGoMuDEv8hygXVlVd6lrpFI,626
+featuremanagement/aio/__init__.py,sha256=-7pTXT_eszJr2Mc34lTS1ICuI67xZ9lDpZ0C01uKbCY,544
+featuremanagement/aio/_defaultfilters.py,sha256=QCrwlzH0738o2nTDmj8XXPgcCrAmxHM8HB11qVJqawA,1732
+featuremanagement/aio/_featurefilters.py,sha256=eF7JXO9Sdxu8rIZivOyWQIc8NDaK-FBGMTEOvQcwqAo,1305
+featuremanagement/aio/_featuremanager.py,sha256=i2LyqTByT5FRGq_3txuondUKufp6g3KQC6H4Pan7oOQ,6141
+FeatureManagement-1.0.0.dist-info/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+FeatureManagement-1.0.0.dist-info/METADATA,sha256=LUag-0GF-s5EcxR1fUqKZ6-ArJxqGWDwdIPDSk-KptE,5543
+FeatureManagement-1.0.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+FeatureManagement-1.0.0.dist-info/top_level.txt,sha256=S0iNu3dPTzNkYFDt3OHOEQXs-gQf1cQaw4Usl7kgPdI,18
+FeatureManagement-1.0.0.dist-info/RECORD,,

FeatureManagement-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.1.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

FeatureManagement-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+featuremanagement

featuremanagement/__init__.py

@@ -0,0 +1,20 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from ._featuremanager import FeatureManager
+from ._featurefilters import FeatureFilter
+from ._defaultfilters import TimeWindowFilter, TargetingFilter
+from ._models import TargetingContext
+
+from ._version import VERSION
+
+__version__ = VERSION
+__all__ = [
+    "FeatureManager",
+    "TimeWindowFilter",
+    "TargetingFilter",
+    "FeatureFilter",
+    "TargetingContext",
+]

featuremanagement/_defaultfilters.py

@@ -0,0 +1,162 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+import logging
+import hashlib
+
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+
+from ._featurefilters import FeatureFilter
+
+FEATURE_FLAG_NAME_KEY = "feature_name"
+ROLLOUT_PERCENTAGE_KEY = "RolloutPercentage"
+DEFAULT_ROLLOUT_PERCENTAGE_KEY = "DefaultRolloutPercentage"
+PARAMETERS_KEY = "parameters"
+
+# Time Window Constants
+START_KEY = "Start"
+END_KEY = "End"
+
+# Targeting kwargs
+TARGETED_USER_KEY = "user"
+TARGETED_GROUPS_KEY = "groups"
+
+# Targeting Constants
+AUDIENCE_KEY = "Audience"
+USERS_KEY = "Users"
+GROUPS_KEY = "Groups"
+EXCLUSION_KEY = "Exclusion"
+FEATURE_FILTER_NAME_KEY = "Name"
+IGNORE_CASE_KEY = "ignore_case"
+
+
+class TargetingException(Exception):
+    """
+    Exception raised when the targeting filter is not configured correctly.
+    """
+
+
+@FeatureFilter.alias("Microsoft.TimeWindow")
+class TimeWindowFilter(FeatureFilter):
+    """
+    Feature Filter that determines if the current time is within the time window.
+    """
+
+    def evaluate(self, context, **kwargs):
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :keyword Mapping context: Mapping with the Start and End time for the feature flag.
+        :return: True if the current time is within the time window.
+        :rtype: bool
+        """
+        start = context.get(PARAMETERS_KEY, {}).get(START_KEY)
+        end = context.get(PARAMETERS_KEY, {}).get(END_KEY)
+
+        current_time = datetime.now(timezone.utc)
+
+        if not start and not end:
+            logging.warning("%s: At least one of Start or End is required.", TimeWindowFilter.__name__)
+            return False
+
+        start_time = parsedate_to_datetime(start) if start else None
+        end_time = parsedate_to_datetime(end) if end else None
+
+        return (start_time is None or start_time <= current_time) and (end_time is None or current_time < end_time)
+
+
+@FeatureFilter.alias("Microsoft.Targeting")
+class TargetingFilter(FeatureFilter):
+    """
+    Feature Filter that determines if the user is targeted for the feature flag.
+    """
+
+    @staticmethod
+    def _is_targeted(context_id, rollout_percentage):
+        """Determine if the user is targeted for the given context"""
+        # Always return true if rollout percentage is 100
+        if rollout_percentage == 100:
+            return True
+
+        hashed_context_id = hashlib.sha256(context_id.encode()).digest()
+        context_marker = int.from_bytes(hashed_context_id[:4], byteorder="little", signed=False)
+
+        percentage = (context_marker / (2**32 - 1)) * 100
+        return percentage < rollout_percentage
+
+    def _target_group(self, target_user, target_group, group, feature_flag_name):
+        group_rollout_percentage = group.get(ROLLOUT_PERCENTAGE_KEY, 0)
+        if not target_user:
+            target_user = ""
+        audience_context_id = target_user + "\n" + feature_flag_name + "\n" + target_group
+
+        return self._is_targeted(audience_context_id, group_rollout_percentage)
+
+    def evaluate(self, context, **kwargs):
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :keyword Mapping context: Context for evaluating the user/group.
+        :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, [])
+
+        if not target_user and not (target_groups and len(target_groups) > 0):
+            logging.warning("%s: Name or Groups are required parameters", TargetingFilter.__name__)
+            return False
+
+        audience = context.get(PARAMETERS_KEY, {}).get(AUDIENCE_KEY, None)
+        feature_flag_name = context.get(FEATURE_FLAG_NAME_KEY, None)
+
+        if not audience:
+            raise TargetingException("Audience is required for " + TargetingFilter.__name__)
+
+        groups = audience.get(GROUPS_KEY, [])
+        default_rollout_percentage = audience.get(DEFAULT_ROLLOUT_PERCENTAGE_KEY, 0)
+
+        self._validate(groups, default_rollout_percentage)
+
+        # Check if the user is excluded
+        if target_user in audience.get(EXCLUSION_KEY, {}).get(USERS_KEY, []):
+            return False
+
+        # Check if the user is in an excluded group
+        for group in audience.get(EXCLUSION_KEY, {}).get(GROUPS_KEY, []):
+            if group in target_groups:
+                return False
+
+        # Check if the user is targeted
+        if target_user in audience.get(USERS_KEY, []):
+            return True
+
+        # Check if the user is in a targeted group
+        for group in groups:
+            for target_group in target_groups:
+                group_name = group.get(FEATURE_FILTER_NAME_KEY, "")
+                if kwargs.get(IGNORE_CASE_KEY, False):
+                    target_group = target_group.lower()
+                    group_name = group_name.lower()
+                if group_name == target_group:
+                    if self._target_group(target_user, target_group, group, feature_flag_name):
+                        return True
+
+        if not target_user:
+            target_user = ""
+        # Check if the user is in the default rollout
+        context_id = target_user + "\n" + feature_flag_name
+        return self._is_targeted(context_id, default_rollout_percentage)
+
+    @staticmethod
+    def _validate(groups, default_rollout_percentage):
+        # 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:
+                raise TargetingException("RolloutPercentage must be between 0 and 100")

featuremanagement/_featurefilters.py

@@ -0,0 +1,48 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from abc import ABC, abstractmethod
+
+
+class FeatureFilter(ABC):
+    """
+    Parent class for all feature filters.
+    """
+
+    @abstractmethod
+    def evaluate(self, context, **kwargs):
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :param Mapping context: Context for the feature flag.
+        """
+
+    @property
+    def name(self):
+        """
+        Get the name of the filter.
+
+        :return: Name of the filter, or alias if it exists.
+        :rtype: str
+        """
+        if hasattr(self, "_alias"):
+            return self._alias
+        return self.__class__.__name__
+
+    @staticmethod
+    def alias(alias):
+        """
+        Decorator to set the alias for the filter.
+
+        :param str alias: Alias for the filter.
+        :return: Decorator.
+        :rtype: callable
+        """
+
+        def wrapper(cls):
+            cls._alias = alias  # pylint: disable=protected-access
+            return cls
+
+        return wrapper

featuremanagement/_featuremanager.py

@@ -0,0 +1,190 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+import logging
+from collections.abc import Mapping
+from typing import overload
+from ._defaultfilters import TimeWindowFilter, TargetingFilter
+from ._featurefilters import FeatureFilter
+from ._models import FeatureFlag, EvaluationEvent, TargetingContext
+
+
+FEATURE_MANAGEMENT_KEY = "feature_management"
+FEATURE_FLAG_KEY = "feature_flags"
+
+PROVIDED_FEATURE_FILTERS = "feature_filters"
+FEATURE_FILTER_NAME = "name"
+REQUIREMENT_TYPE_ALL = "All"
+REQUIREMENT_TYPE_ANY = "Any"
+
+FEATURE_FILTER_PARAMETERS = "parameters"
+
+
+def _get_feature_flag(configuration, feature_flag_name):
+    """
+    Gets the FeatureFlag json from the configuration, if it exists it gets converted to a FeatureFlag object.
+
+    :param Mapping configuration: Configuration object.
+    :param str feature_flag_name: Name of the feature flag.
+    :return: FeatureFlag
+    :rtype: FeatureFlag
+    """
+    feature_management = configuration.get(FEATURE_MANAGEMENT_KEY)
+    if not feature_management or not isinstance(feature_management, Mapping):
+        return None
+    feature_flags = feature_management.get(FEATURE_FLAG_KEY)
+    if not feature_flags or not isinstance(feature_flags, list):
+        return None
+
+    for feature_flag in feature_flags:
+        if feature_flag.get("id") == feature_flag_name:
+            return FeatureFlag.convert_from_json(feature_flag)
+
+    return None
+
+
+def _list_feature_flag_names(configuration):
+    """
+    List of all feature flag names.
+
+    :param Mapping configuration: Configuration object.
+    :return: List of feature flag names.
+    """
+    feature_flag_names = []
+    feature_management = configuration.get(FEATURE_MANAGEMENT_KEY)
+    if not feature_management or not isinstance(feature_management, Mapping):
+        return []
+    feature_flags = feature_management.get(FEATURE_FLAG_KEY)
+    if not feature_flags or not isinstance(feature_flags, list):
+        return []
+
+    for feature_flag in feature_flags:
+        feature_flag_names.append(feature_flag.get("id"))
+
+    return feature_flag_names
+
+
+class FeatureManager:
+    """
+    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.
+    """
+
+    def __init__(self, configuration, **kwargs):
+        self._filters = {}
+        if configuration is None or not isinstance(configuration, Mapping):
+            raise AttributeError("Configuration must be a non-empty dictionary")
+        self._configuration = configuration
+        self._cache = {}
+        self._copy = configuration.get(FEATURE_MANAGEMENT_KEY)
+        filters = [TimeWindowFilter(), TargetingFilter()] + 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
+
+    def _build_targeting_context(self, args):
+        """
+        Builds a TargetingContext, either returns a provided context, takes the provided user_id to make a context, or
+        returns an empty context.
+
+        :param args: Arguments to build the TargetingContext.
+        :return: TargetingContext
+        """
+        if len(args) == 1 and isinstance(args[0], str):
+            return TargetingContext(user_id=args[0], groups=[])
+        if len(args) == 1 and isinstance(args[0], TargetingContext):
+            return args[0]
+        return TargetingContext()
+
+    @overload
+    def is_enabled(self, feature_flag_id, user_id, **kwargs):
+        """
+        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, *args, **kwargs):
+        """
+        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)
+        return result.enabled
+
+    def _check_feature_filters(self, feature_flag, targeting_context, **kwargs):
+        feature_conditions = feature_flag.conditions
+        feature_filters = feature_conditions.client_filters
+        evaluation_event = EvaluationEvent(enabled=False)
+
+        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
+        return evaluation_event
+
+    def _check_feature(self, feature_flag_id, targeting_context, **kwargs):
+        """
+        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
+        """
+        if self._copy is not self._configuration.get(FEATURE_MANAGEMENT_KEY):
+            self._cache = {}
+            self._copy = self._configuration.get(FEATURE_MANAGEMENT_KEY)
+
+        if not self._cache.get(feature_flag_id):
+            feature_flag = _get_feature_flag(self._configuration, feature_flag_id)
+            self._cache[feature_flag_id] = feature_flag
+        else:
+            feature_flag = self._cache.get(feature_flag_id)
+
+        if not feature_flag:
+            logging.warning("Feature flag %s not found", feature_flag_id)
+            # Unknown feature flags are disabled by default
+            return EvaluationEvent(enabled=False)
+
+        if not feature_flag.enabled:
+            # Feature flags that are disabled are always disabled
+            return EvaluationEvent(enabled=False)
+
+        return self._check_feature_filters(feature_flag, targeting_context, **kwargs)
+
+    def list_feature_flag_names(self):
+        """
+        List of all feature flag names.
+        """
+        return _list_feature_flag_names(self._configuration)

featuremanagement/_models/__init__.py

@@ -0,0 +1,12 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from ._feature_flag import FeatureFlag
+from ._evaluation_event import EvaluationEvent
+from ._targeting_context import TargetingContext
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore
+
+__all__ = ["FeatureFlag", "EvaluationEvent", "TargetingContext"]

featuremanagement/_models/_constants.py

@@ -0,0 +1,18 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+
+# Feature Flag
+FEATURE_FLAG_ID = "id"
+FEATURE_FLAG_ENABLED = "enabled"
+FEATURE_FLAG_CONDITIONS = "conditions"
+
+
+# Conditions
+FEATURE_FILTER_REQUIREMENT_TYPE = "requirement_type"
+REQUIREMENT_TYPE_ALL = "All"
+REQUIREMENT_TYPE_ANY = "Any"
+FEATURE_FLAG_CLIENT_FILTERS = "client_filters"
+FEATURE_FILTER_NAME = "name"

featuremanagement/_models/_evaluation_event.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from dataclasses import dataclass
+
+
+@dataclass
+class EvaluationEvent:
+    """
+    Represents a feature flag evaluation event.
+    """
+
+    def __init__(self, *, enabled=False, feature_flag=None):
+        """
+        Initialize the EvaluationEvent.
+        """
+        self.feature = feature_flag
+        self.user = ""
+        self.enabled = enabled
+        self.variant = None
+        self.reason = None

featuremanagement/_models/_feature_conditions.py

@@ -0,0 +1,70 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from collections.abc import Mapping
+from ._constants import (
+    FEATURE_FLAG_CLIENT_FILTERS,
+    FEATURE_FILTER_NAME,
+    FEATURE_FILTER_REQUIREMENT_TYPE,
+    REQUIREMENT_TYPE_ALL,
+    REQUIREMENT_TYPE_ANY,
+)
+
+
+class FeatureConditions:
+    """
+    Represents the conditions for a feature flag.
+    """
+
+    def __init__(self):
+        self._requirement_type = REQUIREMENT_TYPE_ANY
+        self._client_filters = []
+
+    @classmethod
+    def convert_from_json(cls, feature_name, json_value):
+        """
+        Convert a JSON object to FeatureConditions.
+
+        :param dict json: JSON object.
+        :return: FeatureConditions.
+        :rtype: FeatureConditions
+        """
+        conditions = cls()
+        if json_value is not None and not isinstance(json_value, Mapping):
+            raise AttributeError("Feature flag conditions must be a dictionary")
+        conditions._requirement_type = json_value.get(FEATURE_FILTER_REQUIREMENT_TYPE, REQUIREMENT_TYPE_ANY)
+        conditions._client_filters = json_value.get(FEATURE_FLAG_CLIENT_FILTERS, [])
+        if not isinstance(conditions._client_filters, list):
+            conditions._client_filters = []
+        for feature_filter in conditions._client_filters:
+            feature_filter["feature_name"] = feature_name
+        return conditions
+
+    @property
+    def requirement_type(self):
+        """
+        Get the requirement type for the feature flag.
+
+        :return: Requirement type.
+        :rtype: str
+        """
+        return self._requirement_type
+
+    @property
+    def client_filters(self):
+        """
+        Get the client filters for the feature flag.
+
+        :return: Client filters.
+        :rtype: list[dict]
+        """
+        return self._client_filters
+
+    def _validate(self, feature_flag_id):
+        if self._requirement_type not in [REQUIREMENT_TYPE_ALL, REQUIREMENT_TYPE_ANY]:
+            raise ValueError(f"Feature flag {feature_flag_id} has invalid requirement type.")
+        for feature_filter in self._client_filters:
+            if feature_filter.get(FEATURE_FILTER_NAME) is None:
+                raise ValueError(f"Feature flag {feature_flag_id} is missing filter name.")

featuremanagement/_models/_feature_flag.py

@@ -0,0 +1,102 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from ._feature_conditions import FeatureConditions
+from ._constants import (
+    FEATURE_FLAG_ID,
+    FEATURE_FLAG_ENABLED,
+    FEATURE_FLAG_CONDITIONS,
+)
+
+
+class FeatureFlag:
+    """
+    Represents a feature flag.
+    """
+
+    def __init__(self):
+        self._id = None
+        self._enabled = False
+        self._conditions = FeatureConditions()
+
+    @classmethod
+    def convert_from_json(cls, json_value):
+        """
+        Convert a JSON object to FeatureFlag.
+
+        :param dict json_value: JSON object
+        :return: FeatureFlag.
+        :rtype: FeatureFlag
+        """
+        feature_flag = cls()
+        if not isinstance(json_value, dict):
+            raise ValueError("Feature flag must be a dictionary.")
+        feature_flag._id = json_value.get(FEATURE_FLAG_ID)
+        feature_flag._enabled = _convert_boolean_value(json_value.get(FEATURE_FLAG_ENABLED, False))
+        feature_flag._conditions = FeatureConditions.convert_from_json(
+            feature_flag._id, json_value.get(FEATURE_FLAG_CONDITIONS, {})
+        )
+        if FEATURE_FLAG_CONDITIONS in json_value:
+            feature_flag._conditions = FeatureConditions.convert_from_json(
+                feature_flag._id, json_value.get(FEATURE_FLAG_CONDITIONS, {})
+            )
+        else:
+            feature_flag._conditions = FeatureConditions()
+        feature_flag._validate()
+        return feature_flag
+
+    @property
+    def name(self):
+        """
+        Get the name of the feature flag.
+
+        :return: Name of the feature flag.
+        :rtype: str
+        """
+        return self._id
+
+    @property
+    def enabled(self):
+        """
+        Get the status of the feature flag.
+
+        :return: Status of the feature flag.
+        :rtype: bool
+        """
+        return self._enabled
+
+    @property
+    def conditions(self):
+        """
+        Get the conditions for the feature flag.
+
+        :return: Conditions for the feature flag.
+        :rtype: FeatureConditions
+        """
+        return self._conditions
+
+    def _validate(self):
+        if not isinstance(self._id, str):
+            raise ValueError(f"Invalid setting 'id' with value '{self._id}' for feature '{self._id}'.")
+        if not isinstance(self._enabled, bool):
+            raise ValueError(f"Invalid setting 'enabled' with value '{self._enabled}' for feature '{self._id}'.")
+        self.conditions._validate(self._id)  # pylint: disable=protected-access
+
+
+def _convert_boolean_value(enabled):
+    """
+    Convert the value to a boolean if it is a string.
+
+    :param Union[str, bool] enabled: Value to be converted.
+    :return: Converted value.
+    :rtype: bool
+    """
+    if isinstance(enabled, bool):
+        return enabled
+    if enabled.lower() == "true":
+        return True
+    if enabled.lower() == "false":
+        return False
+    return enabled

featuremanagement/_models/_targeting_context.py

@@ -0,0 +1,27 @@
+# -------------------------------------------------------------------------
+# 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 NamedTuple, List
+
+
+class TargetingContext(NamedTuple):
+    """
+    Represents the context for targeting a feature flag.
+    """
+
+    user_id: str = ""
+    """
+    The user ID.
+    
+    :type: str
+    """
+
+    groups: List[str] = []
+    """
+    The users groups.
+    
+    :type: List[str]
+    """

featuremanagement/_version.py

@@ -0,0 +1,7 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+
+VERSION = "1.0.0"

featuremanagement/aio/__init__.py

@@ -0,0 +1,10 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from ._featuremanager import FeatureManager
+from ._featurefilters import FeatureFilter
+from ._defaultfilters import TimeWindowFilter, TargetingFilter
+
+__all__ = ["FeatureManager", "TimeWindowFilter", "TargetingFilter", "FeatureFilter"]

featuremanagement/aio/_defaultfilters.py

@@ -0,0 +1,51 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+
+from ._featurefilters import FeatureFilter
+from .._defaultfilters import (
+    TargetingFilter as SyncTargetingFilter,
+    TimeWindowFilter as SyncTimeWindowFilter,
+)
+
+
+@FeatureFilter.alias("Microsoft.TimeWindow")
+class TimeWindowFilter(FeatureFilter):
+    """
+    Feature Filter that determines if the current time is within the time window.
+    """
+
+    def __init__(self):
+        self._filter = SyncTimeWindowFilter()
+
+    async def evaluate(self, context, **kwargs):
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :keyword Mapping context: Mapping with the Start and End time for the feature flag.
+        :return: True if the current time is within the time window.
+        :rtype: bool
+        """
+        return self._filter.evaluate(context, **kwargs)
+
+
+@FeatureFilter.alias("Microsoft.Targeting")
+class TargetingFilter(FeatureFilter):
+    """
+    Feature Filter that determines if the user is targeted for the feature flag.
+    """
+
+    def __init__(self):
+        self._filter = SyncTargetingFilter()
+
+    async def evaluate(self, context, **kwargs):
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :keyword Mapping context: Context for evaluating the user/group.
+        :return: True if the user is targeted for the feature flag.
+        :rtype: bool
+        """
+        return self._filter.evaluate(context, **kwargs)

featuremanagement/aio/_featurefilters.py

@@ -0,0 +1,48 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from abc import ABC, abstractmethod
+
+
+class FeatureFilter(ABC):
+    """
+    Parent class for all async feature filters.
+    """
+
+    @abstractmethod
+    async def evaluate(self, context, **kwargs):
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :param Mapping context: Context for the feature flag.
+        """
+
+    @property
+    def name(self):
+        """
+        Get the name of the filter.
+
+        :return: Name of the filter, or alias if it exists.
+        :rtype: str
+        """
+        if hasattr(self, "_alias"):
+            return self._alias
+        return self.__class__.__name__
+
+    @staticmethod
+    def alias(alias):
+        """
+        Decorator to set the alias for the filter.
+
+        :param str alias: Alias for the filter.
+        :return: Decorator
+        :rtype: callable
+        """
+
+        def wrapper(cls):
+            cls._alias = alias  # pylint: disable=protected-access
+            return cls
+
+        return wrapper

featuremanagement/aio/_featuremanager.py

@@ -0,0 +1,142 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from collections.abc import Mapping
+import logging
+from typing import overload
+from ._defaultfilters import TimeWindowFilter, TargetingFilter
+from ._featurefilters import FeatureFilter
+from .._featuremanager import (
+    PROVIDED_FEATURE_FILTERS,
+    FEATURE_FILTER_NAME,
+    REQUIREMENT_TYPE_ALL,
+    FEATURE_MANAGEMENT_KEY,
+    _get_feature_flag,
+    _list_feature_flag_names,
+)
+from .._models import EvaluationEvent, TargetingContext
+
+
+class FeatureManager:
+    """
+    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.
+    """
+
+    def __init__(self, configuration, **kwargs):
+        self._filters = {}
+        if configuration is None or not isinstance(configuration, Mapping):
+            raise AttributeError("Configuration must be a non-empty dictionary")
+        self._configuration = configuration
+        self._cache = {}
+        self._copy = configuration.get(FEATURE_MANAGEMENT_KEY)
+        filters = [TimeWindowFilter(), TargetingFilter()] + 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
+
+    def _build_targeting_context(self, args):
+        """
+        Builds a TargetingContext, either returns a provided context, takes the provided user_id to make a context, or
+        returns an empty context.
+
+        :param args: Arguments to build the TargetingContext.
+        :return: TargetingContext
+        """
+        if len(args) == 1 and isinstance(args[0], str):
+            return TargetingContext(user_id=args[0], groups=[])
+        if len(args) == 1 and isinstance(args[0], TargetingContext):
+            return args[0]
+        return TargetingContext()
+
+    @overload
+    async def is_enabled(self, feature_flag_id, user_id, **kwargs):
+        """
+        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
+        """
+
+    async def is_enabled(self, feature_flag_id, *args, **kwargs):
+        """
+        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)
+        return (await self._check_feature(feature_flag_id, targeting_context, **kwargs)).enabled
+
+    async def _check_feature_filters(self, feature_flag, targeting_context, **kwargs):
+        feature_conditions = feature_flag.conditions
+        feature_filters = feature_conditions.client_filters
+        evaluation_event = EvaluationEvent(enabled=False)
+
+        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 await self._filters[filter_name].evaluate(feature_filter, **kwargs):
+                    evaluation_event.enabled = False
+                    break
+            else:
+                if await self._filters[filter_name].evaluate(feature_filter, **kwargs):
+                    evaluation_event.enabled = True
+                    break
+        return evaluation_event
+
+    async def _check_feature(self, feature_flag_id, targeting_context, **kwargs):
+        """
+        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
+        """
+        if self._copy is not self._configuration.get(FEATURE_MANAGEMENT_KEY):
+            self._cache = {}
+            self._copy = self._configuration.get(FEATURE_MANAGEMENT_KEY)
+
+        if not self._cache.get(feature_flag_id):
+            feature_flag = _get_feature_flag(self._configuration, feature_flag_id)
+            self._cache[feature_flag_id] = feature_flag
+        else:
+            feature_flag = self._cache.get(feature_flag_id)
+
+        if not feature_flag:
+            logging.warning("Feature flag %s not found", feature_flag_id)
+            # Unknown feature flags are disabled by default
+            return EvaluationEvent(enabled=False)
+
+        if not feature_flag.enabled:
+            # Feature flags that are disabled are always disabled
+            return EvaluationEvent(enabled=False)
+
+        return await self._check_feature_filters(feature_flag, targeting_context, **kwargs)
+
+    def list_feature_flag_names(self):
+        """
+        List of all feature flag names.
+        """
+        return _list_feature_flag_names(self._configuration)