prefect-client 3.7.8.dev3__tar.gz → 3.7.9.dev1__tar.gz

{prefect_client-3.7.8.dev3 → prefect_client-3.7.9.dev1}/PKG-INFO

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

prefect_client-3.7.9.dev1/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.7.9.dev1"
+__build_date__ = "2026-07-12 08:48:30.330243+00:00"
+__git_commit__ = "0e7435055e18952aa8604dab78507b087a18defb"
+__dirty__ = False

{prefect_client-3.7.8.dev3 → prefect_client-3.7.9.dev1}/src/prefect/_internal/schemas/validators.py

@@ -321,6 +321,7 @@ def normalize_rrule_string(
     rrule_string: str,
     *,
     now: Optional[datetime.datetime] = None,
+    timezone: Optional[str] = None,
 ) -> str:
     """Inject a `DTSTART` line into an rrule string if it doesn't already have one.
 
@@ -350,8 +351,16 @@ def normalize_rrule_string(
       datetimes, ~3 MB).
 
     Strings that already contain a `DTSTART` are returned unchanged.
+
+    The injected anchor is written as a floating (offset-less) `DTSTART`,
+    which `RRuleSchedule.to_rrule` later relabels with the schedule's
+    timezone. `timezone` is the schedule's IANA timezone (defaulting to
+    UTC); the recent anchor's wall-clock digits are computed in it so the
+    floating anchor lands on the intended local instant rather than being
+    shifted by the timezone's UTC offset (PrefectHQ/prefect#22455).
     """
     import dateutil.rrule
+    import dateutil.tz
 
     # Already anchored — leave it alone.
     if "DTSTART" in rrule_string.upper():
@@ -400,10 +409,22 @@ def normalize_rrule_string(
     unit_seconds = 1 if freq == dateutil.rrule.SECONDLY else 60
     period_seconds = unit_seconds * interval
 
+    # The injected `DTSTART` is serialized as floating (no offset/`Z`) and
+    # `RRuleSchedule.to_rrule` later relabels it with the schedule's timezone
+    # via `.replace(tzinfo=...)`, which keeps the wall-clock digits without
+    # converting the offset. The anchor's wall-clock digits must therefore be
+    # computed in the schedule's own timezone; computing them in UTC shifts
+    # every occurrence forward by the timezone's offset, suppressing runs on
+    # the deploy day (PrefectHQ/prefect#22455).
+    anchor_tz = dateutil.tz.gettz(timezone) if timezone else datetime.timezone.utc
+    if anchor_tz is None:
+        anchor_tz = datetime.timezone.utc
+
     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)
+        now = datetime.datetime.now(datetime.timezone.utc)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=datetime.timezone.utc)
+    now = now.astimezone(anchor_tz).replace(tzinfo=None)
 
     delta_seconds = (now - DEFAULT_RRULE_ANCHOR).total_seconds()
     if delta_seconds <= 0:
@@ -443,7 +464,9 @@ def normalize_schedule_rrule(schedule: _T) -> _T:
     rrule = getattr(schedule, "rrule", None)
     if not isinstance(rrule, str):
         return schedule
-    normalized = normalize_rrule_string(rrule)
+    normalized = normalize_rrule_string(
+        rrule, timezone=getattr(schedule, "timezone", None)
+    )
     if normalized == rrule:
         return schedule
     return type(schedule)(rrule=normalized, timezone=schedule.timezone)  # type: ignore[call-arg]

{prefect_client-3.7.8.dev3 → prefect_client-3.7.9.dev1}/src/prefect/concurrency/_asyncio.py

@@ -43,6 +43,51 @@ class AcquireConcurrencySlotTimeoutError(TimeoutError):
 logger: logging.Logger = get_logger("concurrency")
 
 
+def _format_http_status_error(exc: httpx.HTTPStatusError) -> str:
+    """Format an HTTP status error from the server into a compact string.
+
+    Handles both Prefect API payloads (`exception_detail`) and raw FastAPI
+    payloads (`detail`), extracting Pydantic-style validation errors and
+    dropping the leading `body` location component.
+    """
+    status_code = exc.response.status_code
+    reason = exc.response.reason_phrase
+    status_text = f"{status_code} {reason}" if reason else str(status_code)
+
+    try:
+        body = exc.response.json()
+    except Exception:
+        body = None
+
+    messages: list[str] = []
+    if isinstance(body, dict):
+        errors = body.get("exception_detail") or body.get("detail")
+        if isinstance(errors, list):
+            for error in errors:
+                if not isinstance(error, dict):
+                    continue
+                msg = error.get("msg")
+                if not isinstance(msg, str):
+                    continue
+                loc = error.get("loc")
+                if isinstance(loc, (list, tuple)) and loc:
+                    if loc[0] == "body":
+                        loc = loc[1:]
+                    field = ".".join(str(part) for part in loc)
+                else:
+                    field = ""
+                if field:
+                    messages.append(f"{field}: {msg}")
+                else:
+                    messages.append(msg)
+        elif isinstance(errors, str):
+            messages.append(errors)
+
+    if messages:
+        return f"{status_text}: {'; '.join(messages)}"
+    return status_text
+
+
 async def aacquire_concurrency_slots(
     names: list[str],
     slots: int,
@@ -59,6 +104,11 @@ async def aacquire_concurrency_slots(
         raise AcquireConcurrencySlotTimeoutError(
             f"Attempt to acquire concurrency slots timed out after {timeout_seconds} second(s)"
         ) from timeout
+    except httpx.HTTPStatusError as exc:
+        raise ConcurrencySlotAcquisitionError(
+            f"Unable to acquire concurrency slots on {names!r}: "
+            f"{_format_http_status_error(exc)}"
+        ) from exc
     except Exception as exc:
         raise ConcurrencySlotAcquisitionError(
             f"Unable to acquire concurrency slots on {names!r}"
@@ -104,6 +154,11 @@ async def aacquire_concurrency_slots_with_lease(
         raise AcquireConcurrencySlotTimeoutError(
             f"Attempt to acquire concurrency slots timed out after {timeout_seconds} second(s)"
         ) from timeout
+    except httpx.HTTPStatusError as exc:
+        raise ConcurrencySlotAcquisitionError(
+            f"Unable to acquire concurrency slots on {names!r}: "
+            f"{_format_http_status_error(exc)}"
+        ) from exc
     except Exception as exc:
         raise ConcurrencySlotAcquisitionError(
             f"Unable to acquire concurrency slots on {names!r}"

{prefect_client-3.7.8.dev3 → prefect_client-3.7.9.dev1}/src/prefect/events/clients.py

@@ -436,8 +436,17 @@ class PrefectEventsClient(EventsClient):
         # Clear the unconfirmed events here, because they are going back through emit
         # and will be added again through the normal checkpointing process
         self._unconfirmed_events = []
-        for event in events_to_resend:
-            await self.emit(event)
+        try:
+            while events_to_resend:
+                event = events_to_resend.pop(0)
+                await self.emit(event)
+        except Exception:
+            # If a resend fails partway through (emit() has its own retry
+            # budget), restore the events that were never attempted so a later
+            # reconnect can retry them. The event whose emit() failed was
+            # already added back to the buffer by emit() itself.
+            self._unconfirmed_events.extend(events_to_resend)
+            raise
         logger.debug("Finished resending unconfirmed events.")
         self._start_checkpoint_task()
 
@@ -452,17 +461,44 @@ class PrefectEventsClient(EventsClient):
 
     async def _checkpoint_loop(self) -> None:
         """Periodically checkpoint unconfirmed events on a time interval,
-        independent of the count-based checkpoint in _checkpoint."""
+        independent of the count-based checkpoint in _checkpoint.
+
+        If the connection has been lost (e.g. a server restart closed it),
+        reconnects and resends the unconfirmed events rather than leaving them
+        stranded until the next emit."""
         while True:
             await asyncio.sleep(self._checkpoint_interval)
-            if self._websocket and self._unconfirmed_events:
-                try:
+            if not self._unconfirmed_events:
+                continue
+            try:
+                if self._websocket:
                     await self._force_checkpoint()
+                    continue
+                # The connection was lost while events were still unconfirmed;
+                # reconnect to resend them rather than waiting for the next emit.
+                await self._reconnect()
+            except ConnectionClosed:
+                # The connection died since the last checkpoint; reconnect and
+                # resend the unconfirmed events. _reconnect() tears down the
+                # dead connection before connecting again.
+                try:
+                    await self._reconnect()
                 except Exception:
                     logger.debug(
-                        "Time-based checkpoint failed, will retry next interval.",
+                        "Reconnecting during time-based checkpoint failed, "
+                        "will retry next interval.",
                         exc_info=True,
                     )
+                    continue
+            except Exception:
+                logger.debug(
+                    "Time-based checkpoint failed, will retry next interval.",
+                    exc_info=True,
+                )
+                continue
+            # A successful _reconnect() resent the unconfirmed events and
+            # started a replacement checkpoint task, so this task is done.
+            return
 
     async def _force_checkpoint(self) -> None:
         """Checkpoint all unconfirmed events unconditionally."""

{prefect_client-3.7.8.dev3 → prefect_client-3.7.9.dev1}/src/prefect/filesystems.py

@@ -412,14 +412,54 @@ class RemoteFileSystem(WritableFileSystem, WritableDeploymentStorage):
 
         # Confirm that absolute paths are valid
         if scheme:
-            if scheme != base_scheme:
+            if scheme.lower() != base_scheme.lower():
                 raise ValueError(
                     f"Path {path!r} with scheme {scheme!r} must use the same scheme as"
                     f" the base path {base_scheme!r}."
                 )
 
         if netloc:
-            if (netloc != base_netloc) or not urlpath.startswith(base_urlpath):
+            if netloc != base_netloc:
+                raise ValueError(
+                    f"Path {path!r} is outside of the base path {self.basepath!r}."
+                )
+
+            # Normalize the base path for containment checks so that sibling prefixes
+            # (e.g. base `/foo` vs path `/foobar`) are not treated as contained.
+            base_path = base_urlpath.rstrip("/")
+            base_output_path = base_path + "/" if base_path else "/"
+
+            if not urlpath:
+                urlpath = "/"
+
+            # Decode percent-encoded and backslash separators only for traversal
+            # checks. The containment check below uses the raw URL path so that
+            # prefix spoofs such as `pre%66ix` or `prefix%2Fchild` are rejected.
+            decoded_path = urllib.parse.unquote(urlpath).replace("\\", "/")
+            if any(segment == ".." for segment in decoded_path.split("/")):
+                raise ValueError(
+                    f"Path {path!r} is outside of the base path {self.basepath!r}."
+                )
+
+            if urlpath == base_path or urlpath == base_output_path:
+                return urllib.parse.urlunsplit(
+                    (base_scheme, base_netloc, base_output_path, "", "")
+                )
+
+            if (base_path and urlpath.startswith(base_path + "/")) or (
+                not base_path and urlpath.startswith("/")
+            ):
+                return urllib.parse.urlunsplit(
+                    (base_scheme, base_netloc, urlpath, "", "")
+                )
+
+            raise ValueError(
+                f"Path {path!r} is outside of the base path {self.basepath!r}."
+            )
+
+        if scheme:
+            decoded_path = urllib.parse.unquote(urlpath).replace("\\", "/")
+            if any(segment == ".." for segment in decoded_path.split("/")):
                 raise ValueError(
                     f"Path {path!r} is outside of the base path {self.basepath!r}."
                 )

{prefect_client-3.7.8.dev3 → prefect_client-3.7.9.dev1}/src/prefect/workers/_worker_channel/_transport.py

@@ -143,7 +143,12 @@ class WorkerChannelTransport:
 
         status_code = self._status_code_from_exception(exc)
         if status_code is not None:
-            if status_code in {401, 403}:
+            if status_code == 401:
+                return WorkerChannelTerminalError(
+                    WorkerChannelCloseReason.AUTHENTICATION_FAILED.value,
+                    "Worker channel setup was rejected by the server",
+                )
+            if status_code == 403:
                 return WorkerChannelTerminalError(
                     WorkerChannelCloseReason.AUTHORIZATION_FAILED.value,
                     "Worker channel setup was rejected by the server",

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

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.7.8.dev3"
-__build_date__ = "2026-07-08 08:56:31.022641+00:00"
-__git_commit__ = "b2c95fd622d9ba86e5da2be0f7a63d4017f2a695"
-__dirty__ = False