prefect-client 3.4.7.dev8__tar.gz → 3.4.7.dev9__tar.gz

{prefect_client-3.4.7.dev8 → prefect_client-3.4.7.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.4.7.dev8
+Version: 3.4.7.dev9
 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.dev9/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.4.7.dev9"
+__build_date__ = "2025-06-26 08:09:22.695909+00:00"
+__git_commit__ = "6128bf88e0089a6ef517493eafb157d523ed0afd"
+__dirty__ = False

{prefect_client-3.4.7.dev8 → prefect_client-3.4.7.dev9}/src/prefect/_internal/websockets.py

@@ -74,9 +74,10 @@ class WebsocketProxyConnect(connect):
                 "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
-        )
+        # Store proxy URL for deferred creation. Creating the proxy object here
+        # can bind asyncio futures to the wrong event loop when multiple WebSocket
+        # connections are initialized at different times (e.g., events + logs clients).
+        self._proxy_url = proxy_url if proxy_url and not proxy_bypass(host) else None
         self._host = host
         self._port = port
 
@@ -86,8 +87,10 @@ class WebsocketProxyConnect(connect):
             self._kwargs.setdefault("ssl", ssl_context)
 
     async def _proxy_connect(self: Self) -> ClientConnection:
-        if self._proxy:
-            sock = await self._proxy.connect(
+        if self._proxy_url:
+            # Create proxy in the current event loop context
+            proxy = Proxy.from_url(self._proxy_url)
+            sock = await proxy.connect(
                 dest_host=self._host,
                 dest_port=self._port,
             )

{prefect_client-3.4.7.dev8 → prefect_client-3.4.7.dev9}/src/prefect/blocks/core.py

@@ -175,11 +175,29 @@ def _collect_secret_fields(
                 )
         return
 
-    if type_ in (SecretStr, SecretBytes) or (
+    # Check if this is a pydantic Secret type (including generic Secret[T])
+    is_pydantic_secret = False
+
+    # Direct check for SecretStr, SecretBytes
+    if type_ in (SecretStr, SecretBytes):
+        is_pydantic_secret = True
+    # Check for base Secret class
+    elif (
         isinstance(type_, type)  # type: ignore[unnecessaryIsInstance]
         and getattr(type_, "__module__", None) == "pydantic.types"
         and getattr(type_, "__name__", None) == "Secret"
     ):
+        is_pydantic_secret = True
+    # Check for generic Secret[T] (e.g., Secret[str], Secret[int])
+    elif get_origin(type_) is not None:
+        origin = get_origin(type_)
+        if (
+            getattr(origin, "__module__", None) == "pydantic.types"
+            and getattr(origin, "__name__", None) == "Secret"
+        ):
+            is_pydantic_secret = True
+
+    if is_pydantic_secret:
         secrets.append(name)
     elif type_ == SecretDict:
         # Append .* to field name to signify that all values under a given key are secret and should be obfuscated.
@@ -370,16 +388,27 @@ class Block(BaseModel, ABC):
     ) -> Any:
         jsonable_self = handler(self)
         if (ctx := info.context) and ctx.get("include_secrets") is True:
-            jsonable_self.update(
-                {
-                    field_name: visit_collection(
-                        expr=getattr(self, field_name),
-                        visit_fn=partial(handle_secret_render, context=ctx),
-                        return_data=True,
-                    )
-                    for field_name in type(self).model_fields
-                }
-            )
+            # Add serialization mode to context so handle_secret_render knows how to process nested models
+            ctx["serialization_mode"] = info.mode
+
+            for field_name in type(self).model_fields:
+                field_value = getattr(self, field_name)
+
+                # In JSON mode, skip fields that don't contain secrets
+                # as they're already properly serialized by the handler
+                if (
+                    info.mode == "json"
+                    and field_name in jsonable_self
+                    and not self._field_has_secrets(field_name)
+                ):
+                    continue
+
+                # For all other fields, use visit_collection with handle_secret_render
+                jsonable_self[field_name] = visit_collection(
+                    expr=field_value,
+                    visit_fn=partial(handle_secret_render, context=ctx),
+                    return_data=True,
+                )
         extra_fields = {
             "block_type_slug": self.get_block_type_slug(),
             "_block_document_id": self._block_document_id,
@@ -477,6 +506,25 @@ class Block(BaseModel, ABC):
         else:
             return f"sha256:{checksum}"
 
+    def _field_has_secrets(self, field_name: str) -> bool:
+        """Check if a field contains secrets based on the schema's secret_fields."""
+        secret_fields = self.model_json_schema().get("secret_fields", [])
+
+        # Check if field_name matches any secret field pattern
+        for secret_field in secret_fields:
+            if secret_field == field_name:
+                return True
+            elif secret_field.startswith(f"{field_name}."):
+                # This field contains nested secrets
+                return True
+            elif secret_field.endswith(".*"):
+                # Handle wildcard patterns like "field.*"
+                prefix = secret_field[:-2]  # Remove .*
+                if field_name == prefix:
+                    return True
+
+        return False
+
     def _to_block_document(
         self,
         name: Optional[str] = None,
@@ -530,6 +578,29 @@ class Block(BaseModel, ABC):
             context={"include_secrets": include_secrets},
         )
 
+        # Ensure non-secret fields are JSON-serializable to avoid issues with types
+        # like SemanticVersion when the BlockDocument is later serialized
+        try:
+            json_data = self.model_dump(
+                mode="json",
+                by_alias=True,
+                include=data_keys,
+                context={"include_secrets": include_secrets},
+            )
+            # Replace non-secret, non-Block fields with their JSON representation
+            # We need to check the original field to determine if it's a secret or Block
+            for key in data_keys:
+                if key in block_document_data and key in json_data:
+                    field_value = getattr(self, key)
+                    # Only replace if the field doesn't contain secrets and is not a Block
+                    if not self._field_has_secrets(key) and not isinstance(
+                        field_value, Block
+                    ):
+                        block_document_data[key] = json_data[key]
+        except Exception:
+            # If JSON serialization fails, we'll handle it later
+            pass
+
         # Iterate through and find blocks that already have saved block documents to
         # create references to those saved block documents.
         for key in data_keys:

{prefect_client-3.4.7.dev8 → prefect_client-3.4.7.dev9}/src/prefect/utilities/pydantic.py

@@ -1,4 +1,5 @@
 import warnings
+from functools import partial
 from typing import (
     Any,
     Callable,
@@ -20,6 +21,7 @@ from pydantic import (
 from pydantic_core import to_jsonable_python
 from typing_extensions import Literal
 
+from prefect.utilities.collections import visit_collection
 from prefect.utilities.dispatch import get_dispatch_key, lookup_type, register_base_type
 from prefect.utilities.importtools import from_qualified_name, to_qualified_name
 from prefect.utilities.names import obfuscate
@@ -344,7 +346,23 @@ def handle_secret_render(value: object, context: dict[str, Any]) -> object:
             else obfuscate(value)
         )
     elif isinstance(value, BaseModel):
-        return value.model_dump(context=context)
+        # Pass the serialization mode if available in context
+        mode = context.get("serialization_mode", "python")
+        if mode == "json":
+            # For JSON mode with nested models, we need to recursively process fields
+            # because regular Pydantic models don't understand include_secrets
+
+            json_data = value.model_dump(mode="json")
+            for field_name in type(value).model_fields:
+                field_value = getattr(value, field_name)
+                json_data[field_name] = visit_collection(
+                    expr=field_value,
+                    visit_fn=partial(handle_secret_render, context=context),
+                    return_data=True,
+                )
+            return json_data
+        else:
+            return value.model_dump(context=context)
     return value
 
 

prefect_client-3.4.7.dev8/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.4.7.dev8"
-__build_date__ = "2025-06-25 08:09:28.547496+00:00"
-__git_commit__ = "f2c59127b60d3a91a1da167603522185fac2be50"
-__dirty__ = False