prefect-client 3.6.28.dev3__tar.gz → 3.6.28.dev4__tar.gz

{prefect_client-3.6.28.dev3 → prefect_client-3.6.28.dev4}/.gitignore

@@ -97,3 +97,4 @@ CLAUDE.md
 
 # Local planning artifacts
 .planning/
+repros/

{prefect_client-3.6.28.dev3 → prefect_client-3.6.28.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.6.28.dev3
+Version: 3.6.28.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.28.dev3 → prefect_client-3.6.28.dev4}/src/prefect/AGENTS.md

@@ -21,10 +21,12 @@ There is no formal public/private boundary beyond the `_` prefix convention. Mod
 
 - **Engine ordering matters.** The engines apply features (retries, caching, result persistence, transactions) in a specific order. Changing the order or forgetting a feature in one engine path is the most common source of breakage.
 - **Sync and async must stay in sync.** Both `flow_engine.py` and `task_engine.py` have sync and async paths. Any behavior change must be applied to both.
+- **Use `whenever` compat helpers for all datetime conversions on Python 3.13+.** `types/_datetime.py` provides `_whenever_to_stdlib()`, `_whenever_zdt_from_py()`, and `_whenever_pdt_from_py()` to abstract over API differences between whenever 0.7.x–0.9.x and ≥ 0.10.0. The `_WHENEVER_NEW_API` flag (True when whenever ≥ 0.10.0) guards version-specific code. Never call `ZonedDateTime.from_py_datetime()`, `PlainDateTime.from_py_datetime()`, or `.py_datetime()` directly — use the helpers instead. Violations will silently break on whichever whenever version the helpers weren't written for.
 - **Flow and task engines advance state differently.** The flow engine makes blocking API calls to the server to propose and advance states. The task engine emits `prefect.task_run.*` events (delivered via WebSockets) but advances state locally through `set_state` calls with polling/backoff — do not assume the two engines work the same way.
 - **Flow state transitions go through the server.** The flow engine proposes states to the server, which accepts or rejects them via orchestration rules. The task engine, by contrast, manages state transitions locally via `set_state` and emits `prefect.task_run.*` events — it does not propose states to the server.
 - **`ProcessPoolTaskRunner` requires picklable data across subprocess boundaries.** `PrefectFuture` objects are not picklable and cannot be passed to worker subprocesses. Any `wait_for` futures must be waited on in the parent process and converted to `State` objects before submission. The subprocess task engine handles `State` objects via `resolve_to_final_result`, which raises `UpstreamTaskError` for non-completed upstreams.
 - **`ProcessPoolTaskRunner` instances may be deserialized without `__init__` running.** When a runner is pickled and restored in a subprocess, `__init__` is not called, so instance attributes set there may be absent. Access any such attribute via `getattr(self, "_attr", default)` rather than `self._attr` directly — both in the property getter and in `duplicate()`. The `subprocess_message_processor_factories` property demonstrates the required pattern.
+- **`ResultRecordMetadata` tolerates unknown serializer types.** When loading persisted metadata, an unrecognized serializer `type` is converted to an `UnknownSerializer` placeholder rather than raising `ValidationError`. This allows inspecting result metadata when the serializer implementation is unavailable in the current environment. However, known serializer types with invalid fields still raise `ValidationError`. `UnknownSerializer.dumps()` and `UnknownSerializer.loads()` raise `RuntimeError` — the tolerance is for inspection only, not actual serialization/deserialization.
 
 ## Logging
 

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

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.6.28.dev4"
+__build_date__ = "2026-04-22 08:42:19.175916+00:00"
+__git_commit__ = "093cd05d7fae5c8f8bc2f93f5fae8bbdb2eb97dd"
+__dirty__ = False

{prefect_client-3.6.28.dev3 → prefect_client-3.6.28.dev4}/src/prefect/_experimental/bundles/__init__.py

@@ -23,7 +23,10 @@ from typing_extensions import Literal, NotRequired, TypeAlias
 
 import anyio
 import cloudpickle  # pyright: ignore[reportMissingTypeStubs]
+from packaging.requirements import InvalidRequirement, Requirement
+from packaging.version import Version
 
+import prefect
 from prefect._internal.control_listener import configure_from_env
 from prefect.client.schemas.objects import FlowRun
 from prefect.context import SettingsContext, get_settings_context, serialize_context
@@ -616,6 +619,52 @@ def execute_bundle_in_subprocess(
     return process
 
 
+def _pin_prefect_in_bundle_step_requires(requires: list[str]) -> list[str]:
+    """
+    Ensure the `uv run --with` requirements for an outer bundle-step process
+    include the exact current publishable Prefect version.
+
+    The outer bundle-step process imports Prefect before the bundle's frozen
+    dependencies are installed, so transitive constraints like
+    `prefect>=3.6.24` from integration packages can otherwise resolve an
+    older stable Prefect even when the bundle was built against a newer
+    version. Pinning `prefect=={prefect.__version__}` keeps the outer
+    process on the same version the bundle was built with.
+
+    - Rewrites any existing `prefect` (or `prefect[...]`) requirement to the
+      exact current version, preserving extras and markers.
+    - Appends `prefect=={prefect.__version__}` if no Prefect requirement is
+      present.
+    - Returns the requirements unchanged for local/unpublishable versions,
+      matching the behavior of `prefect._internal.installation`.
+    """
+    version = Version(prefect.__version__)
+    if version.local:
+        return requires
+
+    pinned_version = prefect.__version__
+    updated: list[str] = []
+    found_prefect = False
+    for requirement in requires:
+        try:
+            parsed = Requirement(requirement)
+        except InvalidRequirement:
+            updated.append(requirement)
+            continue
+        if parsed.name.lower() != "prefect":
+            updated.append(requirement)
+            continue
+        found_prefect = True
+        extras = f"[{','.join(sorted(parsed.extras))}]" if parsed.extras else ""
+        marker = f" ; {parsed.marker}" if parsed.marker else ""
+        updated.append(f"prefect{extras}=={pinned_version}{marker}")
+
+    if not found_prefect:
+        updated.append(f"prefect=={pinned_version}")
+
+    return updated
+
+
 def convert_step_to_command(
     step: dict[str, Any], key: str, quiet: bool = False
 ) -> list[str]:
@@ -655,6 +704,13 @@ def convert_step_to_command(
         if quiet:
             command.append("--quiet")
 
+        # Pin the outer bundle-step process to the current publishable Prefect
+        # version so integration `requires` like `prefect-aws>=0.5.5` cannot
+        # resolve an older stable Prefect via transitive `prefect>=...`
+        # constraints before the bundle's frozen dependencies are applied.
+        if requires:
+            requires = _pin_prefect_in_bundle_step_requires(requires)
+
         # Add the `--with` argument to handle dependencies for running the step
         if requires:
             command.extend(["--with", ",".join(requires)])

{prefect_client-3.6.28.dev3 → prefect_client-3.6.28.dev4}/src/prefect/_internal/compatibility/deprecated.py

@@ -91,8 +91,14 @@ def generate_deprecation_message(
         if sys.version_info >= (3, 13):
             from whenever import PlainDateTime
 
+            _pdt_from_dt = (
+                PlainDateTime
+                if hasattr(PlainDateTime, "to_stdlib")
+                else PlainDateTime.from_py_datetime
+            )
+            _dt = _pdt_from_dt(start_date).add(months=6)
             end_date = (
-                PlainDateTime.from_py_datetime(start_date).add(months=6).py_datetime()
+                _dt.to_stdlib() if hasattr(_dt, "to_stdlib") else _dt.py_datetime()
             )
         else:
             import pendulum

{prefect_client-3.6.28.dev3 → prefect_client-3.6.28.dev4}/src/prefect/_result_records.py

@@ -17,6 +17,7 @@ from pydantic import (
     BaseModel,
     Field,
     ValidationError,
+    field_validator,
     model_validator,
 )
 
@@ -24,8 +25,9 @@ import prefect
 from prefect.exceptions import (
     SerializationError,
 )
-from prefect.serializers import PickleSerializer, Serializer
+from prefect.serializers import PickleSerializer, Serializer, UnknownSerializer
 from prefect.types import DateTime
+from prefect.utilities.dispatch import lookup_type
 
 if TYPE_CHECKING:
     pass
@@ -49,6 +51,19 @@ class ResultRecordMetadata(BaseModel):
     prefect_version: str = Field(default=prefect.__version__)
     storage_block_id: Optional[uuid.UUID] = Field(default=None)
 
+    @field_validator("serializer", mode="before")
+    @classmethod
+    def _tolerate_unknown_serializer(
+        cls, value: Serializer | dict[str, Any] | Any
+    ) -> Serializer | dict[str, Any] | Any:
+        if isinstance(value, dict) and "type" in value:
+            try:
+                lookup_type(Serializer, dispatch_key=value["type"])
+            except KeyError:
+                return UnknownSerializer.model_construct(**value)
+            return Serializer(**value)
+        return value
+
     def dump_bytes(self) -> bytes:
         """
         Serialize the metadata to bytes.

{prefect_client-3.6.28.dev3 → prefect_client-3.6.28.dev4}/src/prefect/serializers.py

@@ -132,9 +132,16 @@ class Serializer(BaseModel, Generic[D]):
             except KeyError as exc:
                 raise ValidationError.from_exception_data(
                     title=cls.__name__,
-                    line_errors=[{"type": str(exc), "input": kwargs["type"]}],
+                    line_errors=[
+                        {
+                            "type": "value_error",
+                            "loc": ("type",),
+                            "input": kwargs["type"],
+                            "ctx": {"error": exc},
+                        }
+                    ],
                     input_type="python",
-                )
+                ) from exc
 
             return super().__new__(subcls)
         else:
@@ -158,6 +165,35 @@ class Serializer(BaseModel, Generic[D]):
         return type_str if isinstance(type_str, str) else None
 
 
+class UnknownSerializer(Serializer):
+    """
+    Opaque placeholder for serializers that are unavailable in the current process.
+
+    This allows persisted result metadata to be inspected without importing the custom
+    serializer implementation. Actual serialization work still fails when attempted.
+    """
+
+    type: str
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="allow")
+
+    @classmethod
+    def __dispatch_key__(cls) -> str:
+        return "__unknown__"
+
+    def dumps(self, obj: Any) -> bytes:
+        raise RuntimeError(
+            f"Serializer {self.type!r} is not available in this environment, so "
+            "serialization cannot be performed."
+        )
+
+    def loads(self, blob: bytes) -> Any:
+        raise RuntimeError(
+            f"Serializer {self.type!r} is not available in this environment, so "
+            "deserialization cannot be performed."
+        )
+
+
 class PickleSerializer(Serializer[D]):
     """
     Serializes objects using the pickle protocol.

{prefect_client-3.6.28.dev3 → prefect_client-3.6.28.dev4}/src/prefect/types/_datetime.py

@@ -14,12 +14,24 @@ from typing_extensions import TypeAlias
 
 if sys.version_info >= (3, 13):
     from whenever import DateTimeDelta
+    from whenever import ZonedDateTime as _ZDTProbe
+
+    # True on whenever >= 0.10.0, which introduced ZonedDateTime(stdlib_dt),
+    # start_of("day"), and to_stdlib(). False on 0.7.x–0.9.x.
+    _WHENEVER_NEW_API: bool = hasattr(_ZDTProbe, "to_stdlib")
+    del _ZDTProbe
 
     DateTime: TypeAlias = datetime.datetime
     Date: TypeAlias = datetime.date
     Duration: TypeAlias = datetime.timedelta
-    Interval: TypeAlias = Union[datetime.timedelta, DateTimeDelta]
+    if _WHENEVER_NEW_API:
+        from whenever import ItemizedDelta
+
+        Interval: TypeAlias = Union[datetime.timedelta, ItemizedDelta]
+    else:
+        Interval: TypeAlias = Union[datetime.timedelta, DateTimeDelta]
 else:
+    _WHENEVER_NEW_API = False
     import pendulum
     import pendulum.tz
     from pydantic_extra_types.pendulum_dt import (
@@ -115,6 +127,44 @@ def human_friendly_diff(
     return pendulum_dt.diff_for_humans(other=pendulum_other)
 
 
+def _whenever_to_stdlib(obj: Any) -> datetime.datetime:
+    """Convert a whenever datetime object to a stdlib datetime.
+
+    Prefers `to_stdlib()` (newer whenever) and falls back to `py_datetime()`
+    for older releases that don't yet expose `to_stdlib()`.
+    """
+    to_stdlib = getattr(obj, "to_stdlib", None)
+    if callable(to_stdlib):
+        return cast(datetime.datetime, to_stdlib())
+    return cast(datetime.datetime, obj.py_datetime())
+
+
+def _whenever_zdt_from_py(dt: datetime.datetime) -> Any:
+    """Create a ZonedDateTime from a stdlib datetime.
+
+    whenever >= 0.10.0 accepts a stdlib datetime directly in the constructor.
+    Older versions require the `from_py_datetime()` classmethod.
+    """
+    from whenever import ZonedDateTime
+
+    if _WHENEVER_NEW_API:
+        return ZonedDateTime(dt)  # type: ignore[arg-type]
+    return ZonedDateTime.from_py_datetime(dt)
+
+
+def _whenever_pdt_from_py(dt: datetime.datetime) -> Any:
+    """Create a PlainDateTime from a naive stdlib datetime.
+
+    whenever >= 0.10.0 accepts a stdlib datetime directly in the constructor.
+    Older versions require the `from_py_datetime()` classmethod.
+    """
+    from whenever import PlainDateTime
+
+    if _WHENEVER_NEW_API:
+        return PlainDateTime(dt)  # type: ignore[arg-type]
+    return PlainDateTime.from_py_datetime(dt)
+
+
 def now(
     tz: str | Any = "UTC",
 ) -> datetime.datetime:
@@ -124,14 +174,7 @@ def now(
         if isinstance(getattr(tz, "name", None), str):
             tz = tz.name
 
-        zoned_datetime = ZonedDateTime.now(tz)
-
-        # `whenever` is deprecating `py_datetime()` in favor of `to_stdlib()`,
-        # but older releases in our supported range do not expose `to_stdlib()`.
-        if callable(to_stdlib := getattr(zoned_datetime, "to_stdlib", None)):
-            return to_stdlib()
-
-        return zoned_datetime.py_datetime()
+        return _whenever_to_stdlib(ZonedDateTime.now(tz))
     else:
         return pendulum.now(tz)
 
@@ -153,14 +196,11 @@ def end_of_period(dt: datetime.datetime, period: str) -> datetime.datetime:
         ValueError: If an invalid unit is specified.
     """
     if sys.version_info >= (3, 13):
-        from whenever import Weekday, ZonedDateTime, days
+        from whenever import Weekday
 
         if not isinstance(dt.tzinfo, ZoneInfo):
-            zdt = ZonedDateTime.from_py_datetime(
-                dt.replace(tzinfo=ZoneInfo(dt.tzname() or "UTC"))
-            )
-        else:
-            zdt = ZonedDateTime.from_py_datetime(dt)
+            dt = dt.replace(tzinfo=ZoneInfo(dt.tzname() or "UTC"))
+        zdt = _whenever_zdt_from_py(dt)
         if period == "second":
             zdt = zdt.replace(nanosecond=999999999)
         elif period == "minute":
@@ -173,7 +213,14 @@ def end_of_period(dt: datetime.datetime, period: str) -> datetime.datetime:
             days_till_end_of_week: int = (
                 Weekday.SUNDAY.value - zdt.date().day_of_week().value
             )
-            zdt = zdt + days(days_till_end_of_week)
+            if _WHENEVER_NEW_API:
+                from whenever import ItemizedDateDelta
+
+                zdt = zdt + ItemizedDateDelta(days=days_till_end_of_week)
+            else:
+                from whenever import days
+
+                zdt = zdt + days(days_till_end_of_week)
             zdt = zdt.replace(
                 hour=23,
                 minute=59,
@@ -183,7 +230,7 @@ def end_of_period(dt: datetime.datetime, period: str) -> datetime.datetime:
         else:
             raise ValueError(f"Invalid period: {period}")
 
-        return zdt.py_datetime()
+        return _whenever_to_stdlib(zdt)
     else:
         return DateTime.instance(dt).end_of(period)
 
@@ -202,16 +249,14 @@ def start_of_day(dt: datetime.datetime | DateTime) -> datetime.datetime:
         ValueError: If an invalid unit is specified.
     """
     if sys.version_info >= (3, 13):
-        from whenever import ZonedDateTime
-
-        if hasattr(dt, "tz"):
-            zdt = ZonedDateTime.from_timestamp(
-                dt.timestamp(), tz=dt.tz.name if dt.tz else "UTC"
-            )
-        else:
-            zdt = ZonedDateTime.from_py_datetime(dt)
-
-        return zdt.start_of_day().py_datetime()
+        zdt = _whenever_zdt_from_py(dt)
+        zdt = (
+            zdt.start_of("day")
+            if callable(getattr(zdt, "start_of", None))
+            else zdt.start_of_day()
+        )
+
+        return _whenever_to_stdlib(zdt)
     else:
         return DateTime.instance(dt).start_of("day")
 
@@ -235,10 +280,8 @@ def travel_to(dt: Any):
 
 def in_local_tz(dt: datetime.datetime) -> datetime.datetime:
     if sys.version_info >= (3, 13):
-        from whenever import PlainDateTime, ZonedDateTime
-
         if dt.tzinfo is None:
-            wdt = PlainDateTime.from_py_datetime(dt)
+            wdt = _whenever_pdt_from_py(dt).assume_system_tz()
         else:
             if not isinstance(dt.tzinfo, ZoneInfo):
                 if key := getattr(dt.tzinfo, "key", None):
@@ -247,11 +290,11 @@ def in_local_tz(dt: datetime.datetime) -> datetime.datetime:
                     utc_dt = dt.astimezone(datetime.timezone.utc)
                     dt = utc_dt.replace(tzinfo=ZoneInfo("UTC"))
 
-            wdt = ZonedDateTime.from_py_datetime(dt).to_system_tz()
-
-        return wdt.py_datetime()
+            wdt = _whenever_zdt_from_py(dt).to_system_tz()
 
-    return DateTime.instance(dt).in_tz(pendulum.tz.local_timezone())
+        return _whenever_to_stdlib(wdt)
+    else:
+        return DateTime.instance(dt).in_tz(pendulum.tz.local_timezone())
 
 
 def to_datetime_string(dt: datetime.datetime, include_tz: bool = True) -> str:
@@ -262,12 +305,19 @@ def to_datetime_string(dt: datetime.datetime, include_tz: bool = True) -> str:
 
 
 def _validate_positive_interval(v: Interval) -> Interval:
-    if sys.version_info >= (3, 13) and isinstance(v, DateTimeDelta):
-        _months, _days, _secs, _nanos = v.in_months_days_secs_nanos()
-        if _months <= 0 and _days <= 0 and _secs <= 0 and _nanos <= 0:
+    if isinstance(v, datetime.timedelta):
+        if v <= datetime.timedelta(0):
             raise ValueError("interval must be positive")
-    elif isinstance(v, datetime.timedelta) and v <= datetime.timedelta(0):
-        raise ValueError("interval must be positive")
+    elif sys.version_info >= (3, 13):
+        if _WHENEVER_NEW_API:
+            from whenever import ItemizedDelta
+
+            if isinstance(v, ItemizedDelta) and v.sign() <= 0:
+                raise ValueError("interval must be positive")
+        elif isinstance(v, DateTimeDelta):
+            _months, _days, _secs, _nanos = v.in_months_days_secs_nanos()
+            if _months <= 0 and _days <= 0 and _secs <= 0 and _nanos <= 0:
+                raise ValueError("interval must be positive")
     return v
 
 

prefect_client-3.6.28.dev3/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.6.28.dev3"
-__build_date__ = "2026-04-21 18:00:52.018663+00:00"
-__git_commit__ = "8b1eae4d8feacb7b4a7bcf5de97c3bee7cf944c6"
-__dirty__ = False