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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.4.7.dev7
+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.dev7 → 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.dev7 → prefect_client-3.4.7.dev9}/src/prefect/artifacts.py

@@ -55,7 +55,7 @@ class Artifact(ArtifactRequest):
             client: The PrefectClient
 
         Returns:
-            - The created artifact.
+            The created artifact.
         """
 
         local_client_context = asyncnullcontext(client) if client else get_client()
@@ -93,7 +93,7 @@ class Artifact(ArtifactRequest):
             client: The PrefectClient
 
         Returns:
-            - The created artifact.
+            The created artifact.
         """
 
         # Create sync client since this is a sync method.
@@ -417,6 +417,23 @@ def create_link_artifact(
 
     Returns:
         The table artifact ID.
+
+    Example:
+        ```python
+        from prefect import flow
+        from prefect.artifacts import create_link_artifact
+
+        @flow
+        def my_flow():
+            create_link_artifact(
+                link="https://www.prefect.io",
+                link_text="Prefect",
+                key="prefect-link",
+                description="This is a link to the Prefect website",
+            )
+
+        my_flow()
+        ```
     """
     new_artifact = LinkArtifact(
         key=key,
@@ -475,6 +492,22 @@ def create_markdown_artifact(
 
     Returns:
         The table artifact ID.
+
+    Example:
+        ```python
+        from prefect import flow
+        from prefect.artifacts import create_markdown_artifact
+
+        @flow
+        def my_flow():
+            create_markdown_artifact(
+                markdown="## Prefect",
+                key="prefect-markdown",
+                description="This is a markdown artifact",
+            )
+
+        my_flow()
+        ```
     """
     new_artifact = MarkdownArtifact(
         key=key,
@@ -533,6 +566,22 @@ def create_table_artifact(
 
     Returns:
         The table artifact ID.
+
+    Example:
+        ```python
+        from prefect import flow
+        from prefect.artifacts import create_table_artifact
+
+        @flow
+        def my_flow():
+            create_table_artifact(
+                table=[{"name": "John", "age": 30}, {"name": "Jane", "age": 25}],
+                key="prefect-table",
+                description="This is a table artifact",
+            )
+
+        my_flow()
+        ```
     """
 
     new_artifact = TableArtifact(

{prefect_client-3.4.7.dev7 → 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.dev7 → prefect_client-3.4.7.dev9}/src/prefect/events/schemas/labelling.py

@@ -8,6 +8,7 @@ class LabelDiver:
     presenting the labels as a graph of objects that may be accessed by attribute.  For
     example:
 
+        ```python
         diver = LabelDiver({
             'hello.world': 'foo',
             'hello.world.again': 'bar'
@@ -15,6 +16,7 @@ class LabelDiver:
 
         assert str(diver.hello.world) == 'foo'
         assert str(diver.hello.world.again) == 'bar'
+        ```
 
     """
 

{prefect_client-3.4.7.dev7 → prefect_client-3.4.7.dev9}/src/prefect/settings/context.py

@@ -33,20 +33,23 @@ def temporary_settings(
     See `Settings.copy_with_update` for details on different argument behavior.
 
     Examples:
-        >>> from prefect.settings import PREFECT_API_URL
-        >>>
-        >>> with temporary_settings(updates={PREFECT_API_URL: "foo"}):
-        >>>    assert PREFECT_API_URL.value() == "foo"
-        >>>
-        >>>    with temporary_settings(set_defaults={PREFECT_API_URL: "bar"}):
-        >>>         assert PREFECT_API_URL.value() == "foo"
-        >>>
-        >>>    with temporary_settings(restore_defaults={PREFECT_API_URL}):
-        >>>         assert PREFECT_API_URL.value() is None
-        >>>
-        >>>         with temporary_settings(set_defaults={PREFECT_API_URL: "bar"})
-        >>>             assert PREFECT_API_URL.value() == "bar"
-        >>> assert PREFECT_API_URL.value() is None
+
+        ```python
+        from prefect.settings import PREFECT_API_URL
+
+        with temporary_settings(updates={PREFECT_API_URL: "foo"}):
+           assert PREFECT_API_URL.value() == "foo"
+
+           with temporary_settings(set_defaults={PREFECT_API_URL: "bar"}):
+                assert PREFECT_API_URL.value() == "foo"
+
+           with temporary_settings(restore_defaults={PREFECT_API_URL}):
+                assert PREFECT_API_URL.value() is None
+
+                with temporary_settings(set_defaults={PREFECT_API_URL: "bar"})
+                    assert PREFECT_API_URL.value() == "bar"
+        assert PREFECT_API_URL.value() is None
+        ```
     """
     import prefect.context
 

{prefect_client-3.4.7.dev7 → prefect_client-3.4.7.dev9}/src/prefect/utilities/collections.py

@@ -629,12 +629,12 @@ def get_from_dict(
         The fetched value if the key exists, or the default value if it does not.
 
     Examples:
-    >>> get_from_dict({'a': {'b': {'c': [1, 2, 3, 4]}}}, 'a.b.c[1]')
-    2
-    >>> get_from_dict({'a': {'b': [0, {'c': [1, 2]}]}}, ['a', 'b', 1, 'c', 1])
-    2
-    >>> get_from_dict({'a': {'b': [0, {'c': [1, 2]}]}}, 'a.b.1.c.2', 'default')
-    'default'
+
+    ```python
+    get_from_dict({'a': {'b': {'c': [1, 2, 3, 4]}}}, 'a.b.c[1]') # 2
+    get_from_dict({'a': {'b': [0, {'c': [1, 2]}]}}, ['a', 'b', 1, 'c', 1]) # 2
+    get_from_dict({'a': {'b': [0, {'c': [1, 2]}]}}, 'a.b.1.c.2', 'default') # 'default'
+    ```
     """
     if isinstance(keys, str):
         keys = keys.replace("[", ".").replace("]", "").split(".")

{prefect_client-3.4.7.dev7 → prefect_client-3.4.7.dev9}/src/prefect/utilities/engine.py

@@ -72,9 +72,12 @@ async def collect_task_run_inputs(
     found.
 
     Examples:
-        >>> task_inputs = {
-        >>>    k: await collect_task_run_inputs(v) for k, v in parameters.items()
-        >>> }
+
+        ```python
+        task_inputs = {
+            k: await collect_task_run_inputs(v) for k, v in parameters.items()
+         }
+        ```
     """
     # TODO: This function needs to be updated to detect parameters and constants
 
@@ -120,9 +123,11 @@ def collect_task_run_inputs_sync(
     found.
 
     Examples:
-        >>> task_inputs = {
-        >>>    k: collect_task_run_inputs_sync(v) for k, v in parameters.items()
-        >>> }
+        ```python
+        task_inputs = {
+            k: collect_task_run_inputs_sync(v) for k, v in parameters.items()
+         }
+        ```
     """
     # TODO: This function needs to be updated to detect parameters and constants
 

{prefect_client-3.4.7.dev7 → 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.dev7 → prefect_client-3.4.7.dev9}/src/prefect/workers/base.py

@@ -208,10 +208,12 @@ class BaseJobConfiguration(BaseModel):
         Defaults to using the job configuration parameter name as the template variable name.
 
         e.g.
+        ```python
         {
             key1: '{{ key1 }}',     # default variable template
             key2: '{{ template2 }}', # `template2` specifically provide as template
         }
+        ```
         """
         configuration: dict[str, Any] = {}
         properties = cls.model_json_schema()["properties"]

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

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.4.7.dev7"
-__build_date__ = "2025-06-24 08:09:27.221869+00:00"
-__git_commit__ = "3614ff28a5600b1965c957a04e880aaf38442ad5"
-__dirty__ = False