FeatureManagement 1.0.0b1__py3-none-any.whl

FeatureManagement-1.0.0b1.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.0b1.dist-info/METADATA

@@ -0,0 +1,340 @@
+Metadata-Version: 2.1
+Name: FeatureManagement
+Version: 1.0.0b1
+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
+
+Feature Management is a library for enabling/disabling features at runtime. Developers can use feature flags in simple use cases like conditional statement to more advanced scenarios like conditionally adding routes.
+
+## Getting started
+
+### Prerequisites
+
+* Python 3.7 or later is required to use this package.
+
+### Install the package
+
+Install the Python feature management client library for Python with [pip][pip]:
+
+```bash
+pip install microsoft-featuremanagement
+```
+
+## Usage
+
+You can use feature flags from the Azure App Configuration service, a json file, or a dictionary.
+
+### Use feature flags from Azure App Configuration
+
+```python
+from featuremanagement import FeatureManager
+from azure.appconfiguration.provider import load
+from azure.identity import DefaultAzureCredential
+import os
+
+endpoint = os.environ.get("APPCONFIGURATION_ENDPOINT_STRING")
+
+# If no setting selector is set then feature flags with no label are loaded.
+selects = {SettingSelector(key_filter=".appconfig.featureflag*")}
+
+config = load(endpoint=endpoint, credential=DefaultAzureCredential(), selects=selects)
+
+feature_manager = FeatureManager(config)
+
+# Prints the value of the feature flag Alpha
+print("Alpha is ", feature_manager.is_enabled("Alpha"))
+```
+
+### Use feature flags from a json file
+
+A Json file with the following format can be used to load feature flags.
+
+```json
+{
+    "feature_management": {
+        "feature_flags": [
+            {
+                "id": "Alpha",
+                "description": "",
+                "enabled": "true",
+                "conditions": {
+                    "client_filters": []
+                }
+            }
+        ]
+    }
+ }
+```
+
+Load feature flags from a json file.
+
+```python
+from featuremanagement import FeatureManager
+import json
+import os
+import sys
+
+script_directory = os.path.dirname(os.path.abspath(sys.argv[0]))
+
+f = open(script_directory + "/my_json_file.json", "r")
+
+feature_flags = json.load(f)
+
+feature_manager = FeatureManager(feature_flags)
+
+# Returns the value of Alpha, based on the result of the feature filter
+print("Alpha is ", feature_manager.is_enabled("Alpha"))
+```
+
+### Use feature flags from a dictionary
+
+```python
+from featuremanagement import FeatureManager
+
+feature_flags = {
+    "feature_management": {
+        "feature_flags": [
+            {
+                "id": "Alpha",
+                "description": "",
+                "enabled": "true",
+                "conditions": {
+                    "client_filters": []
+                }
+            }
+        ]
+    }
+}
+
+feature_manager = FeatureManager(feature_flags)
+
+# Is always true
+print("Alpha is ", feature_manager.is_enabled("Alpha"))
+```
+
+## Key concepts
+
+### FeatureManager
+
+The `FeatureManager` is the main entry point for using feature flags. It is initialized with a dictionary of feature flags, and optional feature filters. The `FeatureManager` can then be used to check if a feature is enabled or disabled.
+
+### Feature Flags
+
+Feature Flags are objects that define how Feature Management enables/disables a feature. It contains an `id` and `enabled` property. The `id` is a string that uniquely identifies the feature flag. The `enabled` property is a boolean that indicates if the feature flag is enabled or disabled. The `conditions` object contains a property `client_filters` which is a list of `FeatureFilter` objects that are used to determine if the feature flag is enabled or disabled. The Feature Filters only run if the feature flag is enabled.
+
+The full schema for a feature Flag can be found [here](https://github.com/Azure/AppConfiguration/blob/main/docs/FeatureManagement/FeatureFlag.v1.1.0.schema.json).
+
+```javascript
+{
+    "id": "Alpha",
+    "enabled": "true",
+    "conditions": {
+        "client_filters": [
+            {
+                "name": "MyFilter",
+                "parameters": {
+                    ...
+                }
+            }
+        ]
+    }
+}
+```
+
+This object is passed into the `FeatureManager` when it is initialized.
+
+### Feature Filters
+
+Feature filters enable dynamic evaluation of feature flags. The Python feature management library includes two built-in filters:
+
+- `Microsoft.TimeWindow` - Enables a feature flag based on a time window.
+- `Microsoft.Targeting` - Enables a feature flag based on a list of users, groups, or rollout percentages.
+
+#### Time Window Filter
+
+The Time Window Filter enables a feature flag based on a time window. It has two parameters:
+
+- `Start` - The start time of the time window.
+- `End` - The end time of the time window.
+
+```json
+{
+    "name": "Microsoft.TimeWindow",
+    "parameters": {
+        "Start": "2020-01-01T00:00:00Z",
+        "End": "2020-12-31T00:00:00Z"
+    }
+}
+```
+
+Both parameters are optional, but at least one is required. The time window filter is enabled after the start time and before the end time. If the start time is not specified, it is enabled immediately. If the end time is not specified, it will remain enabled after the start time.
+
+#### Targeting Filter
+
+Targeting is a feature management strategy that enables developers to progressively roll out new features to their user base. The strategy is built on the concept of targeting a set of users known as the target audience. An audience is made up of specific users, groups, excluded users/groups, and a designated percentage of the entire user base. The groups that are included in the audience can be broken down further into percentages of their total members.
+
+The following steps demonstrate an example of a progressive rollout for a new 'Beta' feature:
+
+1. Individual users Jeff and Alicia are granted access to the Beta
+1. Another user, Mark, asks to opt-in and is included.
+1. Twenty percent of a group known as "Ring1" users are included in the Beta.
+1. The number of "Ring1" users included in the beta is bumped up to 100 percent.
+1. Five percent of the user base is included in the beta.
+1. The rollout percentage is bumped up to 100 percent and the feature is completely rolled out.
+
+This strategy for rolling out a feature is built in to the library through the included Microsoft.Targeting feature filter.
+
+##### Defining a Targeting Feature Filter
+
+The Targeting Filter provides the capability to enable a feature for a target audience. The filter parameters include an `Audience` object which describes users, groups, excluded users/groups, and a default percentage of the user base that should have access to the feature. The `Audience` object contains the following fields:
+
+- `Users` - A list of users that the feature flag is enabled for.
+- `Groups` - A list of groups that the feature flag is enabled for and a rollout percentage for each group.
+  - `Name` - The name of the group.
+  - `RolloutPercentage` - A percentage value that the feature flag is enabled for in the given group.
+- `DefaultRolloutPercentage` - A percentage value that the feature flag is enabled for.
+- `Exclusion` - An object that contains a list of users and groups that the feature flag is disabled for.
+  - `Users` - A list of users that the feature flag is disabled for.
+  - `Groups` - A list of groups that the feature flag is disabled for.
+
+```json
+{
+    "name": "Microsoft.Targeting",
+    "parameters": {
+        "Audience": {
+            "Users": ["user1", "user2"],
+            "Groups": [
+                {
+                    "Name": "group1",
+                    "RolloutPercentage": 100
+                }
+            ],
+            "DefaultRolloutPercentage": 50,
+            "Exclusion": {
+                "Users": ["user3"],
+                "Groups": ["group2"]
+            }
+        }
+    }
+}
+```
+
+##### Using Targeting Feature Filter
+
+You can provide the current user info through `kwargs` when calling `isEnabled`.
+
+```python
+from featuremanagement import FeatureManager, TargetingContext
+
+# Returns true, because user1 is in the Users list
+feature_manager.is_enabled("Beta", TargetingContext(user_id="user1", groups=["group1"]))
+
+# Returns false, because group2 is in the Exclusion.Groups list
+feature_manager.is_enabled("Beta", TargetingContext(user_id="user1", groups=["group2"]))
+
+# Has a 50% chance of returning true, but will be conisistent for the same user
+feature_manager.is_enabled("Beta", TargetingContext(user_id="user4"))
+```
+
+#### Custom Filters
+
+You can also create your own feature filters by implementing the `FeatureFilter` interface.
+
+```python
+class MyCustomFilter(FeatureFilter):
+
+    def evaluate(self, context, **kwargs):
+        ...
+        return True
+```
+
+They can then be passed into the `FeatureManager` when it is initialized. By default, the name of a feature filter is the name of the class. You can override this by setting a class attribute `alias` to the modified class name.
+
+```python
+
+feature_manager = FeatureManager(feature_flags, feature_filters={MyCustomFilter(), MyOtherFilter()})
+```
+
+The `evaluate` method is called when checking if a feature flag is enabled. The `context` parameter contains information about the feature filter from the `parameters` field of the feature filter. Any additional parameters can be passed in as keyword arguments when calling `is_enabled`.
+
+```javascript
+{
+    "name": "CustomFilter",
+    "parameters": {
+        ...
+    }
+}
+```
+
+You can modify the name of a feature flag by using the `@FeatureFilter.alias` decorator. The alias overrides the name of the feature filter and needs to match the name of the feature filter in the feature flag json.
+
+```python
+@FeatureFilter.alias("AliasFilter")
+class MyCustomFilter(FeatureFilter):
+    ...
+```
+
+## 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.0b1.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=IZPHLteR881KNqqgCCcB8hknN83UrwORIDn87-TUlAU,329
+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.0b1.dist-info/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+FeatureManagement-1.0.0b1.dist-info/METADATA,sha256=VgiORco0Cy1rLDejYXQQ1kPIO8Rs2kGh-9IKOqns9n8,13556
+FeatureManagement-1.0.0b1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+FeatureManagement-1.0.0b1.dist-info/top_level.txt,sha256=S0iNu3dPTzNkYFDt3OHOEQXs-gQf1cQaw4Usl7kgPdI,18
+FeatureManagement-1.0.0b1.dist-info/RECORD,,

FeatureManagement-1.0.0b1.dist-info/WHEEL

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

FeatureManagement-1.0.0b1.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.0b1"

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)