prefect-client 3.7.4.dev3__tar.gz → 3.7.5__tar.gz

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.7.4.dev3
+Version: 3.7.5
 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.5/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.7.5"
+__build_date__ = "2026-06-18 21:29:47.502929+00:00"
+__git_commit__ = "756685ab55d5afe34017dc5c7ab68cf79600d664"
+__dirty__ = False

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/_internal/concurrency/threads.py

@@ -38,9 +38,18 @@ def _reset_after_fork_in_child():
 
     This handler is called by os.register_at_fork() in the child process after fork().
     """
+    global _global_loop, _run_sync_loop
+
     for instance in list(_active_instances):
         instance.reset_for_fork()
 
+    # Clear global references so get_global_loop() / get_run_sync_loop() create
+    # fresh instances.  After fork the old EventLoopThread objects have a stale
+    # Thread whose is_alive() still returns True (the dead thread's tstate lock
+    # is held), so the "is the thread alive?" guard in the getters never fires.
+    _global_loop = None
+    _run_sync_loop = None
+
 
 # Register fork handler if supported (POSIX systems)
 if hasattr(os, "register_at_fork"):

prefect_client-3.7.5/src/prefect/_internal/schemas/_registry.py

@@ -0,0 +1,13 @@
+from referencing import Registry
+
+
+def non_fetching_registry() -> Registry:
+    """An empty `referencing.Registry` that disables remote `$ref` fetching.
+
+    Passing an explicit registry to jsonschema suppresses its default behavior of
+    fetching `$ref` URLs over the network while validating an instance. With an
+    empty registry, external references raise `referencing.exceptions.Unresolvable`
+    without any network request, while in-document references (`#/$defs/...`) still
+    resolve normally.
+    """
+    return Registry()

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/_internal/schemas/validators.py

@@ -21,7 +21,9 @@ from uuid import UUID
 from zoneinfo import ZoneInfo
 
 import jsonschema
+import referencing.exceptions
 
+from prefect._internal.schemas._registry import non_fetching_registry
 from prefect.types._datetime import DateTime, create_datetime_instance, get_timezones
 from prefect.utilities.collections import isiterable
 from prefect.utilities.filesystem import relative_path_to_current_platform
@@ -65,7 +67,9 @@ def validate_values_conform_to_schema(
 
     try:
         if schema is not None and values is not None:
-            jsonschema.validate(values, schema)
+            jsonschema.validate(values, schema, registry=non_fetching_registry())
+    except referencing.exceptions.Unresolvable as exc:
+        raise ValueError(f"Validation failed. Failure reason: {exc}") from exc
     except jsonschema.ValidationError as exc:
         if exc.json_path == "$":
             error_message = "Validation failed."

prefect_client-3.7.5/src/prefect/_internal/urls.py

@@ -0,0 +1,57 @@
+import re
+from collections.abc import Iterable
+from urllib.parse import urlparse, urlunparse
+
+_URL_AUTH_PATTERN = re.compile(
+    r"(?P<scheme>https?://)[^/\s'\"<>]*@", flags=re.IGNORECASE
+)
+
+
+def strip_auth_from_url(url: str) -> str:
+    """
+    Remove authentication credentials (username/password) from a URL.
+
+    Useful for sanitizing URLs before including them in error messages
+    or logs to avoid leaking secrets.
+    """
+    try:
+        parsed = urlparse(url)
+
+        if not parsed.hostname:
+            return url
+
+        netloc = parsed.hostname
+        if parsed.port:
+            netloc = f"{netloc}:{parsed.port}"
+
+        return urlunparse(
+            (
+                parsed.scheme,
+                netloc,
+                parsed.path,
+                parsed.params,
+                parsed.query,
+                parsed.fragment,
+            )
+        )
+    except ValueError:
+        return strip_auth_from_urls_in_text(url)
+
+
+def strip_auth_from_urls_in_text(
+    text: str, extra_secrets: Iterable[str] | None = None
+) -> str:
+    """
+    Remove authentication credentials from HTTP(S) URLs embedded in text.
+
+    Useful for sanitizing command output before including it in error messages
+    or logs. Any caller-supplied secrets are replaced with a redaction marker.
+    """
+    if not text:
+        return text
+
+    sanitized = _URL_AUTH_PATTERN.sub(r"\g<scheme>", text)
+    for secret in extra_secrets or ():
+        if secret:
+            sanitized = sanitized.replace(secret, "***")
+    return sanitized

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/client/schemas/actions.py

@@ -6,6 +6,7 @@ from typing import Annotated, Any, Callable, Optional, TypeVar, Union
 from uuid import UUID, uuid4
 
 import jsonschema
+import referencing.exceptions
 from pydantic import (
     AfterValidator,
     BaseModel,
@@ -18,6 +19,7 @@ from pydantic import (
 import prefect.client.schemas.objects as objects
 from prefect._internal.result_records import ResultRecordMetadata
 from prefect._internal.schema import ParameterSchema
+from prefect._internal.schemas._registry import non_fetching_registry
 from prefect._internal.schemas.bases import ActionBaseModel
 from prefect._internal.schemas.validators import (
     convert_to_strings,
@@ -324,7 +326,14 @@ class DeploymentCreate(ActionBaseModel):
                     if "default" in v and k in required:
                         required.remove(k)
 
-            jsonschema.validate(self.job_variables, variables_schema)
+            try:
+                jsonschema.validate(
+                    self.job_variables,
+                    variables_schema,
+                    registry=non_fetching_registry(),
+                )
+            except referencing.exceptions.Unresolvable as exc:
+                raise jsonschema.ValidationError(str(exc)) from exc
 
 
 class DeploymentUpdate(ActionBaseModel):
@@ -403,7 +412,14 @@ class DeploymentUpdate(ActionBaseModel):
                         required.remove(k)
 
         if variables_schema is not None:
-            jsonschema.validate(self.job_variables, variables_schema)
+            try:
+                jsonschema.validate(
+                    self.job_variables,
+                    variables_schema,
+                    registry=non_fetching_registry(),
+                )
+            except referencing.exceptions.Unresolvable as exc:
+                raise jsonschema.ValidationError(str(exc)) from exc
 
 
 class DeploymentBranch(ActionBaseModel):

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/client/schemas/schedules.py

@@ -26,6 +26,26 @@ MAX_ITERATIONS = 1000
 MAX_RRULE_LENGTH = 6500
 
 
+def _iana_timezone_name(tzinfo: datetime.tzinfo) -> str:
+    """Return a valid IANA timezone name for *tzinfo*, or `"UTC"`."""
+    for attr in ("key", "name"):
+        value: Optional[str] = getattr(tzinfo, attr, None)
+        if value and is_valid_timezone(value):
+            return value
+
+    filename: Optional[str] = getattr(tzinfo, "_filename", None)
+    if filename:
+        normalized = filename.replace("\\", "/")
+        marker = "/zoneinfo/"
+        idx = normalized.find(marker)
+        if idx != -1:
+            candidate = normalized[idx + len(marker) :]
+            if candidate and is_valid_timezone(candidate):
+                return candidate
+
+    return "UTC"
+
+
 def is_valid_timezone(v: str) -> bool:
     """
     Validate that the provided timezone is a valid IANA timezone.
@@ -204,26 +224,27 @@ class RRuleSchedule(PrefectBaseModel):
         if isinstance(rrule, dateutil.rrule.rrule):
             dtstart = _rrule_dt(rrule)
             if dtstart and dtstart.tzinfo is not None:
-                timezone = dtstart.tzinfo.tzname(dtstart)
+                timezone = _iana_timezone_name(dtstart.tzinfo)
             else:
                 timezone = "UTC"
             return RRuleSchedule(rrule=str(rrule), timezone=timezone)
         rrules = _rrule(rrule)
         dtstarts = [dts for rr in rrules if (dts := _rrule_dt(rr)) is not None]
         unique_dstarts = set(d.astimezone(ZoneInfo("UTC")) for d in dtstarts)
-        unique_timezones = set(d.tzinfo for d in dtstarts if d.tzinfo is not None)
+        unique_tz_names = set(
+            _iana_timezone_name(d.tzinfo) for d in dtstarts if d.tzinfo is not None
+        )
 
-        if len(unique_timezones) > 1:
+        if len(unique_tz_names) > 1:
             raise ValueError(
-                f"rruleset has too many dtstart timezones: {unique_timezones}"
+                f"rruleset has too many dtstart timezones: {unique_tz_names}"
             )
 
         if len(unique_dstarts) > 1:
             raise ValueError(f"rruleset has too many dtstarts: {unique_dstarts}")
 
-        if unique_dstarts and unique_timezones:
-            [unique_tz] = unique_timezones
-            timezone = unique_tz.tzname(dtstarts[0])
+        if unique_dstarts and unique_tz_names:
+            [timezone] = unique_tz_names
         else:
             timezone = "UTC"
 

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/deployments/base.py

@@ -278,6 +278,33 @@ def _interval_schedule_to_dict(schedule: IntervalSchedule) -> dict[str, Any]:
     return schedule_config
 
 
+def _deployment_already_saved_to_prefect_file(
+    deployment: dict[str, Any],
+    prefect_file: Path = Path("prefect.yaml"),
+) -> bool:
+    """
+    Return True if `prefect.yaml` already contains a deployment entry matching the
+    given deployment's name and entrypoint.
+
+    Used to decide whether the interactive `prefect deploy` flow should offer to
+    persist a newly-created deployment: a deployment that is already declared in
+    the file does not need to be saved again, but a brand-new one (even when the
+    file otherwise exists) should still be offered up for saving.
+    """
+    if not prefect_file.exists():
+        return False
+
+    with prefect_file.open(mode="r") as f:
+        contents = yaml.safe_load(f) or {}
+
+    for existing in contents.get("deployments") or []:
+        if existing.get("name") == deployment.get("name") and existing.get(
+            "entrypoint"
+        ) == deployment.get("entrypoint"):
+            return True
+    return False
+
+
 def _save_deployment_to_prefect_file(
     deployment: dict[str, Any],
     build_steps: list[dict[str, Any]] | None = None,

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/flow_engine.py

@@ -972,6 +972,7 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
             parent_task = Task(
                 name=self.flow.name, fn=self.flow.fn, version=self.flow.version
             )
+            setattr(parent_task, "_is_subflow_tracking_task", True)
 
             parent_task_run = run_coro_as_sync(
                 parent_task.create_run(
@@ -1667,6 +1668,7 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
             parent_task = Task(
                 name=self.flow.name, fn=self.flow.fn, version=self.flow.version
             )
+            setattr(parent_task, "_is_subflow_tracking_task", True)
 
             parent_task_run = await parent_task.create_run(
                 flow_run_context=flow_run_ctx,

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/flows.py

@@ -706,7 +706,11 @@ class Flow(Generic[P, R]):
                 from fastapi.encoders import jsonable_encoder
 
                 serialized_parameters[key] = jsonable_encoder(value)
-            except (TypeError, ValueError):
+            except (TypeError, ValueError, RecursionError):
+                # `jsonable_encoder` recurses into unknown objects with no cycle
+                # or depth limit, so a deeply-nested or self-referential value
+                # raises `RecursionError`. Treat it like any other unserializable
+                # value and fall back to the placeholder below.
                 logger.debug(
                     f"Parameter {key!r} for flow {self.name!r} is unserializable. "
                     f"Type {type(value).__name__!r} and will not be stored "

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/runner/AGENTS.md

@@ -15,7 +15,7 @@ Thin facade over single-responsibility extracted classes. New behavior belongs i
 | CancelFinalizer | _cancel_finalizer.py | Persist Cancelled state after kill; fall back to Crashed if state cannot be confirmed |
 | ControlChannel | _control_channel.py | Runner-side TCP loopback IPC for delivering cancel intent to child processes before kill |
 | HookRunner | _hook_runner.py | on_cancellation / on_crashed hook execution |
-| EventEmitter | _event_emitter.py | Event emission via EventsClient; degrades to NullEventsClient on WebSocket rejection |
+| EventEmitter | _event_emitter.py | Event emission via EventsClient; degrades to NullEventsClient on any WebSocket connection failure |
 | LimitManager | _limit_manager.py | Concurrency limiting |
 | DeploymentRegistry | _deployment_registry.py | Deployment/flow/storage/bundle maps |
 | ScheduledRunPoller | _scheduled_run_poller.py | Poll loop, run discovery, scheduling |
@@ -49,7 +49,7 @@ These will be removed once internal callers (notably ProcessWorker) are migrated
 
 ## EventEmitter WebSocket Degradation
 
-`EventEmitter.__aenter__` catches `websockets.exceptions.InvalidStatus` (HTTP 4xx rejections) and silently swaps the failed client for a `NullEventsClient`. This handles old clients (≤3.6.13) connecting to servers ≥3.6.14 with `PREFECT_SERVER_API_AUTH_STRING` configured — the server rejects the WebSocket handshake, but events are non-critical telemetry so the flow run must not crash. A `WARNING` is logged. If `__aenter__` raises, `__aexit__` is **not** called on the original client (it was never successfully entered); the replacement `NullEventsClient` is entered instead.
+`EventEmitter.__aenter__` catches connection failures and silently swaps the failed client for a `NullEventsClient` — events are non-critical telemetry (the runner emits only `prefect.runner.cancelled-flow-run`), so the flow run must not crash when the events WebSocket is unreachable. Two failure classes are caught (`_NONFATAL_CONNECTION_EXCEPTIONS`): permanent rejections (`websockets.exceptions.InvalidStatus`, i.e. HTTP 4xx — e.g. a client ≤3.6.13 connecting to a server ≥3.6.14 with `PREFECT_SERVER_API_AUTH_STRING` configured) and transient failures (`RETRYABLE_EXCEPTIONS` from `events/clients.py`: `ConnectionClosed`, `TimeoutError`, `OSError`) that outlive the events client's own reconnection attempts. A `WARNING` is logged. If `__aenter__` raises, `__aexit__` is **not** called on the original client (it was never successfully entered); the replacement `NullEventsClient` is entered instead.
 
 ## AsyncExitStack LIFO Ordering
 

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/runner/_event_emitter.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Callable
 from cachetools import TTLCache
 from websockets.exceptions import InvalidStatus as _WsInvalidStatus
 
-from prefect.events.clients import NullEventsClient
+from prefect.events.clients import RETRYABLE_EXCEPTIONS, NullEventsClient
 from prefect.events.related import tags_as_related_resources
 from prefect.events.schemas.events import Event, RelatedResource, Resource
 from prefect.logging import get_logger
@@ -18,12 +18,19 @@ if TYPE_CHECKING:
     from prefect.client.schemas.responses import DeploymentResponse
     from prefect.events.clients import EventsClient
 
-# Exceptions that indicate a permanent connection failure (e.g. auth rejected).
-# On these, EventEmitter degrades gracefully to NullEventsClient rather than
-# crashing the flow run.  This preserves backwards-compatibility with clients
-# running against a server that has PREFECT_SERVER_API_AUTH_STRING configured
-# (server >=3.6.14) where the WS handshake is rejected with HTTP 401/403.
-_NONFATAL_CONNECTION_EXCEPTIONS: tuple[type[Exception], ...] = (_WsInvalidStatus,)
+# Connection failures that must not crash the flow run.  The events WebSocket
+# carries non-critical telemetry, so a failure to connect degrades to
+# NullEventsClient rather than taking the flow run down with it.
+# - _WsInvalidStatus: the server rejected the handshake (HTTP 401/403), e.g. a
+#   client <=3.6.13 connecting to a server >=3.6.14 that has
+#   PREFECT_SERVER_API_AUTH_STRING configured.  A permanent failure.
+# - RETRYABLE_EXCEPTIONS: transient failures (handshake timeout, dropped
+#   connection, network errors) that the events client already retries; once
+#   those retries are exhausted the error must still not be fatal here.
+_NONFATAL_CONNECTION_EXCEPTIONS: tuple[type[Exception], ...] = (
+    _WsInvalidStatus,
+    *RETRYABLE_EXCEPTIONS,
+)
 
 
 def _default_get_events_client() -> "EventsClient":
@@ -60,17 +67,18 @@ class EventEmitter:
         try:
             await self._events_client.__aenter__()
         except _NONFATAL_CONNECTION_EXCEPTIONS as exc:
-            # The events WebSocket was rejected by the server (e.g. HTTP 401/403).
-            # This happens when an old client (<=3.6.13) connects to a server
-            # >=3.6.14 that has PREFECT_SERVER_API_AUTH_STRING configured: the
-            # server now requires the "prefect" subprotocol + auth handshake, but
-            # old clients omit it.  Events are non-critical telemetry, so we
-            # degrade gracefully instead of crashing the flow run.
+            # The events WebSocket could not be established -- either rejected by
+            # the server (HTTP 401/403, e.g. a client <=3.6.13 connecting to a
+            # server >=3.6.14 with PREFECT_SERVER_API_AUTH_STRING configured) or a
+            # transient connection failure that outlived the events client's own
+            # retries.  Events are non-critical telemetry, so degrade gracefully
+            # instead of crashing the flow run.
             self._logger.warning(
                 "Unable to connect to the events WebSocket (%s). "
-                "Event data will not be emitted for this runner. "
-                "Upgrade the Prefect client to >=3.6.14 to restore event support "
-                "when the server has authentication configured.",
+                "Event data will not be emitted for this runner; the flow run "
+                "will continue. Upgrade the Prefect client to >=3.6.14 to "
+                "restore event support if the server has authentication "
+                "configured.",
                 exc,
             )
             # __aenter__ failed, so __aexit__ must NOT be called on the original

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/runner/storage.py

@@ -14,7 +14,7 @@ from typing import (
     Union,
     runtime_checkable,
 )
-from urllib.parse import quote, urlparse, urlsplit, urlunparse
+from urllib.parse import quote, unquote, urlparse, urlsplit, urlunparse
 from uuid import uuid4
 
 import fsspec  # pyright: ignore[reportMissingTypeStubs]
@@ -22,7 +22,7 @@ from anyio import run_process
 from pydantic import SecretStr
 
 from prefect._internal.concurrency.api import create_call, from_async
-from prefect._internal.urls import strip_auth_from_url
+from prefect._internal.urls import strip_auth_from_url, strip_auth_from_urls_in_text
 from prefect.blocks.core import Block, BlockNotSavedError
 from prefect.blocks.system import Secret
 from prefect.filesystems import ReadableDeploymentStorage, WritableDeploymentStorage
@@ -499,6 +499,21 @@ class GitRepository:
                 else exc
             )
             safe_url = strip_auth_from_url(self._url)
+            sanitized_stderr = strip_auth_from_urls_in_text(
+                _decode_stderr(exc),
+                extra_secrets=_url_auth_secrets(self._url, repository_url),
+            )
+            # Surface the raw git error at DEBUG so users can opt in via log
+            # level when the hint patterns don't match. The exception chain is
+            # suppressed above when credentials are present, so DEBUG is the
+            # only way to see the actual git output in that case.
+            if sanitized_stderr:
+                self._logger.debug(
+                    "git clone failed (exit %d) for %r: %s",
+                    exc.returncode,
+                    safe_url,
+                    sanitized_stderr.strip(),
+                )
             error_message = (
                 f"Failed to clone repository {safe_url!r} with exit code"
                 f" {exc.returncode}."
@@ -506,6 +521,14 @@ class GitRepository:
             hint = _get_git_clone_error_hint(exc)
             if hint:
                 error_message += f" {hint}"
+            elif sanitized_stderr:
+                # No pattern matched -- surface the actual git error so the
+                # user doesn't have to enable DEBUG to know what went wrong.
+                snippet = sanitized_stderr.strip().splitlines()
+                # Keep the last few lines; git's final 'fatal:' line is usually
+                # the actionable one.
+                tail = " | ".join(snippet[-3:])
+                error_message += f" git stderr: {tail}"
             raise RuntimeError(error_message) from exc_chain
 
         if self._commit_sha:
@@ -985,15 +1008,34 @@ _GIT_CLONE_ERROR_HINTS: list[tuple[str, str]] = [
 ]
 
 
+def _decode_stderr(exc: subprocess.CalledProcessError) -> str:
+    """Decode a CalledProcessError's stderr to text, tolerating bytes/None."""
+    if not exc.stderr:
+        return ""
+    if isinstance(exc.stderr, bytes):
+        return exc.stderr.decode("utf-8", errors="replace")
+    return str(exc.stderr)
+
+
+def _url_auth_secrets(*urls: str) -> list[str]:
+    """Extract userinfo values from URLs so echoed auth can be redacted."""
+    secrets: list[str] = []
+    seen: set[str] = set()
+    for url in urls:
+        parsed = urlparse(url)
+        for value in (parsed.username, parsed.password):
+            if not value:
+                continue
+            for secret in (value, unquote(value)):
+                if secret and secret not in seen:
+                    secrets.append(secret)
+                    seen.add(secret)
+    return secrets
+
+
 def _get_git_clone_error_hint(exc: subprocess.CalledProcessError) -> str | None:
     """Extract a resolution hint from a git clone CalledProcessError's stderr."""
-    stderr = ""
-    if exc.stderr:
-        stderr = (
-            exc.stderr.decode("utf-8", errors="replace")
-            if isinstance(exc.stderr, bytes)
-            else str(exc.stderr)
-        )
+    stderr = _decode_stderr(exc)
     for pattern, hint in _GIT_CLONE_ERROR_HINTS:
         if pattern.lower() in stderr.lower():
             return hint

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/server/api/background_workers.py

@@ -14,6 +14,7 @@ from prefect.server.models.work_queues import mark_work_queues_ready
 from prefect.server.services.cancellation_cleanup import (
     cancel_child_task_runs,
     cancel_subflow_run,
+    handle_cancelling_timeout,
 )
 from prefect.server.services.db_vacuum import (
     vacuum_events_with_retention_overrides,
@@ -40,6 +41,7 @@ task_functions: list[Callable[..., Any]] = [
     delete_task_run_logs,
     delete_flow_run_logs,
     # Find-and-flood pattern tasks used by perpetual services
+    handle_cancelling_timeout,
     cancel_child_task_runs,
     cancel_subflow_run,
     fail_expired_pause,

{prefect_client-3.7.4.dev3 → prefect_client-3.7.5}/src/prefect/server/api/deployments.py

@@ -311,7 +311,11 @@ async def update_deployment(
             )
             try:
                 deployment.check_valid_configuration(work_pool.base_job_template)
-            except (MissingVariableError, jsonschema.exceptions.ValidationError) as exc:
+            except (
+                MissingVariableError,
+                jsonschema.exceptions.ValidationError,
+                ValidationError,
+            ) as exc:
                 raise HTTPException(
                     status_code=status.HTTP_409_CONFLICT,
                     detail=f"Error creating deployment: {exc!r}",