FeatureManagement 2.0.0b3__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.0b3 → 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.0b3
+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.0b3 → 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.0b3 → featuremanagement-2.1.0}/FeatureManagement.egg-info/top_level.txt

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

{featuremanagement-2.0.0b3/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.0b3
+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.0b3 → 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.0b3 → featuremanagement-2.1.0}/featuremanagement/_featuremanager.py

@@ -3,7 +3,8 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # -------------------------------------------------------------------------
-from typing import cast, overload, Any, Optional, Dict, Mapping, List
+import logging
+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
@@ -14,6 +15,8 @@ from ._featuremanagerbase import (
     FEATURE_FILTER_NAME,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class FeatureManager(FeatureManagerBase):
     """
@@ -23,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):
@@ -56,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 (
@@ -89,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 (
@@ -102,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:

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

@@ -6,7 +6,7 @@
 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
 
 
@@ -21,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.
@@ -77,6 +80,9 @@ 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 _assign_default_disabled_variant(evaluation_event: EvaluationEvent) -> None:
@@ -218,7 +224,7 @@ class FeatureManagerBase(ABC):
                 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.
@@ -229,10 +235,12 @@ class FeatureManagerBase(ABC):
         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 TargetingContext()
+        return None
 
     def _assign_allocation(self, evaluation_event: EvaluationEvent, targeting_context: TargetingContext) -> None:
         feature_flag = evaluation_event.feature
@@ -271,7 +279,7 @@ class FeatureManagerBase(ABC):
 
         evaluation_event = EvaluationEvent(feature_flag)
         if not feature_flag:
-            logging.warning("Feature flag %s not found", feature_flag_id)
+            logger.warning("Feature flag %s not found", feature_flag_id)
             # Unknown feature flags are disabled by default
             return evaluation_event, True
 

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"]

featuremanagement-2.1.0/featuremanagement/_time_window_filter/_models.py

@@ -0,0 +1,149 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from enum import Enum
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+from dataclasses import dataclass
+from email.utils import parsedate_to_datetime
+
+
+class RecurrencePatternType(str, Enum):
+    """
+    The recurrence pattern type.
+    """
+
+    DAILY = "Daily"
+    WEEKLY = "Weekly"
+
+    @staticmethod
+    def from_str(value: str) -> "RecurrencePatternType":
+        """
+        Get the RecurrencePatternType from the string value.
+
+        :param value: The string value.
+        :type value: str
+        :return: The RecurrencePatternType.
+        :rtype: RecurrencePatternType
+        """
+        if value == "Daily":
+            return RecurrencePatternType.DAILY
+        if value == "Weekly":
+            return RecurrencePatternType.WEEKLY
+        raise ValueError(f"Invalid value: {value}")
+
+
+class RecurrenceRangeType(str, Enum):
+    """
+    The recurrence range type.
+    """
+
+    NO_END = "NoEnd"
+    END_DATE = "EndDate"
+    NUMBERED = "Numbered"
+
+    @staticmethod
+    def from_str(value: str) -> "RecurrenceRangeType":
+        """
+        Get the RecurrenceRangeType from the string value.
+
+        :param value: The string value.
+        :type value: str
+        :return: The RecurrenceRangeType.
+        :rtype: RecurrenceRangeType
+        """
+        if value == "NoEnd":
+            return RecurrenceRangeType.NO_END
+        if value == "EndDate":
+            return RecurrenceRangeType.END_DATE
+        if value == "Numbered":
+            return RecurrenceRangeType.NUMBERED
+        raise ValueError(f"Invalid value: {value}")
+
+
+class RecurrencePattern:  # pylint: disable=too-few-public-methods
+    """
+    The recurrence pattern settings.
+    """
+
+    days: List[str] = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+
+    def __init__(self, pattern_data: Dict[str, Any]):
+        self.type = RecurrencePatternType.from_str(pattern_data.get("Type", "Daily"))
+        self.interval = pattern_data.get("Interval", 1)
+        if self.interval <= 0:
+            raise ValueError("The interval must be greater than 0.")
+        # Days of the week are represented as a list of strings of their names.
+        days_of_week_str = pattern_data.get("DaysOfWeek", [])
+
+        # Days of the week are represented as a list of integers from 0 to 6.
+        self.days_of_week: List[int] = []
+        for day in days_of_week_str:
+            if day not in self.days:
+                raise ValueError(f"Invalid value for DaysOfWeek: {day}")
+            if self.days.index(day) in self.days_of_week:
+                raise ValueError(f"Duplicate day of the week found: {day}")
+            self.days_of_week.append(self.days.index(day))
+        if pattern_data.get("FirstDayOfWeek") and pattern_data.get("FirstDayOfWeek") not in self.days:
+            raise ValueError(f"Invalid value for FirstDayOfWeek: {pattern_data.get('FirstDayOfWeek')}")
+        self.first_day_of_week = self.days.index(pattern_data.get("FirstDayOfWeek", "Sunday"))
+
+
+class RecurrenceRange:  # pylint: disable=too-few-public-methods
+    """
+    The recurrence range settings.
+    """
+
+    type: RecurrenceRangeType
+    end_date: Optional[datetime] = None
+
+    def __init__(self, range_data: Dict[str, Any]):
+        self.type = RecurrenceRangeType.from_str(range_data.get("Type", "NoEnd"))
+        if range_data.get("EndDate") and isinstance(range_data.get("EndDate"), str):
+            end_date_str = range_data.get("EndDate", "")
+            try:
+                self.end_date = parsedate_to_datetime(end_date_str) if end_date_str else None
+            except ValueError as e:
+                raise ValueError(f"Invalid value for EndDate: {end_date_str}") from e
+            except TypeError as e:
+                # Python 3.9 and earlier throw TypeError if the string is not in RFC 2822 format.
+                raise ValueError(f"Invalid value for EndDate: {end_date_str}") from e
+        self.num_of_occurrences = range_data.get("NumberOfOccurrences", 2**63 - 1)
+        if self.num_of_occurrences <= 0:
+            raise ValueError("The number of occurrences must be greater than 0.")
+
+
+class Recurrence:  # pylint: disable=too-few-public-methods
+    """
+    The recurrence settings.
+    """
+
+    pattern: RecurrencePattern
+    range: RecurrenceRange
+
+    def __init__(self, recurrence_data: Dict[str, Any]):
+        self.pattern = RecurrencePattern(recurrence_data.get("Pattern", {}))
+        self.range = RecurrenceRange(recurrence_data.get("Range", {}))
+
+
+@dataclass
+class TimeWindowFilterSettings:
+    """
+    The settings for the time window filter.
+    """
+
+    start: Optional[datetime]
+    end: Optional[datetime]
+    recurrence: Optional[Recurrence]
+
+
+@dataclass
+class OccurrenceInfo:
+    """
+    The information of the previous occurrence.
+    """
+
+    previous_occurrence: datetime
+    num_of_occurrences: int

featuremanagement-2.1.0/featuremanagement/_time_window_filter/_recurrence_evaluator.py

@@ -0,0 +1,125 @@
+# ------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from datetime import datetime, timedelta
+from typing import Optional
+from ._models import RecurrencePatternType, RecurrenceRangeType, TimeWindowFilterSettings, OccurrenceInfo, Recurrence
+from ._recurrence_validator import validate_settings, _get_passed_week_days, _sort_days_of_week
+
+DAYS_PER_WEEK = 7
+REQUIRED_PARAMETER = "Required parameter: %s"
+
+
+def is_match(settings: TimeWindowFilterSettings, now: datetime) -> bool:
+    """
+    Check if the current time is within the time window filter settings.
+
+    :param TimeWindowFilterSettings settings: The settings for the time window filter.
+    :param datetime now: The current time.
+    :return: True if the current time is within the time window filter settings, otherwise False.
+    :rtype: bool
+    """
+    recurrence = settings.recurrence
+    if recurrence is None:
+        raise ValueError(REQUIRED_PARAMETER % "Recurrence")
+
+    start = settings.start
+    end = settings.end
+    if start is None or end is None:
+        raise ValueError(REQUIRED_PARAMETER % "Start or End")
+
+    validate_settings(recurrence, start, end)
+
+    previous_occurrence = _get_previous_occurrence(recurrence, start, now)
+    if previous_occurrence is None:
+        return False
+
+    occurrence_end_date = previous_occurrence + (end - start)
+    return now < occurrence_end_date
+
+
+def _get_previous_occurrence(recurrence: Recurrence, start: datetime, now: datetime) -> Optional[datetime]:
+    if now < start:
+        return None
+
+    pattern_type = recurrence.pattern.type
+    if pattern_type == RecurrencePatternType.DAILY:
+        occurrence_info = _get_daily_previous_occurrence(recurrence, start, now)
+    elif pattern_type == RecurrencePatternType.WEEKLY:
+        occurrence_info = _get_weekly_previous_occurrence(recurrence, start, now)
+    else:
+        raise ValueError(f"Unsupported recurrence pattern type: {pattern_type}")
+
+    recurrence_range = recurrence.range
+    range_type = recurrence_range.type
+    previous_occurrence = occurrence_info.previous_occurrence
+    end_date = recurrence_range.end_date
+    if (
+        range_type == RecurrenceRangeType.END_DATE
+        and previous_occurrence is not None
+        and end_date is not None
+        and previous_occurrence > end_date
+    ):
+        return None
+    if (
+        range_type == RecurrenceRangeType.NUMBERED
+        and recurrence_range.num_of_occurrences is not None
+        and occurrence_info.num_of_occurrences > recurrence_range.num_of_occurrences
+    ):
+        return None
+
+    return occurrence_info.previous_occurrence
+
+
+def _get_daily_previous_occurrence(recurrence: Recurrence, start: datetime, now: datetime) -> OccurrenceInfo:
+    interval = recurrence.pattern.interval
+    num_of_occurrences = (now - start).days // interval
+    previous_occurrence = start + timedelta(days=num_of_occurrences * interval)
+    return OccurrenceInfo(previous_occurrence, num_of_occurrences + 1)
+
+
+def _get_weekly_previous_occurrence(recurrence: Recurrence, start: datetime, now: datetime) -> OccurrenceInfo:
+    pattern = recurrence.pattern
+    interval = pattern.interval
+    first_day_of_first_week = start - timedelta(days=_get_passed_week_days(start.weekday(), pattern.first_day_of_week))
+
+    number_of_interval = (now - first_day_of_first_week).days // (interval * DAYS_PER_WEEK)
+    first_day_of_most_recent_occurring_week = first_day_of_first_week + timedelta(
+        days=number_of_interval * (interval * DAYS_PER_WEEK)
+    )
+    sorted_days_of_week = _sort_days_of_week(pattern.days_of_week, pattern.first_day_of_week)
+    max_day_offset = _get_passed_week_days(sorted_days_of_week[-1], pattern.first_day_of_week)
+    min_day_offset = _get_passed_week_days(sorted_days_of_week[0], pattern.first_day_of_week)
+    num_of_occurrences = number_of_interval * len(sorted_days_of_week) - sorted_days_of_week.index(start.weekday())
+
+    if now > first_day_of_most_recent_occurring_week + timedelta(days=DAYS_PER_WEEK):
+        num_of_occurrences += len(sorted_days_of_week)
+        most_recent_occurrence = first_day_of_most_recent_occurring_week + timedelta(days=max_day_offset)
+        return OccurrenceInfo(most_recent_occurrence, num_of_occurrences)
+
+    day_with_min_offset = first_day_of_most_recent_occurring_week + timedelta(days=min_day_offset)
+    if start > day_with_min_offset:
+        num_of_occurrences = 0
+        day_with_min_offset = start
+    if now < day_with_min_offset:
+        most_recent_occurrence = (
+            first_day_of_most_recent_occurring_week
+            - timedelta(days=interval * DAYS_PER_WEEK)
+            + timedelta(days=max_day_offset)
+        )
+    else:
+        most_recent_occurrence = day_with_min_offset
+        num_of_occurrences += 1
+
+        for day in sorted_days_of_week[sorted_days_of_week.index(day_with_min_offset.weekday()) + 1 :]:
+            day_with_min_offset = first_day_of_most_recent_occurring_week + timedelta(
+                days=_get_passed_week_days(day, pattern.first_day_of_week)
+            )
+            if now < day_with_min_offset:
+                break
+            most_recent_occurrence = day_with_min_offset
+            num_of_occurrences += 1
+
+    return OccurrenceInfo(most_recent_occurrence, num_of_occurrences)