prefect-client 2.16.4__py3-none-any.whl → 2.16.5__py3-none-any.whl

prefect/_internal/concurrency/calls.py

@@ -2,6 +2,7 @@
 Implementation of the `Call` data structure for transport of deferred function calls
 and low-level management of call execution.
 """
+
 import abc
 import asyncio
 import concurrent.futures
@@ -40,8 +41,8 @@ P = ParamSpec("P")
 # we already have strong references to the `Call` objects in other places
 # and b) this is used for performance optimizations where we have fallback
 # behavior if this weakref is garbage collected. A fix for issue #10952.
-current_call: contextvars.ContextVar["weakref.ref[Call]"] = contextvars.ContextVar(
-    "current_call"
+current_call: contextvars.ContextVar["weakref.ref[Call]"] = (  # novm
+    contextvars.ContextVar("current_call")
 )
 
 # Create a strong reference to tasks to prevent destruction during execution errors

prefect/_internal/pydantic/__init__.py

@@ -9,3 +9,5 @@
 from pydantic.version import VERSION as PYDANTIC_VERSION
 
 HAS_PYDANTIC_V2 = PYDANTIC_VERSION.startswith("2.")
+
+from ._compat import model_dump, IncEx, model_json_schema

prefect/_internal/pydantic/_compat.py

@@ -0,0 +1,180 @@
+from typing import Any, Dict, Literal, Optional, Set, Type, Union
+
+import typing_extensions
+from pydantic import BaseModel
+
+from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect.logging.loggers import get_logger
+from prefect.settings import PREFECT_EXPERIMENTAL_ENABLE_PYDANTIC_V2_INTERNALS
+
+IncEx: typing_extensions.TypeAlias = (
+    "Union[Set[int], Set[str], Dict[int, Any], Dict[str, Any], None]"
+)
+
+logger = get_logger("prefect._internal.pydantic")
+
+if HAS_PYDANTIC_V2:
+    from pydantic.json_schema import GenerateJsonSchema
+
+
+def is_pydantic_v2_compatible(
+    model_instance: Optional[BaseModel] = None, fn_name: Optional[str] = None
+) -> bool:
+    """
+    Determines if the current environment is compatible with Pydantic V2 features,
+    based on the presence of Pydantic V2 and a global setting that enables V2 functionalities.
+
+    This function primarily serves to facilitate conditional logic in code that needs to
+    operate differently depending on the availability of Pydantic V2 features. It checks
+    two conditions: whether Pydantic V2 is installed, and whether the use of V2 features
+    is explicitly enabled through a global setting (`PREFECT_EXPERIMENTAL_ENABLE_PYDANTIC_V2_INTERNALS`).
+
+    Parameters:
+    -----------
+    model_instance : Optional[BaseModel], optional
+        An instance of a Pydantic model. This parameter is used to perform a type check
+        to ensure the passed object is a Pydantic model instance. If not provided or if
+        the object is not a Pydantic model, a TypeError is raised. Defaults to None.
+
+    fn_name : Optional[str], optional
+        The name of the function or feature for which V2 compatibility is being checked.
+        This is used for logging purposes to provide more context in debug messages.
+        Defaults to None.
+
+    Returns:
+    --------
+    bool
+        True if the current environment supports Pydantic V2 features and if the global
+        setting for enabling V2 features is set to True. False otherwise.
+
+    Raises:
+    -------
+    TypeError
+        If `model_instance` is provided but is not an instance of a Pydantic BaseModel.
+    """
+    if model_instance and not isinstance(model_instance, BaseModel):
+        raise TypeError(
+            f"Expected a Pydantic model, but got {type(model_instance).__name__}"
+        )
+
+    should_dump_as_v2_model = (
+        HAS_PYDANTIC_V2 and PREFECT_EXPERIMENTAL_ENABLE_PYDANTIC_V2_INTERNALS
+    )
+
+    if should_dump_as_v2_model:
+        logger.debug(
+            f"Using Pydantic v2 compatibility layer for `{fn_name}`. This will be removed in a future release."
+        )
+
+        return True
+
+    elif HAS_PYDANTIC_V2:
+        logger.debug(
+            "Pydantic v2 compatibility layer is disabled. To enable, set `PREFECT_EXPERIMENTAL_ENABLE_PYDANTIC_V2_INTERNALS` to `True`."
+        )
+
+    else:
+        logger.debug("Pydantic v2 is not installed.")
+
+    return False
+
+
+def model_dump(
+    model_instance: BaseModel,
+    *,
+    mode: Union[Literal["json", "python"], str] = "python",
+    include: IncEx = None,
+    exclude: IncEx = None,
+    by_alias: bool = False,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+    round_trip: bool = False,
+    warnings: bool = True,
+) -> Dict[str, Any]:
+    """
+    Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+    Args:
+        mode: The mode in which `to_python` should run.
+            If mode is 'json', the output will only contain JSON serializable types.
+            If mode is 'python', the output may contain non-JSON-serializable Python objects.
+        include: A list of fields to include in the output.
+        exclude: A list of fields to exclude from the output.
+        by_alias: Whether to use the field's alias in the dictionary key if defined.
+        exclude_unset: Whether to exclude fields that have not been explicitly set.
+        exclude_defaults: Whether to exclude fields that are set to their default value.
+        exclude_none: Whether to exclude fields that have a value of `None`.
+        round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+        warnings: Whether to log warnings when invalid fields are encountered.
+
+    Returns:
+        A dictionary representation of the model.
+    """
+    if is_pydantic_v2_compatible(model_instance=model_instance, fn_name="model_dump"):
+        return model_instance.model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+
+    return model_instance.dict(
+        include=include,
+        exclude=exclude,
+        by_alias=by_alias,
+        exclude_unset=exclude_unset,
+        exclude_defaults=exclude_defaults,
+        exclude_none=exclude_none,
+    )
+
+
+DEFAULT_REF_TEMPLATE = "#/$defs/{model}"
+JsonSchemaMode = Literal["validation", "serialization"]
+
+
+def model_json_schema(
+    model: Type[BaseModel],
+    *,
+    by_alias: bool = True,
+    ref_template: str = DEFAULT_REF_TEMPLATE,
+    schema_generator=None,
+    mode: JsonSchemaMode = "validation",
+) -> Dict[str, Any]:
+    """
+    Generates a JSON schema for a model class.
+
+    Parameters
+    ----------
+    by_alias : bool, optional
+        Whether to use attribute aliases or not, by default True
+    ref_template : str, optional
+        The reference template, by default DEFAULT_REF_TEMPLATE
+    schema_generator : type[GenerateEmptySchemaForUserClasses], optional
+        To override the logic used to generate the JSON schema, as a subclass of GenerateEmptySchemaForUserClasses with your desired modifications, by default GenerateEmptySchemaForUserClasses
+    mode : JsonSchemaMode, optional
+        The mode in which to generate the schema, by default 'validation'
+
+    Returns
+    -------
+    dict[str, Any]
+        The JSON schema for the given model class.
+    """
+    if is_pydantic_v2_compatible(fn_name="model_json_schema"):
+        schema_generator = GenerateJsonSchema
+        return model.model_json_schema(
+            by_alias=by_alias,
+            ref_template=ref_template,
+            schema_generator=schema_generator,
+            mode=mode,
+        )
+
+    return model.schema(
+        by_alias=by_alias,
+        ref_template=ref_template,
+    )

prefect/artifacts.py

@@ -0,0 +1,185 @@
+"""
+Interface for creating and reading artifacts.
+"""
+
+import json
+import math
+from typing import Any, Dict, List, Optional, Union
+from uuid import UUID
+
+from prefect.client.orchestration import PrefectClient
+from prefect.client.schemas.actions import ArtifactCreate
+from prefect.client.utilities import inject_client
+from prefect.context import FlowRunContext, TaskRunContext
+from prefect.utilities.asyncutils import sync_compatible
+
+INVALID_TABLE_TYPE_ERROR = (
+    "`create_table_artifact` requires a `table` argument of type `dict[list]` or"
+    " `list[dict]`."
+)
+
+
+@inject_client
+async def _create_artifact(
+    type: str,
+    key: Optional[str] = None,
+    description: Optional[str] = None,
+    data: Optional[Union[Dict[str, Any], Any]] = None,
+    client: Optional[PrefectClient] = None,
+) -> UUID:
+    """
+    Helper function to create an artifact.
+
+    Arguments:
+        type: A string identifying the type of artifact.
+        key: A user-provided string identifier.
+          The key must only contain lowercase letters, numbers, and dashes.
+        description: A user-specified description of the artifact.
+        data: A JSON payload that allows for a result to be retrieved.
+        client: The PrefectClient
+
+    Returns:
+        - The table artifact ID.
+    """
+    artifact_args = {}
+    task_run_ctx = TaskRunContext.get()
+    flow_run_ctx = FlowRunContext.get()
+
+    if task_run_ctx:
+        artifact_args["task_run_id"] = task_run_ctx.task_run.id
+        artifact_args["flow_run_id"] = task_run_ctx.task_run.flow_run_id
+    elif flow_run_ctx:
+        artifact_args["flow_run_id"] = flow_run_ctx.flow_run.id
+
+    if key is not None:
+        artifact_args["key"] = key
+    if type is not None:
+        artifact_args["type"] = type
+    if description is not None:
+        artifact_args["description"] = description
+    if data is not None:
+        artifact_args["data"] = data
+
+    artifact = ArtifactCreate(**artifact_args)
+
+    return await client.create_artifact(artifact=artifact)
+
+
+@sync_compatible
+async def create_link_artifact(
+    link: str,
+    link_text: Optional[str] = None,
+    key: Optional[str] = None,
+    description: Optional[str] = None,
+) -> UUID:
+    """
+    Create a link artifact.
+
+    Arguments:
+        link: The link to create.
+        link_text: The link text.
+        key: A user-provided string identifier.
+          Required for the artifact to show in the Artifacts page in the UI.
+          The key must only contain lowercase letters, numbers, and dashes.
+        description: A user-specified description of the artifact.
+
+
+    Returns:
+        The table artifact ID.
+    """
+    formatted_link = f"[{link_text}]({link})" if link_text else f"[{link}]({link})"
+    artifact = await _create_artifact(
+        key=key,
+        type="markdown",
+        description=description,
+        data=formatted_link,
+    )
+
+    return artifact.id
+
+
+@sync_compatible
+async def create_markdown_artifact(
+    markdown: str,
+    key: Optional[str] = None,
+    description: Optional[str] = None,
+) -> UUID:
+    """
+    Create a markdown artifact.
+
+    Arguments:
+        markdown: The markdown to create.
+        key: A user-provided string identifier.
+          Required for the artifact to show in the Artifacts page in the UI.
+          The key must only contain lowercase letters, numbers, and dashes.
+        description: A user-specified description of the artifact.
+
+    Returns:
+        The table artifact ID.
+    """
+    artifact = await _create_artifact(
+        key=key,
+        type="markdown",
+        description=description,
+        data=markdown,
+    )
+
+    return artifact.id
+
+
+@sync_compatible
+async def create_table_artifact(
+    table: Union[Dict[str, List[Any]], List[Dict[str, Any]], List[List[Any]]],
+    key: Optional[str] = None,
+    description: Optional[str] = None,
+) -> UUID:
+    """
+    Create a table artifact.
+
+    Arguments:
+        table: The table to create.
+        key: A user-provided string identifier.
+          Required for the artifact to show in the Artifacts page in the UI.
+          The key must only contain lowercase letters, numbers, and dashes.
+        description: A user-specified description of the artifact.
+
+    Returns:
+        The table artifact ID.
+    """
+
+    def _sanitize_nan_values(item):
+        """
+        Sanitize NaN values in a given item. The item can be a dict, list or float.
+        """
+
+        if isinstance(item, list):
+            return [_sanitize_nan_values(sub_item) for sub_item in item]
+
+        elif isinstance(item, dict):
+            return {k: _sanitize_nan_values(v) for k, v in item.items()}
+
+        elif isinstance(item, float) and math.isnan(item):
+            return None
+
+        else:
+            return item
+
+    sanitized_table = _sanitize_nan_values(table)
+
+    if isinstance(table, dict) and all(isinstance(v, list) for v in table.values()):
+        pass
+    elif isinstance(table, list) and all(isinstance(v, (list, dict)) for v in table):
+        pass
+    else:
+        raise TypeError(INVALID_TABLE_TYPE_ERROR)
+
+    formatted_table = json.dumps(sanitized_table)
+
+    artifact = await _create_artifact(
+        key=key,
+        type="table",
+        description=description,
+        data=formatted_table,
+    )
+
+    return artifact.id

prefect/client/base.py

@@ -1,9 +1,10 @@
 import copy
 import sys
 import threading
+import uuid
 from collections import defaultdict
 from contextlib import asynccontextmanager
-from functools import partial
+from datetime import datetime, timezone
 from typing import (
     Any,
     AsyncGenerator,
@@ -11,6 +12,7 @@ from typing import (
     Callable,
     Dict,
     MutableMapping,
+    Optional,
     Protocol,
     Set,
     Tuple,
@@ -21,10 +23,11 @@ from typing import (
 import anyio
 import httpx
 from asgi_lifespan import LifespanManager
-from httpx import HTTPStatusError, Response
+from httpx import HTTPStatusError, Request, Response
 from prefect._vendor.starlette import status
 from typing_extensions import Self
 
+from prefect.client.schemas.objects import CsrfToken
 from prefect.exceptions import PrefectHTTPStatusError
 from prefect.logging import get_logger
 from prefect.settings import (
@@ -188,9 +191,20 @@ class PrefectHttpxClient(httpx.AsyncClient):
     [Configuring Cloudflare Rate Limiting](https://support.cloudflare.com/hc/en-us/articles/115001635128-Configuring-Rate-Limiting-from-UI)
     """
 
+    def __init__(self, *args, enable_csrf_support: bool = False, **kwargs):
+        self.enable_csrf_support: bool = enable_csrf_support
+        self.csrf_token: Optional[str] = None
+        self.csrf_token_expiration: Optional[datetime] = None
+        self.csrf_client_id: uuid.UUID = uuid.uuid4()
+
+        super().__init__(*args, **kwargs)
+
     async def _send_with_retry(
         self,
-        request: Callable,
+        request: Request,
+        send: Callable[[Request], Awaitable[Response]],
+        send_args: Tuple,
+        send_kwargs: Dict,
         retry_codes: Set[int] = set(),
         retry_exceptions: Tuple[Exception, ...] = tuple(),
     ):
@@ -207,21 +221,34 @@ class PrefectHttpxClient(httpx.AsyncClient):
         try_count = 0
         response = None
 
+        is_change_request = request.method.lower() in {"post", "put", "patch", "delete"}
+
+        if self.enable_csrf_support and is_change_request:
+            await self._add_csrf_headers(request=request)
+
         while try_count <= PREFECT_CLIENT_MAX_RETRIES.value():
             try_count += 1
             retry_seconds = None
             exc_info = None
 
             try:
-                response = await request()
+                response = await send(request, *send_args, **send_kwargs)
             except retry_exceptions:  # type: ignore
                 if try_count > PREFECT_CLIENT_MAX_RETRIES.value():
                     raise
                 # Otherwise, we will ignore this error but capture the info for logging
                 exc_info = sys.exc_info()
             else:
-                # We got a response; return immediately if it is not retryable
-                if response.status_code not in retry_codes:
+                # We got a response; check if it's a CSRF error, otherwise
+                # return immediately if it is not retryable
+                if (
+                    response.status_code == status.HTTP_403_FORBIDDEN
+                    and "Invalid CSRF token" in response.text
+                ):
+                    # We got a CSRF error, clear the token and try again
+                    self.csrf_token = None
+                    await self._add_csrf_headers(request)
+                elif response.status_code not in retry_codes:
                     return response
 
                 if "Retry-After" in response.headers:
@@ -268,19 +295,24 @@ class PrefectHttpxClient(httpx.AsyncClient):
         # We ran out of retries, return the failed response
         return response
 
-    async def send(self, *args, **kwargs) -> Response:
+    async def send(self, request: Request, *args, **kwargs) -> Response:
         """
         Send a request with automatic retry behavior for the following status codes:
 
+        - 403 Forbidden, if the request failed due to CSRF protection
+        - 408 Request Timeout
         - 429 CloudFlare-style rate limiting
         - 502 Bad Gateway
         - 503 Service unavailable
+        - Any additional status codes provided in `PREFECT_CLIENT_RETRY_EXTRA_CODES`
         """
 
-        api_request = partial(super().send, *args, **kwargs)
-
+        super_send = super().send
         response = await self._send_with_retry(
-            request=api_request,
+            request=request,
+            send=super_send,
+            send_args=args,
+            send_kwargs=kwargs,
             retry_codes={
                 status.HTTP_429_TOO_MANY_REQUESTS,
                 status.HTTP_503_SERVICE_UNAVAILABLE,
@@ -312,3 +344,41 @@ class PrefectHttpxClient(httpx.AsyncClient):
         response.raise_for_status()
 
         return response
+
+    async def _add_csrf_headers(self, request: Request):
+        now = datetime.now(timezone.utc)
+
+        if not self.enable_csrf_support:
+            return
+
+        if not self.csrf_token or (
+            self.csrf_token_expiration and now > self.csrf_token_expiration
+        ):
+            token_request = self.build_request(
+                "GET", f"/csrf-token?client={self.csrf_client_id}"
+            )
+
+            try:
+                token_response = await self.send(token_request)
+            except PrefectHTTPStatusError as exc:
+                old_server = exc.response.status_code == status.HTTP_404_NOT_FOUND
+                unconfigured_server = (
+                    exc.response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+                    and "CSRF protection is disabled." in exc.response.text
+                )
+
+                if old_server or unconfigured_server:
+                    # The token endpoint is either unavailable, suggesting an
+                    # older server, or CSRF protection is disabled. In either
+                    # case we should disable CSRF support.
+                    self.enable_csrf_support = False
+                    return
+
+                raise
+
+            token: CsrfToken = CsrfToken.parse_obj(token_response.json())
+            self.csrf_token = token.token
+            self.csrf_token_expiration = token.expiration
+
+        request.headers["Prefect-Csrf-Token"] = self.csrf_token
+        request.headers["Prefect-Csrf-Client"] = str(self.csrf_client_id)

prefect/client/cloud.py

@@ -72,7 +72,7 @@ class CloudClient:
         httpx_settings.setdefault("base_url", host)
         if not PREFECT_UNIT_TEST_MODE.value():
             httpx_settings.setdefault("follow_redirects", True)
-        self._client = PrefectHttpxClient(**httpx_settings)
+        self._client = PrefectHttpxClient(**httpx_settings, enable_csrf_support=False)
 
     async def api_healthcheck(self):
         """

prefect/client/orchestration.py

@@ -15,6 +15,7 @@ from typing import (
 )
 from uuid import UUID, uuid4
 
+import certifi
 import httpcore
 import httpx
 import pendulum
@@ -134,8 +135,10 @@ from prefect.settings import (
     PREFECT_API_ENABLE_HTTP2,
     PREFECT_API_KEY,
     PREFECT_API_REQUEST_TIMEOUT,
+    PREFECT_API_SSL_CERT_FILE,
     PREFECT_API_TLS_INSECURE_SKIP_VERIFY,
     PREFECT_API_URL,
+    PREFECT_CLIENT_CSRF_SUPPORT_ENABLED,
     PREFECT_CLOUD_API_URL,
     PREFECT_UNIT_TEST_MODE,
 )
@@ -220,6 +223,11 @@ class PrefectClient:
 
         if PREFECT_API_TLS_INSECURE_SKIP_VERIFY:
             httpx_settings.setdefault("verify", False)
+        else:
+            cert_file = PREFECT_API_SSL_CERT_FILE.value()
+            if not cert_file:
+                cert_file = certifi.where()
+            httpx_settings.setdefault("verify", cert_file)
 
         if api_version is None:
             api_version = SERVER_API_VERSION
@@ -316,7 +324,15 @@ class PrefectClient:
 
         if not PREFECT_UNIT_TEST_MODE:
             httpx_settings.setdefault("follow_redirects", True)
-        self._client = PrefectHttpxClient(**httpx_settings)
+
+        enable_csrf_support = (
+            self.server_type != ServerType.CLOUD
+            and PREFECT_CLIENT_CSRF_SUPPORT_ENABLED.value()
+        )
+
+        self._client = PrefectHttpxClient(
+            **httpx_settings, enable_csrf_support=enable_csrf_support
+        )
         self._loop = None
 
         # See https://www.python-httpx.org/advanced/#custom-transports

prefect/client/schemas/objects.py

@@ -1632,3 +1632,16 @@ class GlobalConcurrencyLimit(ObjectBaseModel):
             " is used as a rate limit."
         ),
     )
+
+
+class CsrfToken(ObjectBaseModel):
+    token: str = Field(
+        default=...,
+        description="The CSRF token",
+    )
+    client: str = Field(
+        default=..., description="The client id associated with the CSRF token"
+    )
+    expiration: DateTimeTZ = Field(
+        default=..., description="The expiration time of the CSRF token"
+    )

prefect/client/subscriptions.py

@@ -74,9 +74,9 @@ class Subscription(Generic[S]):
             auth: Dict[str, Any] = orjson.loads(await websocket.recv())
             assert auth["type"] == "auth_success", auth.get("message")
 
-            message = {"type": "subscribe", "keys": self.keys} | {
-                **(dict(client_id=self.client_id) if self.client_id else {})
-            }
+            message = {"type": "subscribe", "keys": self.keys}
+            if self.client_id:
+                message.update({"client_id": self.client_id})
 
             await websocket.send(orjson.dumps(message).decode())
         except (

prefect/engine.py

@@ -2002,10 +2002,14 @@ async def orchestrate_task_run(
     )
 
     # Emit an event to capture that the task run was in the `PENDING` state.
-    last_event = _emit_task_run_state_change_event(
+    last_event = emit_task_run_state_change_event(
         task_run=task_run, initial_state=None, validated_state=task_run.state
     )
-    last_state = task_run.state
+    last_state = (
+        Pending()
+        if flow_run_context and flow_run_context.autonomous_task_run
+        else task_run.state
+    )
 
     # Completed states with persisted results should have result data. If it's missing,
     # this could be a manual state transition, so we should use the Unknown result type
@@ -2094,7 +2098,7 @@ async def orchestrate_task_run(
                 break
 
     # Emit an event to capture the result of proposing a `RUNNING` state.
-    last_event = _emit_task_run_state_change_event(
+    last_event = emit_task_run_state_change_event(
         task_run=task_run,
         initial_state=last_state,
         validated_state=state,
@@ -2187,7 +2191,7 @@ async def orchestrate_task_run(
                     await _check_task_failure_retriable(task, task_run, terminal_state)
                 )
             state = await propose_state(client, terminal_state, task_run_id=task_run.id)
-            last_event = _emit_task_run_state_change_event(
+            last_event = emit_task_run_state_change_event(
                 task_run=task_run,
                 initial_state=last_state,
                 validated_state=state,
@@ -2220,7 +2224,7 @@ async def orchestrate_task_run(
                 )
                 # Attempt to enter a running state again
                 state = await propose_state(client, Running(), task_run_id=task_run.id)
-                last_event = _emit_task_run_state_change_event(
+                last_event = emit_task_run_state_change_event(
                     task_run=task_run,
                     initial_state=last_state,
                     validated_state=state,
@@ -2896,7 +2900,7 @@ async def check_api_reachable(client: PrefectClient, fail_message: str):
     API_HEALTHCHECKS[api_url] = get_deadline(60 * 10)
 
 
-def _emit_task_run_state_change_event(
+def emit_task_run_state_change_event(
     task_run: TaskRun,
     initial_state: Optional[State],
     validated_state: State,

prefect/events/related.py

@@ -74,7 +74,7 @@ async def related_resources_from_run_context(
     if flow_run_id is None:
         return []
 
-    related_objects: list[ResourceCacheEntry] = []
+    related_objects: List[ResourceCacheEntry] = []
 
     async with get_client() as client:
 

prefect/events/schemas.py

@@ -372,9 +372,53 @@ class MetricTrigger(ResourceTrigger):
     )
 
 
-TriggerTypes: TypeAlias = Union[EventTrigger, MetricTrigger]
+class CompositeTrigger(Trigger, abc.ABC):
+    """
+    Requires some number of triggers to have fired within the given time period.
+    """
+
+    type: Literal["compound", "sequence"]
+    triggers: List["TriggerTypes"]
+    within: Optional[timedelta]
+
+
+class CompoundTrigger(CompositeTrigger):
+    """A composite trigger that requires some number of triggers to have
+    fired within the given time period"""
+
+    type: Literal["compound"] = "compound"
+    require: Union[int, Literal["any", "all"]]
+
+    @root_validator
+    def validate_require(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        require = values.get("require")
+
+        if isinstance(require, int):
+            if require < 1:
+                raise ValueError("required must be at least 1")
+            if require > len(values["triggers"]):
+                raise ValueError(
+                    "required must be less than or equal to the number of triggers"
+                )
+
+        return values
+
+
+class SequenceTrigger(CompositeTrigger):
+    """A composite trigger that requires some number of triggers to have fired
+    within the given time period in a specific order"""
+
+    type: Literal["sequence"] = "sequence"
+
+
+TriggerTypes: TypeAlias = Union[
+    EventTrigger, MetricTrigger, CompoundTrigger, SequenceTrigger
+]
 """The union of all concrete trigger types that a user may actually create"""
 
+CompoundTrigger.update_forward_refs()
+SequenceTrigger.update_forward_refs()
+
 
 class Automation(PrefectBaseModel):
     """Defines an action a user wants to take when a certain number of events

prefect/flows.py

@@ -1345,8 +1345,12 @@ def flow(
     result_serializer: Optional[ResultSerializer] = None,
     cache_result_in_memory: bool = True,
     log_prints: Optional[bool] = None,
-    on_completion: Optional[List[Callable[[FlowSchema, FlowRun, State], None]]] = None,
-    on_failure: Optional[List[Callable[[FlowSchema, FlowRun, State], None]]] = None,
+    on_completion: Optional[
+        List[Callable[[FlowSchema, FlowRun, State], Union[Awaitable[None], None]]]
+    ] = None,
+    on_failure: Optional[
+        List[Callable[[FlowSchema, FlowRun, State], Union[Awaitable[None], None]]]
+    ] = None,
     on_cancellation: Optional[
         List[Callable[[FlowSchema, FlowRun, State], None]]
     ] = None,
@@ -1373,8 +1377,12 @@ def flow(
     result_serializer: Optional[ResultSerializer] = None,
     cache_result_in_memory: bool = True,
     log_prints: Optional[bool] = None,
-    on_completion: Optional[List[Callable[[FlowSchema, FlowRun, State], None]]] = None,
-    on_failure: Optional[List[Callable[[FlowSchema, FlowRun, State], None]]] = None,
+    on_completion: Optional[
+        List[Callable[[FlowSchema, FlowRun, State], Union[Awaitable[None], None]]]
+    ] = None,
+    on_failure: Optional[
+        List[Callable[[FlowSchema, FlowRun, State], Union[Awaitable[None], None]]]
+    ] = None,
     on_cancellation: Optional[
         List[Callable[[FlowSchema, FlowRun, State], None]]
     ] = None,

prefect/server/api/collections_data/views/aggregate-worker-metadata.json

@@ -912,8 +912,7 @@
             "metadata": {
               "name": "{{ name }}",
               "annotations": {
-                "run.googleapis.com/launch-stage": "BETA",
-                "run.googleapis.com/vpc-access-connector": "{{ vpc_connector_name }}"
+                "run.googleapis.com/launch-stage": "BETA"
               }
             },
             "spec": {
@@ -941,6 +940,11 @@
                       "serviceAccountName": "{{ service_account_name }}"
                     }
                   }
+                },
+                "metadata": {
+                  "annotations": {
+                    "run.googleapis.com/vpc-access-connector": "{{ vpc_connector_name }}"
+                  }
                 }
               }
             }
@@ -1093,8 +1097,10 @@
             "launchStage": "{{ launch_stage }}",
             "template": {
               "template": {
+                "serviceAccount": "{{ service_account_name }}",
                 "maxRetries": "{{ max_retries }}",
                 "timeout": "{{ timeout }}",
+                "vpcAccess": "{{ vpc_connector_name }}",
                 "containers": [
                   {
                     "env": [],
@@ -1229,6 +1235,12 @@
               "title": "VPC Connector Name",
               "description": "The name of the VPC connector to use for the Cloud Run job.",
               "type": "string"
+            },
+            "service_account_name": {
+              "title": "Service Account Name",
+              "description": "The name of the service account to use for the task execution of Cloud Run Job. By default Cloud Run jobs run as the default Compute Engine Service Account.",
+              "example": "service-account@example.iam.gserviceaccount.com",
+              "type": "string"
             }
           },
           "definitions": {

prefect/settings.py

@@ -102,7 +102,10 @@ T = TypeVar("T")
 
 DEFAULT_PROFILES_PATH = Path(__file__).parent.joinpath("profiles.toml")
 
-REMOVED_EXPERIMENTAL_FLAGS = {"PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_SCHEDULING_UI"}
+REMOVED_EXPERIMENTAL_FLAGS = {
+    "PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_SCHEDULING_UI",
+    "PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_DEPLOYMENT_PARAMETERS",
+}
 
 
 class Setting(Generic[T]):
@@ -592,6 +595,16 @@ PREFECT_API_TLS_INSECURE_SKIP_VERIFY = Setting(
 This is recommended only during development, e.g. when using self-signed certificates.
 """
 
+PREFECT_API_SSL_CERT_FILE = Setting(
+    str,
+    default=os.environ.get("SSL_CERT_FILE"),
+)
+"""
+This configuration settings option specifies the path to an SSL certificate file. 
+When set, it allows the application to use the specified certificate for secure communication. 
+If left unset, the setting will default to the value provided by the `SSL_CERT_FILE` environment variable.
+"""
+
 PREFECT_API_URL = Setting(
     str,
     default=None,
@@ -657,6 +670,21 @@ A comma-separated list of extra HTTP status codes to retry on. Defaults to an em
 may result in unexpected behavior.
 """
 
+PREFECT_CLIENT_CSRF_SUPPORT_ENABLED = Setting(bool, default=True)
+"""
+Determines if CSRF token handling is active in the Prefect client for API
+requests.
+
+When enabled (`True`), the client automatically manages CSRF tokens by
+retrieving, storing, and including them in applicable state-changing requests
+(POST, PUT, PATCH, DELETE) to the API.
+
+Disabling this setting (`False`) means the client will not handle CSRF tokens,
+which might be suitable for environments where CSRF protection is disabled.
+
+Defaults to `True`, ensuring CSRF protection is enabled by default.
+"""
+
 PREFECT_CLOUD_API_URL = Setting(
     str,
     default="https://api.prefect.cloud/api",
@@ -1207,6 +1235,33 @@ Note this setting only applies when calling `prefect server start`; if hosting t
 API with another tool you will need to configure this there instead.
 """
 
+PREFECT_SERVER_CSRF_PROTECTION_ENABLED = Setting(bool, default=False)
+"""
+Controls the activation of CSRF protection for the Prefect server API.
+
+When enabled (`True`), the server enforces CSRF validation checks on incoming
+state-changing requests (POST, PUT, PATCH, DELETE), requiring a valid CSRF
+token to be included in the request headers or body. This adds a layer of
+security by preventing unauthorized or malicious sites from making requests on
+behalf of authenticated users.
+
+It is recommended to enable this setting in production environments where the
+API is exposed to web clients to safeguard against CSRF attacks.
+
+Note: Enabling this setting requires corresponding support in the client for
+CSRF token management. See PREFECT_CLIENT_CSRF_SUPPORT_ENABLED for more.
+"""
+
+PREFECT_SERVER_CSRF_TOKEN_EXPIRATION = Setting(timedelta, default=timedelta(hours=1))
+"""
+Specifies the duration for which a CSRF token remains valid after being issued
+by the server.
+
+The default expiration time is set to 1 hour, which offers a reasonable
+compromise. Adjust this setting based on your specific security requirements
+and usage patterns.
+"""
+
 PREFECT_UI_ENABLED = Setting(
     bool,
     default=True,
@@ -1292,12 +1347,12 @@ PREFECT_API_MAX_FLOW_RUN_GRAPH_ARTIFACTS = Setting(int, default=10000)
 The maximum number of artifacts to show on a flow run graph on the v2 API
 """
 
-PREFECT_EXPERIMENTAL_ENABLE_ARTIFACTS_ON_FLOW_RUN_GRAPH = Setting(bool, default=False)
+PREFECT_EXPERIMENTAL_ENABLE_ARTIFACTS_ON_FLOW_RUN_GRAPH = Setting(bool, default=True)
 """
 Whether or not to enable artifacts on the flow run graph.
 """
 
-PREFECT_EXPERIMENTAL_ENABLE_STATES_ON_FLOW_RUN_GRAPH = Setting(bool, default=False)
+PREFECT_EXPERIMENTAL_ENABLE_STATES_ON_FLOW_RUN_GRAPH = Setting(bool, default=True)
 """
 Whether or not to enable flow run states on the flow run graph.
 """
@@ -1342,11 +1397,6 @@ PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_CANCELLATION = Setting(bool, default=True)
 Whether or not to enable experimental enhanced flow run cancellation.
 """
 
-PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_DEPLOYMENT_PARAMETERS = Setting(bool, default=True)
-"""
-Whether or not to enable enhanced deployment parameters.
-"""
-
 PREFECT_EXPERIMENTAL_WARN_ENHANCED_CANCELLATION = Setting(bool, default=False)
 """
 Whether or not to warn when experimental enhanced flow run cancellation is used.
@@ -1525,6 +1575,10 @@ PREFECT_EXPERIMENTAL_ENABLE_WORK_QUEUE_STATUS = Setting(bool, default=True)
 Whether or not to enable experimental work queue status in-place of work queue health.
 """
 
+PREFECT_EXPERIMENTAL_ENABLE_PYDANTIC_V2_INTERNALS = Setting(bool, default=False)
+"""
+Whether or not to enable internal experimental Pydantic v2 behavior.
+"""
 
 # Defaults -----------------------------------------------------------------------------
 

prefect/task_server.py

@@ -6,7 +6,7 @@ import socket
 import sys
 from contextlib import AsyncExitStack
 from functools import partial
-from typing import Optional, Type
+from typing import List, Optional, Type
 
 import anyio
 from websockets.exceptions import InvalidStatusCode
@@ -15,7 +15,7 @@ from prefect import Task, get_client
 from prefect._internal.concurrency.api import create_call, from_sync
 from prefect.client.schemas.objects import TaskRun
 from prefect.client.subscriptions import Subscription
-from prefect.engine import propose_state
+from prefect.engine import emit_task_run_state_change_event, propose_state
 from prefect.logging.loggers import get_logger
 from prefect.results import ResultFactory
 from prefect.settings import (
@@ -72,7 +72,7 @@ class TaskServer:
         *tasks: Task,
         task_runner: Optional[Type[BaseTaskRunner]] = None,
     ):
-        self.tasks: list[Task] = tasks
+        self.tasks: List[Task] = tasks
 
         self.task_runner: BaseTaskRunner = task_runner or ConcurrentTaskRunner()
         self.started: bool = False
@@ -205,6 +205,12 @@ class TaskServer:
                 " Task run may have already begun execution."
             )
 
+        emit_task_run_state_change_event(
+            task_run=task_run,
+            initial_state=task_run.state,
+            validated_state=state,
+        )
+
         self._runs_task_group.start_soon(
             partial(
                 submit_autonomous_task_run_to_engine,

prefect/tasks.py

@@ -283,13 +283,14 @@ class Task(Generic[P, R]):
         if not hasattr(self.fn, "__qualname__"):
             self.task_key = to_qualified_name(type(self.fn))
         else:
-            if self.fn.__module__ == "__main__":
-                task_definition_path = inspect.getsourcefile(self.fn)
-                self.task_key = hash_objects(
-                    self.name, os.path.abspath(task_definition_path)
+            try:
+                task_origin_hash = hash_objects(
+                    self.name, os.path.abspath(inspect.getsourcefile(self.fn))
                 )
-            else:
-                self.task_key = to_qualified_name(self.fn)
+            except TypeError:
+                task_origin_hash = "unknown-source-file"
+
+            self.task_key = f"{self.fn.__qualname__}-{task_origin_hash}"
 
         self.cache_key_fn = cache_key_fn
         self.cache_expiration = cache_expiration
@@ -390,8 +391,12 @@ class Task(Generic[P, R]):
         timeout_seconds: Union[int, float] = None,
         log_prints: Optional[bool] = NotSet,
         refresh_cache: Optional[bool] = NotSet,
-        on_completion: Optional[List[Callable[["Task", TaskRun, State], None]]] = None,
-        on_failure: Optional[List[Callable[["Task", TaskRun, State], None]]] = None,
+        on_completion: Optional[
+            List[Callable[["Task", TaskRun, State], Union[Awaitable[None], None]]]
+        ] = None,
+        on_failure: Optional[
+            List[Callable[["Task", TaskRun, State], Union[Awaitable[None], None]]]
+        ] = None,
         retry_condition_fn: Optional[Callable[["Task", TaskRun, State], bool]] = None,
         viz_return_value: Optional[Any] = None,
     ):

prefect/utilities/callables.py

@@ -1,6 +1,7 @@
 """
 Utilities for working with Python callables.
 """
+
 import inspect
 from functools import partial
 from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
@@ -312,8 +313,9 @@ def parameter_schema(fn: Callable) -> ParameterSchema:
         ParameterSchema: the argument schema
     """
     try:
-        signature = inspect.signature(fn, eval_str=True)
+        signature = inspect.signature(fn, eval_str=True)  # novm
     except (NameError, TypeError):
+        # `eval_str` is not available in Python < 3.10
         signature = inspect.signature(fn)
 
     model_fields = {}

{prefect_client-2.16.4.dist-info → prefect_client-2.16.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 2.16.4
+Version: 2.16.5
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect_client-2.16.4.dist-info → prefect_client-2.16.5.dist-info}/RECORD

@@ -2,12 +2,13 @@ prefect/.prefectignore,sha256=awSprvKT0vI8a64mEOLrMxhxqcO-b0ERQeYpA2rNKVQ,390
 prefect/__init__.py,sha256=FqZ2FacBZq5wr-RnLQphwqXN0atLdu9bDC2YtmZi-AU,5456
 prefect/_version.py,sha256=fQguBh1dzT7Baahj504O5RrsLlSyg3Zrx42OpgdPnFc,22378
 prefect/agent.py,sha256=ZHRiQo13SC8F_flWaoWskVopM1DZKgZVwx9kkg_z0A0,27791
+prefect/artifacts.py,sha256=QLnFkVaBpMQp9fLWkHlayZOUCp2OI6lPmAkUbT-NMLo,5274
 prefect/context.py,sha256=QK_U3ym-h2i1Y_EOSr4BQeeMN0AIOpG81LQS7k1RiRA,18103
-prefect/engine.py,sha256=ZWu-4oyOeoJ-CWe-Yz3SVNg7GkoMVfVjPu72ZAFLvx4,110024
+prefect/engine.py,sha256=kWU4jJQm3ApiJiuq3rZysyZZC2zBQc3DdJuYfpydmIE,110127
 prefect/exceptions.py,sha256=84rpsDLp0cn_v2gE1TnK_NZXh27NJtzgZQtARVKyVEE,10953
 prefect/filesystems.py,sha256=HkBczs0r69yJQRWsPUVJiU2JKK6NPrkPvSSVIUrvMpQ,36444
 prefect/flow_runs.py,sha256=mFHLavZk1yZ62H3UazuNDBZWAF7AqKttA4rMcHgsVSw,3119
-prefect/flows.py,sha256=B4W5kAX3jNjBoYmZQYnZ6XC3_th3F8IKTc5MUiZ8_YI,70123
+prefect/flows.py,sha256=CvQ_sGsJNA7zs4i9l4jaZpReon_RznSeK8vZ4TbpSY0,70275
 prefect/futures.py,sha256=RaWfYIXtH7RsWxQ5QWTTlAzwtVV8XWpXaZT_hLq35vQ,12590
 prefect/manifests.py,sha256=xfwEEozSEqPK2Lro4dfgdTnjVbQx-aCECNBnf7vO7ZQ,808
 prefect/plugins.py,sha256=0C-D3-dKi06JZ44XEGmLjCiAkefbE_lKX-g3urzdbQ4,4163
@@ -15,12 +16,12 @@ prefect/profiles.toml,sha256=1Tz7nKBDTDXL_6KPJSeB7ok0Vx_aQJ_p0AUmbnzDLzw,39
 prefect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/results.py,sha256=FgudRagwoNKVKR5590I4AN0mxgYoyXG_7Q1HVoMXdaU,24731
 prefect/serializers.py,sha256=sSbe40Ipj-d6VuzBae5k2ao9lkMUZpIXcLtD7f2a7cE,10852
-prefect/settings.py,sha256=4YgZ6LxyWr-WIj5B50K3eXJrtnsbYdlAz9mPDJ4cVCc,68890
+prefect/settings.py,sha256=3xU5DQQglwa7MFnYQ6GqhWHbdIis81Ehnj1fMa7d30M,71067
 prefect/states.py,sha256=-Ud4AUom3Qu-HQ4hOLvfVZuuF-b_ibaqtzmL7V949Ac,20839
 prefect/task_engine.py,sha256=_2I7XLwoT_nNhpzTMa_52aQKjsDoaW6WpzwIHYEWZS0,2598
 prefect/task_runners.py,sha256=HXUg5UqhZRN2QNBqMdGE1lKhwFhT8TaRN75ScgLbnw8,11012
-prefect/task_server.py,sha256=Fga_2DOhPgXIO2f-R4u6pOtMxxJfqHyjX9r627-5a78,10331
-prefect/tasks.py,sha256=pwTZcyv7meEomogREofh1r3gDcaG-VSz8vO1_F3QBcg,50390
+prefect/task_server.py,sha256=6sJAQ6re5ahAHF9IjYkr05mUgefUB6Ga0BeKicgH84A,10532
+prefect/tasks.py,sha256=AFDCyb0p0r8mamiFMu220-DfGMLSjq-uRi4vL6oxQOE,50477
 prefect/variables.py,sha256=sk3pfwfPY5lKLt4Qi7OQJPeYipzYip3gidgA9gydcpI,978
 prefect/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/_internal/_logging.py,sha256=HvNHY-8P469o5u4LYEDBTem69XZEt1QUeUaLToijpak,810
@@ -30,7 +31,7 @@ prefect/_internal/compatibility/deprecated.py,sha256=5vd4iIzpeGftFdtVaP6PCKNQRiN
 prefect/_internal/compatibility/experimental.py,sha256=bQ2ia6MjgIu1SAWpkGVza87wSz5aTo58X_z3JawqleQ,7442
 prefect/_internal/concurrency/__init__.py,sha256=ncKwi1NhE3umSFGSKRk9wEVKzN1z1ZD-fmY4EDZHH_U,2142
 prefect/_internal/concurrency/api.py,sha256=I6OHx53rP7f8GI_O-VHLook1wJfM5Wbe6i2OlAcEcjs,8765
-prefect/_internal/concurrency/calls.py,sha256=AC7SW8T97RZKQvqD_4IwhlDzIq3aem8bdKDTAOonY6E,15553
+prefect/_internal/concurrency/calls.py,sha256=SVMR1yPTQJtBX095WfRk6cMTq4YKf_L6G77qtaTyN3I,15564
 prefect/_internal/concurrency/cancellation.py,sha256=eiVsdG5BE_2HCvkQGzIcZ6Gw4ANmchcPRzHsI9wtP3Y,18201
 prefect/_internal/concurrency/event_loop.py,sha256=rOxUa7e95xP4ionH3o0gRpUzzG6aZMQUituLpMTvTFo,2596
 prefect/_internal/concurrency/inspection.py,sha256=GWFoSzgs8bZZGNN-Im9sQ-0t0Dqdn8EbwPR1UY3Mhro,3452
@@ -38,7 +39,8 @@ prefect/_internal/concurrency/primitives.py,sha256=kxCPD9yLtCeqt-JIHjevL4Zt5FvrF
 prefect/_internal/concurrency/services.py,sha256=aggJd4IUSB6ufppRYdRT-36daEg1JSpJCvK635R8meg,11951
 prefect/_internal/concurrency/threads.py,sha256=-tReWZL9_XMkRS35SydAfeePH2vqCqb1CGM8lgrKT1I,7846
 prefect/_internal/concurrency/waiters.py,sha256=DXTD_bbVEUhcTplYQFX8mGmL6nsqJGEDfvS0TmHmIQk,9475
-prefect/_internal/pydantic/__init__.py,sha256=ZTFHClaJIxIHpFFIHrZD1rZbWrY-1yyvAvLvwy1IQCk,423
+prefect/_internal/pydantic/__init__.py,sha256=zhbVYT051zywa0rF7Q62jaVFH2D2no3CTCJ1ZXktmR8,482
+prefect/_internal/pydantic/_compat.py,sha256=YTRAmOTTYybXKJtwsPjee40shpWCtAYlI7RZbPADVO0,6532
 prefect/_internal/pydantic/schemas.py,sha256=tsRKq5yEIgiRbWMl3BPnbfNaKyDN6pq8WSs0M8SQMm4,452
 prefect/_internal/pydantic/v2_schema.py,sha256=fySqjMCFoJpRs7wN6c5qoVKePbDbWcXYUoYOs5eFzL0,3485
 prefect/_internal/pydantic/v2_validated_func.py,sha256=44I4o8jjiS7TYep-E6UYMwjpYH5F1WwJFajW81A3wts,3823
@@ -137,17 +139,17 @@ prefect/blocks/notifications.py,sha256=gtr2irqxlvQ5aJTUioG1VfsdSL1xu5e8pWxAYzf49
 prefect/blocks/system.py,sha256=Nlp-3315Hye3FJ5uhDovSPGBIEKi5UbCkAcy3hDxhKk,3057
 prefect/blocks/webhook.py,sha256=hhyWck7mAPfD_12bl40dJedNC9HIaqs7z13iYcZZ14o,2005
 prefect/client/__init__.py,sha256=yJ5FRF9RxNUio2V_HmyKCKw5G6CZO0h8cv6xA_Hkpcc,477
-prefect/client/base.py,sha256=yUIiMH3qvm0esS5H22LwZGXZO2Vv-9MdbRu1yqMNOwg,12225
-prefect/client/cloud.py,sha256=jResyTjMNt69x_VoqUyoY6K0kmO9yZL6PyAvxbsJuYk,3971
+prefect/client/base.py,sha256=VsJWgaSEyIbHo2MfIkBuErahYwXnU68P3R-n83jx2LI,15211
+prefect/client/cloud.py,sha256=rrxwmYE9yH4HIewu-xG0HY4P7rwP9gFNitBMYQybcvE,3998
 prefect/client/collections.py,sha256=I9EgbTg4Fn57gn8vwP_WdDmgnATbx9gfkm2jjhCORjw,1037
 prefect/client/constants.py,sha256=Z_GG8KF70vbbXxpJuqW5pLnwzujTVeHbcYYRikNmGH0,29
-prefect/client/orchestration.py,sha256=OAVaxD_oFgYxri8OjmB67w5kwqX81jKxVPIAQsViX1U,110691
-prefect/client/subscriptions.py,sha256=Z505esj6hnCLUuiVUd8eNdyWVsU0oHn_2STPGDHq4ts,3374
+prefect/client/orchestration.py,sha256=HnBg-i5vrbzhn0KaXgJDbGST5KDsmEv5oJFyWDemHZ0,111199
+prefect/client/subscriptions.py,sha256=3kqPH3F-CwyrR5wygCpJMjRjM_gcQjd54Qjih6FcLlA,3372
 prefect/client/utilities.py,sha256=oGU8dJIq7ExEF4WFt-0aSPNX0JP7uH6NmfRlNhfJu00,2660
 prefect/client/schemas/__init__.py,sha256=KlyqFV-hMulMkNstBn_0ijoHoIwJZaBj6B1r07UmgvE,607
 prefect/client/schemas/actions.py,sha256=hoJ6q10z6lS-GA2osURjBp-rD0lOzJA2qGu6Opnonjo,25937
 prefect/client/schemas/filters.py,sha256=r6gnxZREnmE8Glt2SF6vPxHr0SIeiFBjTrrN32cw-Mo,35514
-prefect/client/schemas/objects.py,sha256=6JjKbjHf_N3bjqLN-ORCCFc48ieR3YscWN_rMJWkba0,55211
+prefect/client/schemas/objects.py,sha256=U3rNUzQspoenwxpb_1b5PcVsX5s2KSNPW9wl1EbGqAE,55562
 prefect/client/schemas/responses.py,sha256=hErSClfLjt3Ys18YZyZS6dyjVf3eLkiAF6mjEgF4LGg,9344
 prefect/client/schemas/schedules.py,sha256=ncGWmmBzZvf5G4AL27E0kWGiJxGX-haR2_-GUNvFlv4,14829
 prefect/client/schemas/sorting.py,sha256=Y-ea8k_vTUKAPKIxqGebwLSXM7x1s5mJ_4-sDd1Ivi8,2276
@@ -179,8 +181,8 @@ prefect/events/actions.py,sha256=wYc52xin_CLrNZaou05FdGdLZ5VEhT2lKM_k-MQEJ34,139
 prefect/events/clients.py,sha256=_4_QV6TWnG-dOIXWaudMprxmdjUaqMc8BgZHYdnGuHU,13975
 prefect/events/filters.py,sha256=vSWHGDCCsi_znQs3gZomCxh-Q498ukn_QHJ7H8q16do,6922
 prefect/events/instrument.py,sha256=uNiD7AnkfuiwTsCMgNyJURmY9H2tXNfLCb3EC5FL0Qw,3805
-prefect/events/related.py,sha256=N0o19kTlos1V4L4AgO79Z_k06ZW9bfjSH8Xa9h7lugg,6746
-prefect/events/schemas.py,sha256=OR_fqi1jgRddgz00AL1tIVVvlN58VVSyaHK7yi2fpO4,18163
+prefect/events/related.py,sha256=jMsCL6VKgMmMcVF4TXdJxQQRT5sxCuAu6piAxSOJxxs,6746
+prefect/events/schemas.py,sha256=x1Wy7btsI6RZ5FSBmdMVmU4WD8ZPANGoJ8uDJgW9VJc,19475
 prefect/events/utilities.py,sha256=gUEJA_kVuYASCqDpGX0HwDW0yczMX0AdgmxXbxhzWbM,2452
 prefect/events/worker.py,sha256=Z6MZmcCyXZtWi4vEtnFyvnzIEBW7HD14lEH1Crye3gY,2716
 prefect/infrastructure/__init__.py,sha256=Fm1Rhc4I7ZfJePpUAl1F4iNEtcDugoT650WXXt6xoCM,770
@@ -214,7 +216,7 @@ prefect/runtime/__init__.py,sha256=iYmfK1HmXiXXCQK77wDloOqZmY7SFF5iyr37jRzuf-c,4
 prefect/runtime/deployment.py,sha256=UWNXH-3-NNVxLCl5XnDKiofo4a5j8w_42ns1OSQMixg,4751
 prefect/runtime/flow_run.py,sha256=aFM3e9xqpeZQ4WkvZQXD0lmXu2fNVVVA1etSN3ZI9aE,8444
 prefect/runtime/task_run.py,sha256=_np3pjBHWkvEtSe-QElEAGwUct629vVx_sahPr-H8gM,3402
-prefect/server/api/collections_data/views/aggregate-worker-metadata.json,sha256=MfSqJCoUe1lEdSqFT8fy4qJAaO9jauZoE-vZ_9re0IU,77799
+prefect/server/api/collections_data/views/aggregate-worker-metadata.json,sha256=Gwv5t_RXgqI77MRk5EV0cWVXRrxZ3_wMWxypV1F2ypI,78423
 prefect/server/api/static/prefect-logo-mark-gradient.png,sha256=ylRjJkI_JHCw8VbQasNnXQHwZW-sH-IQiUGSD3aWP1E,73430
 prefect/software/__init__.py,sha256=cn7Hesmkv3unA3NynEiyB0Cj2jAzV17yfwjVsS5Ecso,106
 prefect/software/base.py,sha256=GV6a5RrLx3JaOg1RI44jZTsI_qbqNWbWF3uVO5csnHM,1464
@@ -224,7 +226,7 @@ prefect/software/python.py,sha256=reuEJFZPJ5PrDMfK3BuPpYieHNkOXJAyCAaopQcjDqE,17
 prefect/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/utilities/annotations.py,sha256=p33yhh1Zx8BZUlTtl8gKRbpwWU9FVnZ8cfYrcd5KxDI,3103
 prefect/utilities/asyncutils.py,sha256=dNVKZKLVdNOhQObPf-224l3uWyKnt1jSFpReMpWFwT4,15674
-prefect/utilities/callables.py,sha256=zev1GNU_VHjVb_r_vAzTJ4oSXfWODPPnj7yDtaPipFY,11539
+prefect/utilities/callables.py,sha256=5G2K_ZAnNoWoY7DqESKpbf4ltF5fkGRlJUvDwBGD7t0,11603
 prefect/utilities/collections.py,sha256=D_DT489rTCwyzZb021i0xp8osBkkQgSW9XLOoLBzgkg,15436
 prefect/utilities/compat.py,sha256=mNQZDnzyKaOqy-OV-DnmH_dc7CNF5nQgW_EsA4xMr7g,906
 prefect/utilities/context.py,sha256=nb_Kui1q9cYK5fLy84baoBzko5-mOToQkd1AnZhwyq8,418
@@ -253,8 +255,8 @@ prefect/workers/block.py,sha256=lvKlaWdA-DCCXDX23HHK9M5urEq4x2wmpKtU9ft3a7k,7767
 prefect/workers/process.py,sha256=Kxj_eZYh6R8t8253LYIIafiG7dodCF8RZABwd3Ng_R0,10253
 prefect/workers/server.py,sha256=WVZJxR8nTMzK0ov0BD0xw5OyQpT26AxlXbsGQ1OrxeQ,1551
 prefect/workers/utilities.py,sha256=VfPfAlGtTuDj0-Kb8WlMgAuOfgXCdrGAnKMapPSBrwc,2483
-prefect_client-2.16.4.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
-prefect_client-2.16.4.dist-info/METADATA,sha256=MBARaKE2rL8fAortKLSdgE-l952gLz1g4Q7N6-H95W0,7349
-prefect_client-2.16.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-prefect_client-2.16.4.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
-prefect_client-2.16.4.dist-info/RECORD,,
+prefect_client-2.16.5.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
+prefect_client-2.16.5.dist-info/METADATA,sha256=A58u55jaNnt77urHhD1faDHXMlL8cClM78JMOFrLwhw,7349
+prefect_client-2.16.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+prefect_client-2.16.5.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
+prefect_client-2.16.5.dist-info/RECORD,,