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

{prefect_client-3.4.7.dev2 → prefect_client-3.4.7.dev4}/.gitignore

@@ -89,3 +89,4 @@ src/integrations/*/**/_version.py
 
 # Pyright type analysis report
 prefect-analysis.json
+CLAUDE.md

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

@@ -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.dev4/src/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_client-3.4.7.dev4/src/prefect/_build_info.py

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

prefect_client-3.4.7.dev4/src/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-3.4.7.dev2 → prefect_client-3.4.7.dev4}/src/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-3.4.7.dev2 → prefect_client-3.4.7.dev4}/src/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-3.4.7.dev2 → prefect_client-3.4.7.dev4}/src/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_client-3.4.7.dev2 → prefect_client-3.4.7.dev4}/src/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_client-3.4.7.dev2 → prefect_client-3.4.7.dev4}/src/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",
     )