FeatureManagement 2.0.0b2__tar.gz → 2.1.0__tar.gz

featuremanagement-2.1.0/CHANGELOG.md

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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: FeatureManagement
-Version: 2.0.0b2
+Version: 2.1.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
@@ -43,6 +43,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: azuremonitor
 Requires-Dist: azure-monitor-events-extension<2.0.0; extra == "azuremonitor"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
 
 # Microsoft Feature Management for Python
 

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

@@ -31,6 +31,10 @@ featuremanagement/_models/_telemetry.py
 featuremanagement/_models/_variant.py
 featuremanagement/_models/_variant_assignment_reason.py
 featuremanagement/_models/_variant_reference.py
+featuremanagement/_time_window_filter/__init__.py
+featuremanagement/_time_window_filter/_models.py
+featuremanagement/_time_window_filter/_recurrence_evaluator.py
+featuremanagement/_time_window_filter/_recurrence_validator.py
 featuremanagement/aio/__init__.py
 featuremanagement/aio/_defaultfilters.py
 featuremanagement/aio/_featurefilters.py
@@ -40,9 +44,12 @@ featuremanagement/azuremonitor/_send_telemetry.py
 samples/feature_flag_sample.py
 samples/feature_flag_with_azure_app_configuration_sample.py
 samples/feature_variant_sample.py
+samples/feature_variant_sample_with_targeting_accessor.py
 samples/feature_variant_sample_with_telemetry.py
 samples/formatted_feature_flags.json
+samples/quarty_sample.py
 samples/random_filter.py
+tests/__init__.py
 tests/test_default_feature_flags.py
 tests/test_default_feature_flags_async.py
 tests/test_feature_manager.py
@@ -51,4 +58,7 @@ tests/test_feature_manager_refresh.py
 tests/test_feature_variants.py
 tests/test_feature_variants_async.py
 tests/test_send_telemetry_appinsights.py
+tests/time_window_filter/test_recurrence_evaluator.py
+tests/time_window_filter/test_recurrence_validator.py
+tests/time_window_filter/test_time_window_filter_models.py
 tests/validation_tests/test_json_validations.py

{featuremanagement-2.0.0b2 → featuremanagement-2.1.0}/FeatureManagement.egg-info/top_level.txt

@@ -1 +1,2 @@
 featuremanagement
+tests

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: FeatureManagement
-Version: 2.0.0b2
+Version: 2.1.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
@@ -43,6 +43,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: azuremonitor
 Requires-Dist: azure-monitor-events-extension<2.0.0; extra == "azuremonitor"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
 
 # Microsoft Feature Management for Python
 

{featuremanagement-2.0.0b2 → featuremanagement-2.1.0}/featuremanagement/_defaultfilters.py

@@ -9,6 +9,7 @@ from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
 from typing import cast, List, Mapping, Optional, Dict, Any
 from ._featurefilters import FeatureFilter
+from ._time_window_filter import Recurrence, is_match, TimeWindowFilterSettings
 
 FEATURE_FLAG_NAME_KEY = "feature_name"
 ROLLOUT_PERCENTAGE_KEY = "RolloutPercentage"
@@ -18,6 +19,15 @@ PARAMETERS_KEY = "parameters"
 # Time Window Constants
 START_KEY = "Start"
 END_KEY = "End"
+TIME_WINDOW_FILTER_SETTING_RECURRENCE = "Recurrence"
+
+# Time Window Exceptions
+TIME_WINDOW_FILTER_INVALID = (
+    "{}: The {} feature filter is not valid for feature {}. It must specify either {}, {}, or both."
+)
+TIME_WINDOW_FILTER_INVALID_RECURRENCE = (
+    "{}: The {} feature filter is not valid for feature {}. It must specify both {} and {} when Recurrence is not None."
+)
 
 # Targeting kwargs
 TARGETED_USER_KEY = "user"
@@ -31,6 +41,8 @@ EXCLUSION_KEY = "Exclusion"
 FEATURE_FILTER_NAME_KEY = "Name"
 IGNORE_CASE_KEY = "ignore_case"
 
+logger = logging.getLogger(__name__)
+
 
 class TargetingException(Exception):
     """
@@ -52,19 +64,35 @@ class TimeWindowFilter(FeatureFilter):
         :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)
+        start = context.get(PARAMETERS_KEY, {}).get(START_KEY, None)
+        end = context.get(PARAMETERS_KEY, {}).get(END_KEY, None)
+        recurrence_data = context.get(PARAMETERS_KEY, {}).get(TIME_WINDOW_FILTER_SETTING_RECURRENCE, None)
+        recurrence = None
 
         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__)
+            logger.warning(
+                TIME_WINDOW_FILTER_INVALID,
+                TimeWindowFilter.__name__,
+                context.get(FEATURE_FLAG_NAME_KEY),
+                START_KEY,
+                END_KEY,
+            )
             return False
 
-        start_time = parsedate_to_datetime(start) if start else None
-        end_time = parsedate_to_datetime(end) if end else None
+        start_time: Optional[datetime] = parsedate_to_datetime(start) if start else None
+        end_time: Optional[datetime] = parsedate_to_datetime(end) if end else None
+
+        if (start_time is None or start_time <= current_time) and (end_time is None or current_time < end_time):
+            return True
+
+        if recurrence_data:
+            recurrence = Recurrence(recurrence_data)
+            settings = TimeWindowFilterSettings(start_time, end_time, recurrence)
+            return is_match(settings, current_time)
 
-        return (start_time is None or start_time <= current_time) and (end_time is None or current_time < end_time)
+        return False
 
 
 @FeatureFilter.alias("Microsoft.Targeting")

{featuremanagement-2.0.0b2 → featuremanagement-2.1.0}/featuremanagement/_featuremanager.py

@@ -4,19 +4,19 @@
 # license information.
 # -------------------------------------------------------------------------
 import logging
-from typing import cast, overload, Any, Optional, Dict, Mapping, List
+from typing import cast, overload, Any, Optional, Dict, Mapping, List, Tuple
 from ._defaultfilters import TimeWindowFilter, TargetingFilter
 from ._featurefilters import FeatureFilter
 from ._models import EvaluationEvent, Variant, TargetingContext
 from ._featuremanagerbase import (
-    _get_feature_flag,
     FeatureManagerBase,
     PROVIDED_FEATURE_FILTERS,
-    FEATURE_MANAGEMENT_KEY,
     REQUIREMENT_TYPE_ALL,
     FEATURE_FILTER_NAME,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class FeatureManager(FeatureManagerBase):
     """
@@ -26,6 +26,8 @@ class FeatureManager(FeatureManagerBase):
     :keyword list[FeatureFilter] feature_filters: Custom filters to be used for evaluating feature flags.
     :keyword Callable[EvaluationEvent] on_feature_evaluated: Callback function to be called when a feature flag is
     evaluated.
+    :keyword Callable[[], TargetingContext] targeting_context_accessor: Callback function to get the current targeting
+    context if one isn't provided.
     """
 
     def __init__(self, configuration: Mapping[str, Any], **kwargs: Any):
@@ -59,7 +61,7 @@ class FeatureManager(FeatureManagerBase):
         :return: True if the feature flag is enabled for the given context.
         :rtype: bool
         """
-        targeting_context = self._build_targeting_context(args)
+        targeting_context: TargetingContext = self._build_targeting_context(args)
 
         result = self._check_feature(feature_flag_id, targeting_context, **kwargs)
         if (
@@ -92,7 +94,7 @@ class FeatureManager(FeatureManagerBase):
         :return: Variant instance.
         :rtype: Variant
         """
-        targeting_context = self._build_targeting_context(args)
+        targeting_context: TargetingContext = self._build_targeting_context(args)
 
         result = self._check_feature(feature_flag_id, targeting_context, **kwargs)
         if (
@@ -105,6 +107,21 @@ class FeatureManager(FeatureManagerBase):
             self._on_feature_evaluated(result)
         return result.variant
 
+    def _build_targeting_context(self, args: Tuple[Any]) -> TargetingContext:
+        targeting_context = super()._build_targeting_context(args)
+        if targeting_context:
+            return targeting_context
+        if not targeting_context and self._targeting_context_accessor and callable(self._targeting_context_accessor):
+            targeting_context = self._targeting_context_accessor()
+            if targeting_context and isinstance(targeting_context, TargetingContext):
+                return targeting_context
+            logger.warning(
+                "targeting_context_accessor did not return a TargetingContext. Received type %s.",
+                type(targeting_context),
+            )
+
+        return TargetingContext()
+
     def _check_feature_filters(
         self, evaluation_event: EvaluationEvent, targeting_context: TargetingContext, **kwargs: Any
     ) -> None:
@@ -143,35 +160,13 @@ class FeatureManager(FeatureManagerBase):
         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
+        :param TargetingContext targeting_context: Targeting context.
+        :return: EvaluationEvent for the given context.
+        :rtype: EvaluationEvent
         """
-        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)
-
-        evaluation_event = EvaluationEvent(feature_flag)
-        if not feature_flag:
-            logging.warning("Feature flag %s not found", feature_flag_id)
-            # Unknown feature flags are disabled by default
-            return evaluation_event
-
-        if not feature_flag.enabled:
-            # Feature flags that are disabled are always disabled
-            FeatureManager._check_default_disabled_variant(evaluation_event)
-            if feature_flag.allocation:
-                variant_name = feature_flag.allocation.default_when_disabled
-                evaluation_event.variant = self._variant_name_to_variant(feature_flag, variant_name)
-            evaluation_event.feature = feature_flag
+        evaluation_event, done = super()._check_feature_base(feature_flag_id)
 
-            # If a feature flag is disabled and override can't enable it
-            evaluation_event.enabled = False
+        if done:
             return evaluation_event
 
         self._check_feature_filters(evaluation_event, targeting_context, **kwargs)

{featuremanagement-2.0.0b2 → featuremanagement-2.1.0}/featuremanagement/_featuremanagerbase.py

@@ -4,8 +4,9 @@
 # license information.
 # -------------------------------------------------------------------------
 import hashlib
+import logging
 from abc import ABC
-from typing import List, Optional, Dict, Tuple, Any, Mapping
+from typing import List, Optional, Dict, Tuple, Any, Mapping, Callable
 from ._models import FeatureFlag, Variant, VariantAssignmentReason, TargetingContext, EvaluationEvent, VariantReference
 
 
@@ -20,6 +21,9 @@ REQUIREMENT_TYPE_ANY = "Any"
 FEATURE_FILTER_PARAMETERS = "parameters"
 
 
+logger = logging.getLogger(__name__)
+
+
 def _get_feature_flag(configuration: Mapping[str, Any], feature_flag_name: str) -> Optional[FeatureFlag]:
     """
     Gets the FeatureFlag json from the configuration, if it exists it gets converted to a FeatureFlag object.
@@ -76,9 +80,12 @@ class FeatureManagerBase(ABC):
         self._cache: Dict[str, Optional[FeatureFlag]] = {}
         self._copy = configuration.get(FEATURE_MANAGEMENT_KEY)
         self._on_feature_evaluated = kwargs.pop("on_feature_evaluated", None)
+        self._targeting_context_accessor: Optional[Callable[[], TargetingContext]] = kwargs.pop(
+            "targeting_context_accessor", None
+        )
 
     @staticmethod
-    def _check_default_disabled_variant(evaluation_event: EvaluationEvent) -> None:
+    def _assign_default_disabled_variant(evaluation_event: EvaluationEvent) -> None:
         """
         A method called when the feature flag is disabled, to determine what the default variant should be. If there is
         no allocation, then None is set as the value of the variant in the EvaluationEvent.
@@ -88,7 +95,7 @@ class FeatureManagerBase(ABC):
         evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_DISABLED
         if not evaluation_event.feature or not evaluation_event.feature.allocation:
             return
-        FeatureManagerBase._check_variant_override(
+        FeatureManagerBase._assign_variant_override(
             evaluation_event.feature.variants,
             evaluation_event.feature.allocation.default_when_disabled,
             False,
@@ -96,7 +103,7 @@ class FeatureManagerBase(ABC):
         )
 
     @staticmethod
-    def _check_default_enabled_variant(evaluation_event: EvaluationEvent) -> None:
+    def _assign_default_enabled_variant(evaluation_event: EvaluationEvent) -> None:
         """
         A method called when the feature flag is enabled, to determine what the default variant should be. If there is
         no allocation, then None is set as the value of the variant in the EvaluationEvent.
@@ -106,7 +113,7 @@ class FeatureManagerBase(ABC):
         evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_ENABLED
         if not evaluation_event.feature or not evaluation_event.feature.allocation:
             return
-        FeatureManagerBase._check_variant_override(
+        FeatureManagerBase._assign_variant_override(
             evaluation_event.feature.variants,
             evaluation_event.feature.allocation.default_when_enabled,
             True,
@@ -114,7 +121,7 @@ class FeatureManagerBase(ABC):
         )
 
     @staticmethod
-    def _check_variant_override(
+    def _assign_variant_override(
         variants: Optional[List[VariantReference]],
         default_variant_name: Optional[str],
         status: bool,
@@ -149,56 +156,57 @@ class FeatureManagerBase(ABC):
 
         return (context_marker / (2**32 - 1)) * 100
 
-    def _assign_variant(
-        self, feature_flag: FeatureFlag, targeting_context: TargetingContext, evaluation_event: EvaluationEvent
-    ) -> None:
+    def _assign_variant(self, targeting_context: TargetingContext, evaluation_event: EvaluationEvent) -> None:
         """
         Assign a variant to the user based on the allocation.
 
-        :param FeatureFlag feature_flag: Feature flag object.
         :param TargetingContext targeting_context: Targeting context.
         :param EvaluationEvent evaluation_event: Evaluation event object.
         """
-        feature = evaluation_event.feature
+        feature_flag = evaluation_event.feature
         variant_name = None
-        if not feature or not feature.variants or not feature.allocation:
+        if not feature_flag or not feature_flag.variants or not feature_flag.allocation:
             return
-        if feature.allocation.user and targeting_context.user_id:
-            for user_allocation in feature.allocation.user:
+
+        allocation = feature_flag.allocation
+        groups = targeting_context.groups
+
+        if allocation.user and targeting_context.user_id:
+            for user_allocation in allocation.user:
                 if targeting_context.user_id in user_allocation.users:
                     evaluation_event.reason = VariantAssignmentReason.USER
                     variant_name = user_allocation.variant
-        if not variant_name and feature.allocation.group and len(targeting_context.groups) > 0:
-            for group_allocation in feature.allocation.group:
-                for group in targeting_context.groups:
-                    if group in group_allocation.groups:
-                        evaluation_event.reason = VariantAssignmentReason.GROUP
-                        variant_name = group_allocation.variant
-        if not variant_name and feature.allocation.percentile:
-            seed = feature.allocation.seed
-            if not seed:
-                seed = "allocation\n" + feature.name
-            context_id = targeting_context.user_id + "\n" + seed
+
+        if not variant_name and allocation.group and groups:
+            for group_allocation in allocation.group:
+                if any(group in group_allocation.groups for group in groups):
+                    evaluation_event.reason = VariantAssignmentReason.GROUP
+                    variant_name = group_allocation.variant
+
+        if not variant_name and allocation.percentile:
+            seed = allocation.seed or f"allocation\n{feature_flag.name}"
+            context_id = f"{targeting_context.user_id}\n{seed}"
             box: float = self._is_targeted(context_id)
-            for percentile_allocation in feature.allocation.percentile:
-                if box == 100 and percentile_allocation.percentile_to == 100:
-                    variant_name = percentile_allocation.variant
-                if not percentile_allocation.percentile_to:
-                    continue
-                if percentile_allocation.percentile_from <= box < percentile_allocation.percentile_to:
+            for percentile_allocation in allocation.percentile:
+                percentile_to: int = percentile_allocation.percentile_to
+                if (box == 100 and percentile_to == 100) or (
+                    percentile_allocation.percentile_from <= box < percentile_to
+                ):
                     evaluation_event.reason = VariantAssignmentReason.PERCENTILE
                     variant_name = percentile_allocation.variant
+                    break
+
         if not variant_name:
-            FeatureManagerBase._check_default_enabled_variant(evaluation_event)
+            FeatureManagerBase._assign_default_enabled_variant(evaluation_event)
             if feature_flag.allocation:
                 evaluation_event.variant = self._variant_name_to_variant(
                     feature_flag, feature_flag.allocation.default_when_enabled
                 )
                 return
+
         evaluation_event.variant = self._variant_name_to_variant(feature_flag, variant_name)
-        if not feature_flag.variants:
-            return
-        FeatureManagerBase._check_variant_override(feature_flag.variants, variant_name, True, evaluation_event)
+        if feature_flag.variants:
+            FeatureManagerBase._assign_variant_override(feature_flag.variants, variant_name, True, evaluation_event)
 
     def _variant_name_to_variant(self, feature_flag: FeatureFlag, variant_name: Optional[str]) -> Optional[Variant]:
         """
@@ -208,16 +216,15 @@ class FeatureManagerBase(ABC):
         :param str variant_name: Name of the variant.
         :return: Variant object.
         """
-        if not feature_flag.variants:
-            return None
-        if not variant_name:
+        if not feature_flag.variants or not variant_name:
             return None
+
         for variant_reference in feature_flag.variants:
             if variant_reference.name == variant_name:
                 return Variant(variant_reference.name, variant_reference.configuration_value)
         return None
 
-    def _build_targeting_context(self, args: Tuple[Any]) -> TargetingContext:
+    def _build_targeting_context(self, args: Tuple[Any]) -> Optional[TargetingContext]:
         """
         Builds a TargetingContext, either returns a provided context, takes the provided user_id to make a context, or
         returns an empty context.
@@ -225,31 +232,68 @@ class FeatureManagerBase(ABC):
         :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()
+        if len(args) == 1:
+            arg = args[0]
+            if isinstance(arg, str):
+                # If the user_id is provided, return a TargetingContext with the user_id
+                return TargetingContext(user_id=arg, groups=[])
+            if isinstance(arg, TargetingContext):
+                # If a TargetingContext is provided, return it
+                return arg
+        return None
 
     def _assign_allocation(self, evaluation_event: EvaluationEvent, targeting_context: TargetingContext) -> None:
         feature_flag = evaluation_event.feature
         if not feature_flag:
             return
-        if feature_flag.variants:
-            if not feature_flag.allocation:
-                if evaluation_event.enabled:
-                    evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_ENABLED
-                    return
-                evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_DISABLED
-                return
-            if not evaluation_event.enabled:
-                FeatureManagerBase._check_default_disabled_variant(evaluation_event)
-                evaluation_event.variant = self._variant_name_to_variant(
-                    feature_flag, feature_flag.allocation.default_when_disabled
-                )
-                return
 
-            self._assign_variant(feature_flag, targeting_context, evaluation_event)
+        if not feature_flag.variants or not feature_flag.allocation:
+            return
+
+        if not evaluation_event.enabled:
+            FeatureManagerBase._assign_default_disabled_variant(evaluation_event)
+            evaluation_event.variant = self._variant_name_to_variant(
+                feature_flag, feature_flag.allocation.default_when_disabled
+            )
+            return
+
+        self._assign_variant(targeting_context, evaluation_event)
+
+    def _check_feature_base(self, feature_flag_id: str) -> Tuple[EvaluationEvent, bool]:
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :param str feature_flag_id: Name of the feature flag.
+        :return: The evaluation event and if the feature filters need to be checked.
+        :rtype: evaluation_event, 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)
+
+        evaluation_event = EvaluationEvent(feature_flag)
+        if not feature_flag:
+            logger.warning("Feature flag %s not found", feature_flag_id)
+            # Unknown feature flags are disabled by default
+            return evaluation_event, True
+
+        if not feature_flag.enabled:
+            # Feature flags that are disabled are always disabled
+            self._assign_default_disabled_variant(evaluation_event)
+            if feature_flag.allocation:
+                variant_name = feature_flag.allocation.default_when_disabled
+                evaluation_event.variant = self._variant_name_to_variant(feature_flag, variant_name)
+
+            # If a feature flag is disabled and override can't enable it
+            evaluation_event.enabled = False
+            return evaluation_event, True
+        return evaluation_event, False
 
     def list_feature_flag_names(self) -> List[str]:
         """

{featuremanagement-2.0.0b2 → featuremanagement-2.1.0}/featuremanagement/_models/_allocation.py

@@ -36,7 +36,7 @@ class PercentileAllocation:
     def __init__(self) -> None:
         self._variant: Optional[str] = None
         self._percentile_from: int = 0
-        self._percentile_to: Optional[int] = None
+        self._percentile_to: int = 0
 
     @classmethod
     def convert_from_json(cls, json: Mapping[str, Union[str, int]]) -> "PercentileAllocation":
@@ -88,7 +88,7 @@ class PercentileAllocation:
         return self._percentile_from
 
     @property
-    def percentile_to(self) -> Optional[int]:
+    def percentile_to(self) -> int:
         """
         Get the ending percentile for the allocation.
 

{featuremanagement-2.0.0b2 → featuremanagement-2.1.0}/featuremanagement/_models/_evaluation_event.py

@@ -24,4 +24,4 @@ class EvaluationEvent:
         self.user = ""
         self.enabled = False
         self.variant: Optional[Variant] = None
-        self.reason: Optional[VariantAssignmentReason] = None
+        self.reason: VariantAssignmentReason = VariantAssignmentReason.NONE

featuremanagement-2.1.0/featuremanagement/_time_window_filter/__init__.py

@@ -0,0 +1,9 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from ._recurrence_evaluator import is_match
+from ._models import Recurrence, TimeWindowFilterSettings
+
+__all__ = ["is_match", "Recurrence", "TimeWindowFilterSettings"]