prefect-client 3.6.26.dev2__tar.gz → 3.6.26.dev4__tar.gz

{prefect_client-3.6.26.dev2 → prefect_client-3.6.26.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.6.26.dev2
+Version: 3.6.26.dev4
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

prefect_client-3.6.26.dev4/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.6.26.dev4"
+__build_date__ = "2026-04-08 08:32:05.083908+00:00"
+__git_commit__ = "a6344b22b58356eab60d6e21163d3520134df4b0"
+__dirty__ = False

{prefect_client-3.6.26.dev2 → prefect_client-3.6.26.dev4}/src/prefect/_internal/schemas/validators.py

@@ -306,6 +306,145 @@ def validate_rrule_string(v: str) -> str:
     return v
 
 
+# RRule's implicit anchor when no DTSTART is supplied. Kept for backward
+# compatibility with rules that already exist in the wild and for shapes
+# where we cannot prove a phase-equivalent advance is safe (anything with
+# COUNT, or any FREQ above MINUTELY).
+DEFAULT_RRULE_ANCHOR = datetime.datetime(2020, 1, 1, 0, 0, 0)
+
+
+def normalize_rrule_string(
+    rrule_string: str,
+    *,
+    now: Optional[datetime.datetime] = None,
+) -> str:
+    """Inject a `DTSTART` line into an rrule string if it doesn't already have one.
+
+    See PrefectHQ/prefect#21362 for context. Without an explicit `DTSTART`,
+    `dateutil.rrule.rrulestr` falls back to the implicit anchor of
+    2020-01-01, and `xafter()` walks every occurrence from then to "now"
+    on each call. For high-frequency rules (FREQ=MINUTELY/SECONDLY without
+    COUNT) that's millions of occurrences and can saturate a CPU core
+    across a handful of deployments.
+
+    The fix is to make `DTSTART` explicit on every persisted rrule. To
+    avoid silently re-phasing existing schedules, we split the work:
+
+    - **High-frequency rules without `COUNT`** (`FREQ=SECONDLY` or
+      `FREQ=MINUTELY`): we pick a *phase-equivalent recent anchor* —
+      `DEFAULT_RRULE_ANCHOR + k * (INTERVAL * unit)` for the largest `k`
+      that keeps the new dtstart at or before `now`. This is provably
+      occurrence-set-equivalent for any query time at or after the new
+      dtstart, and shrinks dateutil's working set from millions of
+      cached datetimes to a handful.
+
+    - **Everything else** (HOURLY/DAILY/WEEKLY/MONTHLY/YEARLY, anything
+      with `COUNT`, rrulesets with multiple components): we inject the
+      legacy `DTSTART:20200101T000000` so observable behavior is
+      byte-for-byte preserved. These shapes don't suffer from the
+      memory/CPU pain in practice (a 6-year HOURLY cache is ~50k
+      datetimes, ~3 MB).
+
+    Strings that already contain a `DTSTART` are returned unchanged.
+    """
+    import dateutil.rrule
+
+    # Already anchored — leave it alone.
+    if "DTSTART" in rrule_string.upper():
+        return rrule_string
+
+    # Try to introspect the rule. We need FREQ/INTERVAL/COUNT to decide
+    # which bucket the rule falls into. If parsing fails for any reason,
+    # leave the input unchanged — synthesizing a DTSTART for an invalid
+    # rrule would just create different garbage. The real validator
+    # (`validate_rrule_string`) surfaces the error on the action-schema
+    # path; the migration's caller skips unchanged rows.
+    try:
+        parsed = dateutil.rrule.rrulestr(
+            rrule_string,
+            dtstart=DEFAULT_RRULE_ANCHOR,
+            cache=False,
+        )
+    except (ValueError, TypeError):
+        return rrule_string
+
+    # Rrulesets (multiple RRULEs, EXRULEs, RDATEs, EXDATEs) take the safe
+    # path. Phase-advancing them correctly would require reasoning about
+    # all components together, and they're rare enough not to matter.
+    if not isinstance(parsed, dateutil.rrule.rrule):
+        return _prepend_dtstart(rrule_string, DEFAULT_RRULE_ANCHOR)
+
+    # dateutil exposes these only as private attributes; use `getattr`
+    # so that any future change to dateutil's internal interface
+    # degrades gracefully to the safe 2020-anchor path instead of
+    # raising `AttributeError`.
+    freq = getattr(parsed, "_freq", None)
+    interval = getattr(parsed, "_interval", None)
+    count = getattr(parsed, "_count", None)
+
+    # Only the high-frequency, no-COUNT shapes are eligible for advance.
+    # If dateutil's internals ever stop exposing these, we fall through
+    # to the safe 2020-anchor path.
+    if (
+        freq is None
+        or interval is None
+        or count is not None
+        or freq not in (dateutil.rrule.SECONDLY, dateutil.rrule.MINUTELY)
+    ):
+        return _prepend_dtstart(rrule_string, DEFAULT_RRULE_ANCHOR)
+
+    unit_seconds = 1 if freq == dateutil.rrule.SECONDLY else 60
+    period_seconds = unit_seconds * interval
+
+    if now is None:
+        now = datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None)
+    elif now.tzinfo is not None:
+        now = now.astimezone(datetime.timezone.utc).replace(tzinfo=None)
+
+    delta_seconds = (now - DEFAULT_RRULE_ANCHOR).total_seconds()
+    if delta_seconds <= 0:
+        # `now` is at or before the legacy anchor — nothing to advance to.
+        return _prepend_dtstart(rrule_string, DEFAULT_RRULE_ANCHOR)
+
+    k = int(delta_seconds // period_seconds)
+    new_dtstart = DEFAULT_RRULE_ANCHOR + datetime.timedelta(seconds=k * period_seconds)
+    return _prepend_dtstart(rrule_string, new_dtstart)
+
+
+def _prepend_dtstart(rrule_string: str, dt: datetime.datetime) -> str:
+    """Prepend a floating-time `DTSTART` line to an rrule string.
+
+    The format is RFC 5545 "floating" local time (no `Z`, no `TZID`); the
+    schedule's `timezone` field continues to handle localization at
+    materialization time. This matches what `RRuleSchedule.to_rrule` was
+    doing implicitly when it passed `DEFAULT_ANCHOR_DATE` as a naive date.
+    """
+    return f"DTSTART:{dt.strftime('%Y%m%dT%H%M%S')}\n{rrule_string}"
+
+
+_T = TypeVar("_T")
+
+
+def normalize_schedule_rrule(schedule: _T) -> _T:
+    """`AfterValidator` for action-schema schedule fields.
+
+    Used as `Annotated[SCHEDULE_TYPES, AfterValidator(normalize_schedule_rrule)]`
+    on the `schedule` field of `DeploymentScheduleCreate` /
+    `DeploymentScheduleUpdate` (both client and server). Duck-typed so a
+    single helper covers both `RRuleSchedule` classes without an import
+    cycle into `_internal/`.
+
+    Non-RRule schedules and `None` pass through unchanged.
+    """
+    rrule = getattr(schedule, "rrule", None)
+    if not isinstance(rrule, str):
+        return schedule
+    normalized = normalize_rrule_string(rrule)
+    if normalized == rrule:
+        return schedule
+    return type(schedule)(rrule=normalized, timezone=schedule.timezone)  # type: ignore[call-arg]
+
+
 ### STATE SCHEMA VALIDATORS ###
 
 

{prefect_client-3.6.26.dev2 → prefect_client-3.6.26.dev4}/src/prefect/client/schemas/actions.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import datetime
 from copy import deepcopy
-from typing import Any, Callable, Optional, TypeVar, Union
+from typing import Annotated, Any, Callable, Optional, TypeVar, Union
 from uuid import UUID, uuid4
 
 import jsonschema
 from pydantic import (
+    AfterValidator,
     BaseModel,
     Field,
     field_serializer,
@@ -18,6 +19,7 @@ import prefect.client.schemas.objects as objects
 from prefect._internal.schemas.bases import ActionBaseModel
 from prefect._internal.schemas.validators import (
     convert_to_strings,
+    normalize_schedule_rrule,
     remove_old_deployment_fields,
     validate_name_present_on_nonanonymous_blocks,
     validate_schedule_max_scheduled_runs,
@@ -98,8 +100,21 @@ class FlowUpdate(ActionBaseModel):
     )
 
 
+# Bare RRule schedules arriving via the API write path get an explicit
+# DTSTART injected here so the scheduler doesn't fall back to the legacy
+# 2020 anchor on every loop. The validator is attached to the *field*
+# (via Annotated) rather than to RRuleSchedule itself — if it lived on
+# the schedule class, it would also fire on every DB read and re-phase
+# INTERVAL>1 schedules. See PrefectHQ/prefect#21362.
+#
+# Fields that accept `None` (e.g. `DeploymentScheduleUpdate.schedule`)
+# use `Optional[NormalizedSchedule]` directly — Pydantic only runs the
+# `AfterValidator` on the non-None branch.
+NormalizedSchedule = Annotated[SCHEDULE_TYPES, AfterValidator(normalize_schedule_rrule)]
+
+
 class DeploymentScheduleCreate(ActionBaseModel):
-    schedule: SCHEDULE_TYPES = Field(
+    schedule: NormalizedSchedule = Field(
         default=..., description="The schedule for the deployment."
     )
     active: bool = Field(
@@ -180,7 +195,7 @@ class DeploymentScheduleCreate(ActionBaseModel):
 
 
 class DeploymentScheduleUpdate(ActionBaseModel):
-    schedule: Optional[SCHEDULE_TYPES] = Field(
+    schedule: Optional[NormalizedSchedule] = Field(
         default=None, description="The schedule for the deployment."
     )
     active: Optional[bool] = Field(

prefect_client-3.6.26.dev2/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.6.26.dev2"
-__build_date__ = "2026-04-05 08:17:02.527706+00:00"
-__git_commit__ = "b1b196328332166faba5bdb79491fd0d52d01edd"
-__dirty__ = False