prefect-client 3.4.7.dev2__py3-none-any.whl → 3.4.7.dev4__py3-none-any.whl

prefect/AGENTS.md

@@ -0,0 +1,28 @@
+# Core Prefect SDK
+
+The foundation for building and executing workflows with Python.
+
+## Key Components
+
+- **Flows & Tasks**: Workflow definition with `@flow` and `@task` decorators
+- **States**: Execution status tracking (Pending, Running, Completed, Failed)
+- **Context**: Runtime information and dependency injection
+- **Results**: Task output persistence and retrieval
+- **Deployments**: Packaging flows for scheduled/triggered execution
+- **Blocks**: Reusable configuration for external systems
+
+## Main Modules
+
+- `flows.py` - Flow lifecycle and execution
+- `tasks.py` - Task definition and dependency resolution
+- `engine.py` - Core execution engine
+- `client/` - Server/Cloud API communication
+- `deployments/` - Deployment management
+- `blocks/` - Infrastructure and storage blocks
+
+## SDK-Specific Notes
+
+- Async-first execution model with sync support
+- Immutable flow/task definitions after creation
+- State transitions handle retries and caching
+- Backward compatibility required for public APIs

prefect/_build_info.py

@@ -1,5 +1,5 @@
 # Generated by versioningit
-__version__ = "3.4.7.dev2"
-__build_date__ = "2025-06-13 08:09:11.132645+00:00"
-__git_commit__ = "5486631396a72284b1035fd98e50dc6c837d2cd0"
+__version__ = "3.4.7.dev4"
+__build_date__ = "2025-06-18 08:09:28.573646+00:00"
+__git_commit__ = "f2a136e5b5fb96adfde1d9aa44fdedb5b11c97a0"
 __dirty__ = False

prefect/_internal/websockets.py

@@ -0,0 +1,106 @@
+"""
+Internal WebSocket proxy utilities for Prefect client connections.
+
+This module provides shared WebSocket proxy connection logic and SSL configuration
+to avoid duplication between events and logs clients.
+"""
+
+import os
+import ssl
+from typing import Any, Generator, Optional
+from urllib.parse import urlparse
+from urllib.request import proxy_bypass
+
+import certifi
+from python_socks.async_.asyncio import Proxy
+from typing_extensions import Self
+from websockets.asyncio.client import ClientConnection, connect
+
+from prefect.settings import get_current_settings
+
+
+def create_ssl_context_for_websocket(uri: str) -> Optional[ssl.SSLContext]:
+    """Create SSL context for WebSocket connections based on URI scheme."""
+    u = urlparse(uri)
+
+    if u.scheme != "wss":
+        return None
+
+    if get_current_settings().api.tls_insecure_skip_verify:
+        # Create an unverified context for insecure connections
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+    else:
+        # Create a verified context with the certificate file
+        cert_file = get_current_settings().api.ssl_cert_file
+        if not cert_file:
+            cert_file = certifi.where()
+        return ssl.create_default_context(cafile=cert_file)
+
+
+class WebsocketProxyConnect(connect):
+    """
+    WebSocket connection class with proxy and SSL support.
+
+    Extends the websockets.asyncio.client.connect class to add HTTP/HTTPS
+    proxy support via environment variables, proxy bypass logic, and SSL
+    certificate verification.
+    """
+
+    def __init__(self: Self, uri: str, **kwargs: Any):
+        # super() is intentionally deferred to the _proxy_connect method
+        # to allow for the socket to be established first
+
+        self.uri = uri
+        self._kwargs = kwargs
+
+        u = urlparse(uri)
+        host = u.hostname
+
+        if not host:
+            raise ValueError(f"Invalid URI {uri}, no hostname found")
+
+        if u.scheme == "ws":
+            port = u.port or 80
+            proxy_url = os.environ.get("HTTP_PROXY")
+        elif u.scheme == "wss":
+            port = u.port or 443
+            proxy_url = os.environ.get("HTTPS_PROXY")
+            kwargs["server_hostname"] = host
+        else:
+            raise ValueError(
+                "Unsupported scheme %s. Expected 'ws' or 'wss'. " % u.scheme
+            )
+
+        self._proxy = (
+            Proxy.from_url(proxy_url) if proxy_url and not proxy_bypass(host) else None
+        )
+        self._host = host
+        self._port = port
+
+        # Configure SSL context for HTTPS connections
+        ssl_context = create_ssl_context_for_websocket(uri)
+        if ssl_context:
+            self._kwargs.setdefault("ssl", ssl_context)
+
+    async def _proxy_connect(self: Self) -> ClientConnection:
+        if self._proxy:
+            sock = await self._proxy.connect(
+                dest_host=self._host,
+                dest_port=self._port,
+            )
+            self._kwargs["sock"] = sock
+
+        super().__init__(self.uri, **self._kwargs)
+        proto = await self.__await_impl__()
+        return proto
+
+    def __await__(self: Self) -> Generator[Any, None, ClientConnection]:
+        return self._proxy_connect().__await__()
+
+
+def websocket_connect(uri: str, **kwargs: Any) -> WebsocketProxyConnect:
+    """Create a WebSocket connection with proxy and SSL support."""
+    return WebsocketProxyConnect(uri, **kwargs)

prefect/client/cloud.py

@@ -24,6 +24,16 @@ from prefect.settings import (
 
 PARSE_API_URL_REGEX = re.compile(r"accounts/(.{36})/workspaces/(.{36})")
 
+# Cache for TypeAdapter instances to avoid repeated instantiation
+_TYPE_ADAPTER_CACHE: dict[type, pydantic.TypeAdapter[Any]] = {}
+
+
+def _get_type_adapter(type_: type) -> pydantic.TypeAdapter[Any]:
+    """Get or create a cached TypeAdapter for the given type."""
+    if type_ not in _TYPE_ADAPTER_CACHE:
+        _TYPE_ADAPTER_CACHE[type_] = pydantic.TypeAdapter(type_)
+    return _TYPE_ADAPTER_CACHE[type_]
+
 
 def get_cloud_client(
     host: Optional[str] = None,
@@ -112,7 +122,7 @@ class CloudClient:
             await self.read_workspaces()
 
     async def read_workspaces(self) -> list[Workspace]:
-        workspaces = pydantic.TypeAdapter(list[Workspace]).validate_python(
+        workspaces = _get_type_adapter(list[Workspace]).validate_python(
             await self.get("/me/workspaces")
         )
         return workspaces

prefect/client/orchestration/__init__.py

@@ -144,6 +144,16 @@ P = ParamSpec("P")
 R = TypeVar("R", infer_variance=True)
 T = TypeVar("T")
 
+# Cache for TypeAdapter instances to avoid repeated instantiation
+_TYPE_ADAPTER_CACHE: dict[type, pydantic.TypeAdapter[Any]] = {}
+
+
+def _get_type_adapter(type_: type) -> pydantic.TypeAdapter[Any]:
+    """Get or create a cached TypeAdapter for the given type."""
+    if type_ not in _TYPE_ADAPTER_CACHE:
+        _TYPE_ADAPTER_CACHE[type_] = pydantic.TypeAdapter(type_)
+    return _TYPE_ADAPTER_CACHE[type_]
+
 
 @overload
 def get_client(
@@ -635,7 +645,7 @@ class PrefectClient(
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return pydantic.TypeAdapter(list[FlowRun]).validate_python(response.json())
+        return _get_type_adapter(list[FlowRun]).validate_python(response.json())
 
     async def read_work_queue(
         self,
@@ -894,7 +904,7 @@ class PrefectClient(
             "offset": offset,
         }
         response = await self._client.post("/task_runs/filter", json=body)
-        return pydantic.TypeAdapter(list[TaskRun]).validate_python(response.json())
+        return _get_type_adapter(list[TaskRun]).validate_python(response.json())
 
     async def delete_task_run(self, task_run_id: UUID) -> None:
         """
@@ -958,7 +968,7 @@ class PrefectClient(
         response = await self._client.get(
             "/task_run_states/", params=dict(task_run_id=str(task_run_id))
         )
-        return pydantic.TypeAdapter(list[prefect.states.State]).validate_python(
+        return _get_type_adapter(list[prefect.states.State]).validate_python(
             response.json()
         )
 
@@ -1005,7 +1015,7 @@ class PrefectClient(
         else:
             response = await self._client.post("/work_queues/filter", json=json)
 
-        return pydantic.TypeAdapter(list[WorkQueue]).validate_python(response.json())
+        return _get_type_adapter(list[WorkQueue]).validate_python(response.json())
 
     async def read_worker_metadata(self) -> dict[str, Any]:
         """Reads worker metadata stored in Prefect collection registry."""
@@ -1554,7 +1564,7 @@ class SyncPrefectClient(
             "offset": offset,
         }
         response = self._client.post("/task_runs/filter", json=body)
-        return pydantic.TypeAdapter(list[TaskRun]).validate_python(response.json())
+        return _get_type_adapter(list[TaskRun]).validate_python(response.json())
 
     def set_task_run_state(
         self,
@@ -1598,6 +1608,6 @@ class SyncPrefectClient(
         response = self._client.get(
             "/task_run_states/", params=dict(task_run_id=str(task_run_id))
         )
-        return pydantic.TypeAdapter(list[prefect.states.State]).validate_python(
+        return _get_type_adapter(list[prefect.states.State]).validate_python(
             response.json()
         )

prefect/client/schemas/objects.py

@@ -279,10 +279,6 @@ class State(TimeSeriesBaseModel, ObjectBaseModel, Generic[R]):
                 if the state is of type `FAILED` and the underlying data is an exception. When flow
                 was run in a different memory space (using `run_deployment`), this will only raise
                 if `fetch` is `True`.
-            fetch: a boolean specifying whether to resolve references to persisted
-                results into data. For synchronous users, this defaults to `True`.
-                For asynchronous users, this defaults to `False` for backwards
-                compatibility.
             retry_result_failure: a boolean specifying whether to retry on failures to
                 load the result from result storage
 

prefect/events/clients.py

@@ -1,7 +1,5 @@
 import abc
 import asyncio
-import os
-import ssl
 from datetime import timedelta
 from types import TracebackType
 from typing import (
@@ -9,7 +7,6 @@ from typing import (
     Any,
     ClassVar,
     Dict,
-    Generator,
     List,
     MutableMapping,
     Optional,
@@ -17,18 +14,14 @@ from typing import (
     Type,
     cast,
 )
-from urllib.parse import urlparse
-from urllib.request import proxy_bypass
 from uuid import UUID
 
-import certifi
 import orjson
 from cachetools import TTLCache
 from prometheus_client import Counter
-from python_socks.async_.asyncio import Proxy
 from typing_extensions import Self
 from websockets import Subprotocol
-from websockets.asyncio.client import ClientConnection, connect
+from websockets.asyncio.client import ClientConnection
 from websockets.exceptions import (
     ConnectionClosed,
     ConnectionClosedError,
@@ -36,13 +29,12 @@ from websockets.exceptions import (
 )
 
 import prefect.types._datetime
+from prefect._internal.websockets import websocket_connect
 from prefect.events import Event
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_API_AUTH_STRING,
     PREFECT_API_KEY,
-    PREFECT_API_SSL_CERT_FILE,
-    PREFECT_API_TLS_INSECURE_SKIP_VERIFY,
     PREFECT_API_URL,
     PREFECT_CLOUD_API_URL,
     PREFECT_DEBUG_MODE,
@@ -94,72 +86,6 @@ def events_out_socket_from_api_url(url: str) -> str:
     return http_to_ws(url) + "/events/out"
 
 
-class WebsocketProxyConnect(connect):
-    def __init__(self: Self, uri: str, **kwargs: Any):
-        # super() is intentionally deferred to the _proxy_connect method
-        # to allow for the socket to be established first
-
-        self.uri = uri
-        self._kwargs = kwargs
-
-        u = urlparse(uri)
-        host = u.hostname
-
-        if not host:
-            raise ValueError(f"Invalid URI {uri}, no hostname found")
-
-        if u.scheme == "ws":
-            port = u.port or 80
-            proxy_url = os.environ.get("HTTP_PROXY")
-        elif u.scheme == "wss":
-            port = u.port or 443
-            proxy_url = os.environ.get("HTTPS_PROXY")
-            kwargs["server_hostname"] = host
-        else:
-            raise ValueError(
-                "Unsupported scheme %s. Expected 'ws' or 'wss'. " % u.scheme
-            )
-
-        self._proxy = (
-            Proxy.from_url(proxy_url) if proxy_url and not proxy_bypass(host) else None
-        )
-        self._host = host
-        self._port = port
-
-        if PREFECT_API_TLS_INSECURE_SKIP_VERIFY and u.scheme == "wss":
-            # Create an unverified context for insecure connections
-            ctx = ssl.create_default_context()
-            ctx.check_hostname = False
-            ctx.verify_mode = ssl.CERT_NONE
-            self._kwargs.setdefault("ssl", ctx)
-        elif u.scheme == "wss":
-            cert_file = PREFECT_API_SSL_CERT_FILE.value()
-            if not cert_file:
-                cert_file = certifi.where()
-            # Create a verified context with the certificate file
-            ctx = ssl.create_default_context(cafile=cert_file)
-            self._kwargs.setdefault("ssl", ctx)
-
-    async def _proxy_connect(self: Self) -> ClientConnection:
-        if self._proxy:
-            sock = await self._proxy.connect(
-                dest_host=self._host,
-                dest_port=self._port,
-            )
-            self._kwargs["sock"] = sock
-
-        super().__init__(self.uri, **self._kwargs)
-        proto = await self.__await_impl__()
-        return proto
-
-    def __await__(self: Self) -> Generator[Any, None, ClientConnection]:
-        return self._proxy_connect().__await__()
-
-
-def websocket_connect(uri: str, **kwargs: Any) -> WebsocketProxyConnect:
-    return WebsocketProxyConnect(uri, **kwargs)
-
-
 def get_events_client(
     reconnection_attempts: int = 10,
     checkpoint_every: int = 700,

prefect/events/schemas/automations.py

@@ -416,7 +416,7 @@ class AutomationCore(PrefectBaseModel, extra="ignore"):  # type: ignore[call-arg
     enabled: bool = Field(
         default=True, description="Whether this automation will be evaluated"
     )
-    tags: list[str] = Field(
+    tags: List[str] = Field(
         default_factory=list,
         description="A list of tags associated with this automation",
     )

prefect/logging/clients.py

@@ -0,0 +1,347 @@
+import asyncio
+from datetime import timedelta
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    MutableMapping,
+    Optional,
+    Tuple,
+    Type,
+    cast,
+)
+from uuid import UUID
+
+import orjson
+from cachetools import TTLCache
+from prometheus_client import Counter
+from typing_extensions import Self
+from websockets import Subprotocol
+from websockets.asyncio.client import ClientConnection
+from websockets.exceptions import (
+    ConnectionClosed,
+    ConnectionClosedError,
+    ConnectionClosedOK,
+)
+
+from prefect._internal.websockets import (
+    create_ssl_context_for_websocket,
+    websocket_connect,
+)
+from prefect.client.schemas.objects import Log
+from prefect.logging import get_logger
+from prefect.settings import (
+    PREFECT_API_AUTH_STRING,
+    PREFECT_API_KEY,
+    PREFECT_API_URL,
+    PREFECT_CLOUD_API_URL,
+    PREFECT_SERVER_ALLOW_EPHEMERAL_MODE,
+)
+from prefect.types._datetime import now
+
+if TYPE_CHECKING:
+    import logging
+
+    from prefect.client.schemas.filters import LogFilter
+
+logger: "logging.Logger" = get_logger(__name__)
+
+LOGS_OBSERVED = Counter(
+    "prefect_logs_observed",
+    "The number of logs observed by Prefect log subscribers",
+    labelnames=["client"],
+)
+LOG_WEBSOCKET_CONNECTIONS = Counter(
+    "prefect_log_websocket_connections",
+    (
+        "The number of times Prefect log clients have connected to a log stream, "
+        "broken down by direction (in/out) and connection (initial/reconnect)"
+    ),
+    labelnames=["client", "direction", "connection"],
+)
+
+SEEN_LOGS_SIZE = 500_000
+SEEN_LOGS_TTL = 120
+
+
+def http_to_ws(url: str) -> str:
+    return url.replace("https://", "wss://").replace("http://", "ws://").rstrip("/")
+
+
+def logs_out_socket_from_api_url(url: str) -> str:
+    return http_to_ws(url) + "/logs/out"
+
+
+def _get_api_url_and_key(
+    api_url: Optional[str], api_key: Optional[str]
+) -> Tuple[str, str]:
+    api_url = api_url or PREFECT_API_URL.value()
+    api_key = api_key or PREFECT_API_KEY.value()
+
+    if not api_url or not api_key:
+        raise ValueError(
+            "api_url and api_key must be provided or set in the Prefect configuration"
+        )
+
+    return api_url, api_key
+
+
+def get_logs_subscriber(
+    filter: Optional["LogFilter"] = None,
+    reconnection_attempts: int = 10,
+) -> "PrefectLogsSubscriber":
+    """
+    Get a logs subscriber based on the current Prefect configuration.
+
+    Similar to get_events_subscriber, this automatically detects whether
+    you're using Prefect Cloud or OSS and returns the appropriate subscriber.
+    """
+    api_url = PREFECT_API_URL.value()
+
+    if isinstance(api_url, str) and api_url.startswith(PREFECT_CLOUD_API_URL.value()):
+        return PrefectCloudLogsSubscriber(
+            filter=filter, reconnection_attempts=reconnection_attempts
+        )
+    elif api_url:
+        return PrefectLogsSubscriber(
+            api_url=api_url,
+            filter=filter,
+            reconnection_attempts=reconnection_attempts,
+        )
+    elif PREFECT_SERVER_ALLOW_EPHEMERAL_MODE:
+        from prefect.server.api.server import SubprocessASGIServer
+
+        server = SubprocessASGIServer()
+        server.start()
+        return PrefectLogsSubscriber(
+            api_url=server.api_url,
+            filter=filter,
+            reconnection_attempts=reconnection_attempts,
+        )
+    else:
+        raise ValueError(
+            "No Prefect API URL provided. Please set PREFECT_API_URL to the address of a running Prefect server."
+        )
+
+
+class PrefectLogsSubscriber:
+    """
+    Subscribes to a Prefect logs stream, yielding logs as they occur.
+
+    Example:
+
+        from prefect.logging.clients import PrefectLogsSubscriber
+        from prefect.client.schemas.filters import LogFilter, LogFilterLevel
+        import logging
+
+        filter = LogFilter(level=LogFilterLevel(ge_=logging.INFO))
+
+        async with PrefectLogsSubscriber(filter=filter) as subscriber:
+            async for log in subscriber:
+                print(log.timestamp, log.level, log.message)
+
+    """
+
+    _websocket: Optional[ClientConnection]
+    _filter: "LogFilter"
+    _seen_logs: MutableMapping[UUID, bool]
+
+    _api_key: Optional[str]
+    _auth_token: Optional[str]
+
+    def __init__(
+        self,
+        api_url: Optional[str] = None,
+        filter: Optional["LogFilter"] = None,
+        reconnection_attempts: int = 10,
+    ):
+        """
+        Args:
+            api_url: The base URL for a Prefect workspace
+            filter: Log filter to apply
+            reconnection_attempts: When the client is disconnected, how many times
+                the client should attempt to reconnect
+        """
+        self._api_key = None
+        self._auth_token = PREFECT_API_AUTH_STRING.value()
+
+        if not api_url:
+            api_url = cast(str, PREFECT_API_URL.value())
+
+        from prefect.client.schemas.filters import LogFilter
+
+        self._filter = filter or LogFilter()  # type: ignore[call-arg]
+        self._seen_logs = TTLCache(maxsize=SEEN_LOGS_SIZE, ttl=SEEN_LOGS_TTL)
+
+        socket_url = logs_out_socket_from_api_url(api_url)
+
+        logger.debug("Connecting to %s", socket_url)
+
+        # Configure SSL context for the connection
+        ssl_context = create_ssl_context_for_websocket(socket_url)
+        connect_kwargs: dict[str, Any] = {"subprotocols": [Subprotocol("prefect")]}
+        if ssl_context:
+            connect_kwargs["ssl"] = ssl_context
+
+        self._connect = websocket_connect(socket_url, **connect_kwargs)
+        self._websocket = None
+        self._reconnection_attempts = reconnection_attempts
+        if self._reconnection_attempts < 0:
+            raise ValueError("reconnection_attempts must be a non-negative integer")
+
+    @property
+    def client_name(self) -> str:
+        return self.__class__.__name__
+
+    async def __aenter__(self) -> Self:
+        # Don't handle any errors in the initial connection, because these are most
+        # likely a permission or configuration issue that should propagate
+        try:
+            await self._reconnect()
+        finally:
+            LOG_WEBSOCKET_CONNECTIONS.labels(self.client_name, "out", "initial").inc()
+        return self
+
+    async def _reconnect(self) -> None:
+        logger.debug("Reconnecting...")
+        if self._websocket:
+            self._websocket = None
+            await self._connect.__aexit__(None, None, None)
+
+        self._websocket = await self._connect.__aenter__()
+
+        # make sure we have actually connected
+        logger.debug("  pinging...")
+        pong = await self._websocket.ping()
+        await pong
+
+        # Send authentication message - logs WebSocket requires auth handshake
+        auth_token = self._api_key or self._auth_token
+        auth_message = {"type": "auth", "token": auth_token}
+        logger.debug("  authenticating...")
+        await self._websocket.send(orjson.dumps(auth_message).decode())
+
+        # Wait for auth response
+        try:
+            message = orjson.loads(await self._websocket.recv())
+            logger.debug("  auth result %s", message)
+            assert message["type"] == "auth_success", message.get("reason", "")
+        except AssertionError as e:
+            raise Exception(
+                "Unable to authenticate to the log stream. Please ensure the "
+                "provided api_key or auth_token you are using is valid for this environment. "
+                f"Reason: {e.args[0]}"
+            )
+        except ConnectionClosedError as e:
+            reason = getattr(e.rcvd, "reason", None)
+            msg = "Unable to authenticate to the log stream. Please ensure the "
+            msg += "provided api_key or auth_token you are using is valid for this environment. "
+            msg += f"Reason: {reason}" if reason else ""
+            raise Exception(msg) from e
+
+        from prefect.client.schemas.filters import LogFilterTimestamp
+
+        current_time = now("UTC")
+        self._filter.timestamp = LogFilterTimestamp(
+            after_=current_time - timedelta(minutes=1),  # type: ignore[arg-type]
+            before_=current_time + timedelta(days=365),  # type: ignore[arg-type]
+        )
+
+        logger.debug("  filtering logs since %s...", self._filter.timestamp.after_)
+        filter_message = {
+            "type": "filter",
+            "filter": self._filter.model_dump(mode="json"),
+        }
+        await self._websocket.send(orjson.dumps(filter_message).decode())
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self._websocket = None
+        await self._connect.__aexit__(exc_type, exc_val, exc_tb)
+
+    def __aiter__(self) -> Self:
+        return self
+
+    async def __anext__(self) -> Log:
+        assert self._reconnection_attempts >= 0
+        for i in range(self._reconnection_attempts + 1):  # pragma: no branch
+            try:
+                # If we're here and the websocket is None, then we've had a failure in a
+                # previous reconnection attempt.
+                #
+                # Otherwise, after the first time through this loop, we're recovering
+                # from a ConnectionClosed, so reconnect now.
+                if not self._websocket or i > 0:
+                    try:
+                        await self._reconnect()
+                    finally:
+                        LOG_WEBSOCKET_CONNECTIONS.labels(
+                            self.client_name, "out", "reconnect"
+                        ).inc()
+                    assert self._websocket
+
+                while True:
+                    message = orjson.loads(await self._websocket.recv())
+                    log: Log = Log.model_validate(message["log"])
+
+                    if log.id in self._seen_logs:
+                        continue
+                    self._seen_logs[log.id] = True
+
+                    try:
+                        return log
+                    finally:
+                        LOGS_OBSERVED.labels(self.client_name).inc()
+
+            except ConnectionClosedOK:
+                logger.debug('Connection closed with "OK" status')
+                raise StopAsyncIteration
+            except ConnectionClosed:
+                logger.debug(
+                    "Connection closed with %s/%s attempts",
+                    i + 1,
+                    self._reconnection_attempts,
+                )
+                if i == self._reconnection_attempts:
+                    # this was our final chance, raise the most recent error
+                    raise
+
+                if i > 2:
+                    # let the first two attempts happen quickly in case this is just
+                    # a standard load balancer timeout, but after that, just take a
+                    # beat to let things come back around.
+                    await asyncio.sleep(1)
+        raise StopAsyncIteration
+
+
+class PrefectCloudLogsSubscriber(PrefectLogsSubscriber):
+    """Logs subscriber for Prefect Cloud"""
+
+    def __init__(
+        self,
+        api_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        filter: Optional["LogFilter"] = None,
+        reconnection_attempts: int = 10,
+    ):
+        """
+        Args:
+            api_url: The base URL for a Prefect Cloud workspace
+            api_key: The API key of an actor with the see_flows scope
+            filter: Log filter to apply
+            reconnection_attempts: When the client is disconnected, how many times
+                the client should attempt to reconnect
+        """
+        api_url, api_key = _get_api_url_and_key(api_url, api_key)
+
+        super().__init__(
+            api_url=api_url,
+            filter=filter,
+            reconnection_attempts=reconnection_attempts,
+        )
+
+        self._api_key = api_key

prefect/serializers.py

@@ -38,6 +38,8 @@ from prefect.utilities.pydantic import custom_pydantic_encoder
 
 D = TypeVar("D", default=Any)
 
+_TYPE_ADAPTER_CACHE: dict[str, TypeAdapter[Any]] = {}
+
 
 def prefect_json_object_encoder(obj: Any) -> Any:
     """
@@ -68,9 +70,12 @@ def prefect_json_object_decoder(result: dict[str, Any]) -> Any:
     with `prefect_json_object_encoder`
     """
     if "__class__" in result:
-        return TypeAdapter(from_qualified_name(result["__class__"])).validate_python(
-            result["data"]
-        )
+        class_name = result["__class__"]
+        if class_name not in _TYPE_ADAPTER_CACHE:
+            _TYPE_ADAPTER_CACHE[class_name] = TypeAdapter(
+                from_qualified_name(class_name)
+            )
+        return _TYPE_ADAPTER_CACHE[class_name].validate_python(result["data"])
     elif "__exc_type__" in result:
         return from_qualified_name(result["__exc_type__"])(result["message"])
     else:

prefect/server/api/logs.py

@@ -2,14 +2,21 @@
 Routes for interacting with log objects.
 """
 
-from typing import List
+from typing import Optional, Sequence
 
-from fastapi import Body, Depends, status
+from fastapi import Body, Depends, WebSocket, status
+from pydantic import TypeAdapter
+from starlette.status import WS_1002_PROTOCOL_ERROR
 
 import prefect.server.api.dependencies as dependencies
 import prefect.server.models as models
-import prefect.server.schemas as schemas
 from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.logs import stream
+from prefect.server.schemas.actions import LogCreate
+from prefect.server.schemas.core import Log
+from prefect.server.schemas.filters import LogFilter
+from prefect.server.schemas.sorting import LogSort
+from prefect.server.utilities import subscriptions
 from prefect.server.utilities.server import PrefectRouter
 
 router: PrefectRouter = PrefectRouter(prefix="/logs", tags=["Logs"])
@@ -17,7 +24,7 @@ router: PrefectRouter = PrefectRouter(prefix="/logs", tags=["Logs"])
 
 @router.post("/", status_code=status.HTTP_201_CREATED)
 async def create_logs(
-    logs: List[schemas.actions.LogCreate],
+    logs: Sequence[LogCreate],
     db: PrefectDBInterface = Depends(provide_database_interface),
 ) -> None:
     """
@@ -30,18 +37,66 @@ async def create_logs(
             await models.logs.create_logs(session=session, logs=batch)
 
 
+logs_adapter: TypeAdapter[Sequence[Log]] = TypeAdapter(Sequence[Log])
+
+
 @router.post("/filter")
 async def read_logs(
     limit: int = dependencies.LimitBody(),
     offset: int = Body(0, ge=0),
-    logs: schemas.filters.LogFilter = None,
-    sort: schemas.sorting.LogSort = Body(schemas.sorting.LogSort.TIMESTAMP_ASC),
+    logs: Optional[LogFilter] = None,
+    sort: LogSort = Body(LogSort.TIMESTAMP_ASC),
     db: PrefectDBInterface = Depends(provide_database_interface),
-) -> List[schemas.core.Log]:
+) -> Sequence[Log]:
     """
     Query for logs.
     """
     async with db.session_context() as session:
-        return await models.logs.read_logs(
-            session=session, log_filter=logs, offset=offset, limit=limit, sort=sort
+        return logs_adapter.validate_python(
+            await models.logs.read_logs(
+                session=session, log_filter=logs, offset=offset, limit=limit, sort=sort
+            )
         )
+
+
+@router.websocket("/out")
+async def stream_logs_out(websocket: WebSocket) -> None:
+    """Serve a WebSocket to stream live logs"""
+    websocket = await subscriptions.accept_prefect_socket(websocket)
+    if not websocket:
+        return
+
+    try:
+        # After authentication, the next message is expected to be a filter message, any
+        # other type of message will close the connection.
+        message = await websocket.receive_json()
+
+        if message["type"] != "filter":
+            return await websocket.close(
+                WS_1002_PROTOCOL_ERROR, reason="Expected 'filter' message"
+            )
+
+        try:
+            filter = LogFilter.model_validate(message["filter"])
+        except Exception as e:
+            return await websocket.close(
+                WS_1002_PROTOCOL_ERROR, reason=f"Invalid filter: {e}"
+            )
+
+        # No backfill support for logs - only live streaming
+        # Subscribe to the ongoing log stream
+        async with stream.logs(filter) as log_stream:
+            async for log in log_stream:
+                if not log:
+                    if await subscriptions.still_connected(websocket):
+                        continue
+                    break
+
+                await websocket.send_json(
+                    {"type": "log", "log": log.model_dump(mode="json")}
+                )
+
+    except subscriptions.NORMAL_DISCONNECT_EXCEPTIONS:  # pragma: no cover
+        pass  # it's fine if a client disconnects either normally or abnormally
+
+    return None

prefect/settings/models/server/logs.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from pydantic import Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings, build_settings_config
+
+
+class ServerLogsSettings(PrefectBaseSettings):
+    """
+    Settings for controlling behavior of the logs subsystem
+    """
+
+    model_config: ClassVar[SettingsConfigDict] = build_settings_config(
+        ("server", "logs")
+    )
+
+    stream_out_enabled: bool = Field(
+        default=False,
+        description="Whether or not to stream logs out to the API via websockets.",
+    )
+
+    stream_publishing_enabled: bool = Field(
+        default=False,
+        description="Whether or not to publish logs to the streaming system.",
+    )

prefect/settings/models/server/root.py

@@ -13,6 +13,7 @@ from .deployments import ServerDeploymentsSettings
 from .ephemeral import ServerEphemeralSettings
 from .events import ServerEventsSettings
 from .flow_run_graph import ServerFlowRunGraphSettings
+from .logs import ServerLogsSettings
 from .services import ServerServicesSettings
 from .tasks import ServerTasksSettings
 from .ui import ServerUISettings
@@ -127,6 +128,10 @@ class ServerSettings(PrefectBaseSettings):
         default_factory=ServerFlowRunGraphSettings,
         description="Settings for controlling flow run graph behavior",
     )
+    logs: ServerLogsSettings = Field(
+        default_factory=ServerLogsSettings,
+        description="Settings for controlling server logs behavior",
+    )
     services: ServerServicesSettings = Field(
         default_factory=ServerServicesSettings,
         description="Settings for controlling server services behavior",

prefect/utilities/_ast.py

@@ -1,6 +1,6 @@
 import ast
 import math
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 import anyio
 from typing_extensions import TypeAlias
@@ -17,7 +17,7 @@ OPEN_FILE_SEMAPHORE = LazySemaphore(lambda: math.floor(get_open_file_limit() * 0
 # this potentially could be a TypedDict, but you
 # need some way to convince the type checker that
 # Literal["flow_name", "task_name"] are being provided
-DecoratedFnMetadata: TypeAlias = dict[str, str]
+DecoratedFnMetadata: TypeAlias = dict[str, Any]
 
 
 async def find_prefect_decorated_functions_in_file(

prefect/utilities/callables.py

@@ -654,7 +654,7 @@ def _get_docstring_from_source(source_code: str, func_name: str) -> Optional[str
         and isinstance(func_def.body[0], ast.Expr)
         and isinstance(func_def.body[0].value, ast.Constant)
     ):
-        return func_def.body[0].value.value
+        return str(func_def.body[0].value.value)
     return None
 
 

{prefect_client-3.4.7.dev2.dist-info → prefect_client-3.4.7.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.4.7.dev2
+Version: 3.4.7.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.4.7.dev2.dist-info → prefect_client-3.4.7.dev4.dist-info}/RECORD

@@ -1,7 +1,8 @@
 prefect/.prefectignore,sha256=awSprvKT0vI8a64mEOLrMxhxqcO-b0ERQeYpA2rNKVQ,390
+prefect/AGENTS.md,sha256=qmCZAuKIF9jQyp5TrW_T8bsM_97-QaiCoQp71A_b2Lg,1008
 prefect/__init__.py,sha256=iCdcC5ZmeewikCdnPEP6YBAjPNV5dvfxpYCTpw30Hkw,3685
 prefect/__main__.py,sha256=WFjw3kaYJY6pOTA7WDOgqjsz8zUEUZHCcj3P5wyVa-g,66
-prefect/_build_info.py,sha256=p-1WZT8sHGg-wrREDK4_ct9XaOJZFHNK6WNakLCaTSw,185
+prefect/_build_info.py,sha256=tffaShFeVAkOpp2FeHJl2rknEfdLB7UQINPTvgTU6a8,185
 prefect/_result_records.py,sha256=S6QmsODkehGVSzbMm6ig022PYbI6gNKz671p_8kBYx4,7789
 prefect/_versioning.py,sha256=YqR5cxXrY4P6LM1Pmhd8iMo7v_G2KJpGNdsf4EvDFQ0,14132
 prefect/_waiters.py,sha256=Ia2ITaXdHzevtyWIgJoOg95lrEXQqNEOquHvw3T33UQ,9026
@@ -22,7 +23,7 @@ prefect/plugins.py,sha256=FPRLR2mWVBMuOnlzeiTD9krlHONZH2rtYLD753JQDNQ,2516
 prefect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/results.py,sha256=Amm3TQu8U_oakSn__tCogIJ5DsTj0w_kLzuENWsxK6A,36824
 prefect/schedules.py,sha256=dhq4OhImRvcmtxF7UH1m8RbwYdHT5RQsp_FrxVXfODE,7289
-prefect/serializers.py,sha256=lU9A1rGEfAfhr8nTl3rf-K7ED78QNShXOrmRBhgNk3Y,9566
+prefect/serializers.py,sha256=MICSdT_1iL2SSq9cYatJ8T7wqPS97uyw9ew5Fh86-NM,9789
 prefect/states.py,sha256=rh7l1bnIYpTXdlXt5nnpz66y9KLjBWAJrN9Eo5RwgQs,26023
 prefect/task_engine.py,sha256=j7i_UiLvijV4Vut1Bw5-72kSlOqAPxqeS7-3cMVEBPA,65509
 prefect/task_runners.py,sha256=ptgE5wuXg_IVHM0j7d6l7ELAVg3SXSy4vggnoHRF8dA,17040
@@ -44,6 +45,7 @@ prefect/_internal/integrations.py,sha256=U4cZMDbnilzZSKaMxvzZcSL27a1tzRMjDoTfr2u
 prefect/_internal/pytz.py,sha256=Sy_cD-Hkmo_Yrhx2Jucy7DgTRhvO8ZD0whW1ywbSg_U,13765
 prefect/_internal/retries.py,sha256=pMHofrTQPDSxbVWclDwXbfhFKaDC6sxe1DkUOWugV6k,3040
 prefect/_internal/uuid7.py,sha256=yvndhibNDrqnYrG-qUncas4XQp8bKVbmM8XfF7JrjJI,4203
+prefect/_internal/websockets.py,sha256=CloIdusf2Bbefdit46pT91cVDudeYtztPI-MmqSnuLI,3466
 prefect/_internal/compatibility/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/_internal/compatibility/async_dispatch.py,sha256=cUXOqSeseMUaje9oYUzasVPtNttyiHvrqfJl0zK66XI,2949
 prefect/_internal/compatibility/blocks.py,sha256=SSZXoWVuCMYu1EzjqmTa4lKjDCyxvOFK47XMj6s4hsk,984
@@ -84,12 +86,12 @@ prefect/blocks/system.py,sha256=4KiUIy5zizMqfGJrxvi9GLRLcMj4BjAXARxCUEmgbKI,5041
 prefect/blocks/webhook.py,sha256=xylFigbDOsn-YzxahkTzNqYwrIA7wwS6204P0goLY3A,2907
 prefect/client/__init__.py,sha256=bDeOC_I8_la5dwCAfxKzYSTSAr2tlq5HpxJgVoCCdAs,675
 prefect/client/base.py,sha256=7VAMyoy8KtmtI-H8KYsI16_uw9TlrXSrcxChFuMp65Q,26269
-prefect/client/cloud.py,sha256=jnFgg0osMVDGbLjdWkDX3rQg_0pI_zvfSlU480XCWGQ,6523
+prefect/client/cloud.py,sha256=v1UO5YUF3kP6u5I1SKHe5DfpcVXB1_xc1rxr6P9-5DY,6927
 prefect/client/collections.py,sha256=t9XkVU_onQMZ871L21F1oZnAiPSQeeVfd_MuDEBS3iM,1050
 prefect/client/constants.py,sha256=Z_GG8KF70vbbXxpJuqW5pLnwzujTVeHbcYYRikNmGH0,29
 prefect/client/subscriptions.py,sha256=PTYi1Pp7rX-aGdcxZkxRBZkZnpzBt1P17APsm05EDR8,4376
 prefect/client/utilities.py,sha256=UEJD6nwYg2mD8-GSmru-E2ofXaBlmSFZ2-8T_5rIK6c,3472
-prefect/client/orchestration/__init__.py,sha256=DPbazZvQDgoSZipuNk4z_AILgJbM6zBld-1OsVH55ME,55831
+prefect/client/orchestration/__init__.py,sha256=lG3IW4XfbBkgZyPiSrxeyBhTqt3YfFcBHnEXDVrNmLs,56220
 prefect/client/orchestration/base.py,sha256=HM6ryHBZSzuHoCFQM9u5qR5k1dN9Bbr_ah6z1UPNbZQ,1542
 prefect/client/orchestration/routes.py,sha256=_-HC-EmgMhsYdmGwZTxIXlINaVzYuX7RZAvzjHbVp-4,4266
 prefect/client/orchestration/_artifacts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -119,7 +121,7 @@ prefect/client/orchestration/_work_pools/client.py,sha256=s1DfUQQBgB2sLiVVPhLNTl
 prefect/client/schemas/__init__.py,sha256=InZcDzdeWA2oaV0TlyvoMcyLcbi_aaqU1U9D6Gx-eoU,2747
 prefect/client/schemas/actions.py,sha256=E46Mdq7vAq8hhYmMj6zqUF20uAPXZricViZcIYmgEf0,32443
 prefect/client/schemas/filters.py,sha256=qa--NNZduuSOcL1xw-YMd4FVIKMrDnBwPPY4m5Di0GA,35963
-prefect/client/schemas/objects.py,sha256=6rR9ccLJ4f1Hw0J8ywzgX2L3FRw8--XCQX9blBrE7R8,57984
+prefect/client/schemas/objects.py,sha256=JYcHShcR4JUBjc1VrsMaJ0QYd3H9peXbXtT9U4Lhkc8,57708
 prefect/client/schemas/responses.py,sha256=Zdcx7jlIaluEa2uYIOE5mK1HsJvWPErRAcaWM20oY_I,17336
 prefect/client/schemas/schedules.py,sha256=sxLFk0SmFY7X1Y9R9HyGDqOS3U5NINBWTciUU7vTTic,14836
 prefect/client/schemas/sorting.py,sha256=L-2Mx-igZPtsUoRUguTcG3nIEstMEMPD97NwPM2Ox5s,2579
@@ -153,7 +155,7 @@ prefect/docker/__init__.py,sha256=z6wdc6UFfiBG2jb9Jk64uCWVM04JKVWeVyDWwuuon8M,52
 prefect/docker/docker_image.py,sha256=bR_pEq5-FDxlwTj8CP_7nwZ_MiGK6KxIi8v7DRjy1Kg,3138
 prefect/events/__init__.py,sha256=GtKl2bE--pJduTxelH2xy7SadlLJmmis8WR1EYixhuA,2094
 prefect/events/actions.py,sha256=A7jS8bo4zWGnrt3QfSoQs0uYC1xfKXio3IfU0XtTb5s,9129
-prefect/events/clients.py,sha256=r_C3ZevVYUzIW53CpmFbEtR2DwhYeYB4budtB3GaYl0,27625
+prefect/events/clients.py,sha256=pvCbvPcehDhaFEJfeu1DzUP6RhBhacKU7L5Z4XPSvIE,25132
 prefect/events/filters.py,sha256=tnAbA4Z0Npem8Jbin-qqe38K_4a-4YdpU-Oc4u8Y95Q,8697
 prefect/events/related.py,sha256=CTeexYUmmA93V4gsR33GIFmw-SS-X_ouOpRg-oeq-BU,6672
 prefect/events/utilities.py,sha256=ww34bTMENCNwcp6RhhgzG0KgXOvKGe0MKmBdSJ8NpZY,3043
@@ -161,7 +163,7 @@ prefect/events/worker.py,sha256=HjbibR0_J1W1nnNMZDFTXAbB0cl_cFGaFI87DvNGcnI,4557
 prefect/events/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/events/cli/automations.py,sha256=uCX3NnypoI25TmyAoyL6qYhanWjZbJ2watwv1nfQMxs,11513
 prefect/events/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prefect/events/schemas/automations.py,sha256=U3wNJtaxz42qi-X4n3SX2AAyqaNk9jX3m01E5cn4OyQ,14775
+prefect/events/schemas/automations.py,sha256=GVAfgyNoTxr8NpEw_Ao-1Prfd_MSsrhrLsXv6SLKUdY,14775
 prefect/events/schemas/deployment_triggers.py,sha256=OX9g9eHe0nqJ3PtVEzqs9Ub2LaOHMA4afLZSvSukKGU,3191
 prefect/events/schemas/events.py,sha256=r8sSx2Q1A0KIofnZR_Bri7YT1wzXKV3YS-LnxpeIXHE,9270
 prefect/events/schemas/labelling.py,sha256=bU-XYaHXhI2MEBIHngth96R9D02m8HHb85KNcHZ_1Gc,3073
@@ -181,6 +183,7 @@ prefect/locking/filesystem.py,sha256=PxC9ndDbo59-gBEx9jtKad4T-Jav0srJSM9vYGzvQwE
 prefect/locking/memory.py,sha256=EFQnhAO94jEy4TyS880DbsJ42CHT5WNuNc6Wj8dYrKc,7842
 prefect/locking/protocol.py,sha256=RsfvlaHTTEJ0YvYWSqFGoZuT2w4FPPxyQlHqjoyNGuE,4240
 prefect/logging/__init__.py,sha256=DpRZzZeWeiDHFlMDEQdknRzbxpL0ObFh5IqqS9iaZwQ,170
+prefect/logging/clients.py,sha256=nKEv-Xfzy5QwtFmZvNirBI8G5YraZ9YzuIkKHb4XVXM,11825
 prefect/logging/configuration.py,sha256=go9lA4W5HMpK6azDz_ez2YqgQ2b3aCFXxJH-AopoHy8,3404
 prefect/logging/filters.py,sha256=NnRYubh9dMmWcCAjuW32cIVQ37rLxdn8ci26wTtQMyU,1136
 prefect/logging/formatters.py,sha256=Sum42BmYZ7mns64jSOy4OA_K8KudEZjeG2h7SZcY9mA,4167
@@ -218,7 +221,7 @@ prefect/server/api/events.py,sha256=mUTv5ZNxiRsEOpzq8fpfCkLpPasjt-ROUAowA5eFbDE,
 prefect/server/api/flow_run_states.py,sha256=lIdxVE9CqLgtDCuH9bTaKkzHNL81FPrr11liPzvONrw,1661
 prefect/server/api/flow_runs.py,sha256=Lmb165fLbN4DioxjxgDYaAJ5Qxj771iRYaqn-hYq9KM,33744
 prefect/server/api/flows.py,sha256=Bz0ISh-9oY0W1X3mqA631_8678pQ6tuRGMpSgWAfxOc,7018
-prefect/server/api/logs.py,sha256=0z78tM2B5sRgJWYRWJn5lHhRoLtZB_OU3C-uALV8tOs,1571
+prefect/server/api/logs.py,sha256=O0W9jomHQuWF7XPMPOhW2p5Uidss6ssMqmKKwMGiv7Y,3526
 prefect/server/api/middleware.py,sha256=WkyuyeJIfo9Q0GAIVU5gO6yIGNVwoHwuBah5AB5oUyw,2733
 prefect/server/api/root.py,sha256=CeumFYIM_BDvPicJH9ry5PO_02PZTLeMqbLMGGTh90o,942
 prefect/server/api/run_history.py,sha256=EW-GTPxZAQ5zXiAqHzmS-iAN_Bn6ZSgVQksDT-ZTsyc,5995
@@ -270,7 +273,8 @@ prefect/settings/models/server/deployments.py,sha256=LjWQr2U1mjItYhuuLqMT_QQ7P4K
 prefect/settings/models/server/ephemeral.py,sha256=rh8Py5Nxh-gq9KgfB7CDnIgT_nuOuv59OrLGuhMIGmk,1043
 prefect/settings/models/server/events.py,sha256=9rdlbLz9SIg_easm1UcFTfX1seS935Xtv5d9y3r39Eo,5578
 prefect/settings/models/server/flow_run_graph.py,sha256=PuAZqqdu6fzvrbUgXZzyntUH_Ii_bP7qezgcgvW7ULk,1146
-prefect/settings/models/server/root.py,sha256=Dk_Zx4eGUy1h2cAetDKphnd6TWhDrK6DHOLJxdP7e1Y,5215
+prefect/settings/models/server/logs.py,sha256=tk6tzZS2pAHcAA55Ko-WaIbYz88sUGSGESvZHjIzv9Q,756
+prefect/settings/models/server/root.py,sha256=9z58934Yqudf8N3-aRCIL73GPsfs3dKuTt-E9ECaxB4,5409
 prefect/settings/models/server/services.py,sha256=Mb71MG5I1hPlCaJ54vNmHgU7Rxde2x8QeDQl9a8cGU4,18998
 prefect/settings/models/server/tasks.py,sha256=_CaOUfh3WDXvUhmHXmR-MkTRaQqocZck4efmX74iOg8,2976
 prefect/settings/models/server/ui.py,sha256=hShsi4rPBtdJA2WnT1Er0tWqu-e5wUum8NkNgucShkk,1867
@@ -286,13 +290,13 @@ prefect/types/_datetime.py,sha256=_N3eAMhYlwSEubMQlfeTGxLJHn2jRFPrNPxkod21B_s,75
 prefect/types/entrypoint.py,sha256=2FF03-wLPgtnqR_bKJDB2BsXXINPdu8ptY9ZYEZnXg8,328
 prefect/types/names.py,sha256=dGXNrP9nibQTm4hOBOpaQebKm3Avf3OGM5MH4M5BUKc,4013
 prefect/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prefect/utilities/_ast.py,sha256=sgEPUWElih-3cp4PoAy1IOyPtu8E27lL0Dldf3ijnYY,4905
+prefect/utilities/_ast.py,sha256=IE_XGZAfkd_C7Rl6MvvNC4kGSbbqIFAbYa5S2PPks-U,4910
 prefect/utilities/_deprecated.py,sha256=b3pqRSoFANdVJAc8TJkygBcP-VjZtLJUxVIWC7kwspI,1303
 prefect/utilities/_engine.py,sha256=9GW4X1lyAbmPwCuXXIubVJ7Z0DMT3dykkEUtp9tm5hI,3356
 prefect/utilities/_git.py,sha256=bPYWQdr9xvH0BqxR1ll1RkaSb3x0vhwylhYD5EilkKU,863
 prefect/utilities/annotations.py,sha256=0Elqgq6LR7pQqezNqT5wb6U_0e2pDO_zx6VseVL6kL8,4396
 prefect/utilities/asyncutils.py,sha256=xcfeNym2j3WH4gKXznON2hI1PpUTcwr_BGc16IQS3C4,19789
-prefect/utilities/callables.py,sha256=HcXA3_Stb8CBtp074SuFKuMy-ge2KW89X5towbzGjaY,25925
+prefect/utilities/callables.py,sha256=57adLaN2QGJEE0YCdv1jS1L5R3vi4IuzPiNVZ7cCcEk,25930
 prefect/utilities/collections.py,sha256=c3nPLPWqIZQQdNuHs_nrbQJwuhQSX4ivUl-h9LtzXto,23243
 prefect/utilities/compat.py,sha256=nnPA3lf2f4Y-l645tYFFNmj5NDPaYvjqa9pbGKZ3WKE,582
 prefect/utilities/context.py,sha256=23SDMgdt07SjmB1qShiykHfGgiv55NBzdbMXM3fE9CI,1447
@@ -325,7 +329,7 @@ prefect/workers/cloud.py,sha256=dPvG1jDGD5HSH7aM2utwtk6RaJ9qg13XjkA0lAIgQmY,287
 prefect/workers/process.py,sha256=Yi5D0U5AQ51wHT86GdwtImXSefe0gJf3LGq4r4z9zwM,11090
 prefect/workers/server.py,sha256=2pmVeJZiVbEK02SO6BEZaBIvHMsn6G8LzjW8BXyiTtk,1952
 prefect/workers/utilities.py,sha256=VfPfAlGtTuDj0-Kb8WlMgAuOfgXCdrGAnKMapPSBrwc,2483
-prefect_client-3.4.7.dev2.dist-info/METADATA,sha256=yhvRf0gZS7dNvoTtnT_QQ52HsH68jUAWDdCaGSHaHnM,7517
-prefect_client-3.4.7.dev2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-prefect_client-3.4.7.dev2.dist-info/licenses/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
-prefect_client-3.4.7.dev2.dist-info/RECORD,,
+prefect_client-3.4.7.dev4.dist-info/METADATA,sha256=OkzXvCsiyz1Qs2jMNsixg3GzEMIuQLwmn0ZYSQaPraY,7517
+prefect_client-3.4.7.dev4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+prefect_client-3.4.7.dev4.dist-info/licenses/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
+prefect_client-3.4.7.dev4.dist-info/RECORD,,