Merge branch 'main' into gh-pages

Author: mrm9084

.github/workflows/validate.yml

@@ -0,0 +1,29 @@
+name: Validate
+
+on: [pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r dev_requirements.txt
+        pip install .
+    - name: Analysing the code/samples with pylint
+      run: |
+        pylint featuremanagement
+        pylint --disable=missing-function-docstring,missing-class-docstring samples tests
+    - uses: psf/black@stable
+    - name: Test with pytest
+      run: |
+        pytest tests --doctest-modules --cov-report=xml --cov-report=html

README.md

@@ -220,14 +220,16 @@ The Targeting Filter provides the capability to enable a feature for a target au
 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", user="user1", groups=["group1"])
+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", user="user1", groups=["group2"])
+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", user="user4")
+feature_manager.is_enabled("Beta", TargetingContext(user_id="user4"))
 ```
 
 #### Custom Filters

dev_requirements.txt

@@ -1,8 +1,10 @@
 pytest
+pytest-cov
 pytest-asyncio
 black
 pylint
 mypy
 sphinx
 sphinx_rtd_theme
-myst_parser
+myst_parser
+azure-appconfiguration-provider

featuremanagement/__init__.py

@@ -6,8 +6,15 @@
 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"]
+__all__ = [
+    "FeatureManager",
+    "TimeWindowFilter",
+    "TargetingFilter",
+    "FeatureFilter",
+    "TargetingContext",
+]

featuremanagement/_defaultfilters.py

@@ -11,7 +11,7 @@
 
 from ._featurefilters import FeatureFilter
 
-FEATURE_FLAG_NAME_KEY = "name"
+FEATURE_FLAG_NAME_KEY = "feature_name"
 ROLLOUT_PERCENTAGE_KEY = "RolloutPercentage"
 DEFAULT_ROLLOUT_PERCENTAGE_KEY = "DefaultRolloutPercentage"
 PARAMETERS_KEY = "parameters"
@@ -35,23 +35,22 @@
 
 class TargetingException(Exception):
     """
-    Exception raised when the targeting filter is not configured correctly
+    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
+    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
+        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
-        :paramtype context: Mapping
-        :return: True if the current time is within the time window
+        :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)
@@ -72,7 +71,7 @@ def evaluate(self, context, **kwargs):
 @FeatureFilter.alias("Microsoft.Targeting")
 class TargetingFilter(FeatureFilter):
     """
-    Feature Filter that determines if the user is targeted for the feature flag
+    Feature Filter that determines if the user is targeted for the feature flag.
     """
 
     @staticmethod
@@ -82,27 +81,26 @@ def _is_targeted(context_id, rollout_percentage):
         if rollout_percentage == 100:
             return True
 
-        hashed_context_id = hashlib.sha256(context_id.encode()).hexdigest()
-        context_marker = abs(int(hashed_context_id, 16))
-        percentage = (context_marker / (2**256 - 1)) * 100
+        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)
-        audience_context_id = (
-            target_user + "\n" + target_group + "\n" + feature_flag_name + "\n" + group.get(FEATURE_FILTER_NAME_KEY, "")
-        )
+        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
+        Determine if the feature flag is enabled for the given context.
 
-        :keyword Mapping context: Context for evaluating the user/group
-        :paramtype context: Mapping
-        :return: True if the user is targeted for the feature flag
+        :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)
@@ -129,7 +127,7 @@ def evaluate(self, context, **kwargs):
 
         # Check if the user is in an excluded group
         for group in audience.get(EXCLUSION_KEY, {}).get(GROUPS_KEY, []):
-            if group.get(FEATURE_FILTER_NAME_KEY) in target_groups:
+            if group in target_groups:
                 return False
 
         # Check if the user is targeted
@@ -147,6 +145,8 @@ def evaluate(self, context, **kwargs):
                     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)

featuremanagement/_featurefilters.py

@@ -8,22 +8,23 @@
 
 class FeatureFilter(ABC):
     """
-    Parent class for all feature filters
+    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
-        :paramtype context: Mapping
+        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
+        Get the name of the filter.
+
+        :return: Name of the filter, or alias if it exists.
         :rtype: str
         """
         if hasattr(self, "_alias"):
@@ -32,8 +33,16 @@ def name(self):
 
     @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
+            cls._alias = alias  # pylint: disable=protected-access
             return cls
 
         return wrapper