prefect-client 3.4.1.dev4__py3-none-any.whl → 3.4.2__py3-none-any.whl

prefect/events/filters.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 import datetime
-from typing import Optional
+from typing import Optional, Union
 from uuid import UUID
 
 from pydantic import Field
@@ -43,11 +45,21 @@ class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-ar
     """A base class for filtering event data."""
 
     def get_filters(self) -> list["EventDataFilter"]:
-        filters: list["EventDataFilter"] = [
-            filter
-            for filter in [getattr(self, name) for name in type(self).model_fields]
-            if isinstance(filter, EventDataFilter)
-        ]
+        filters: list[EventDataFilter] = []
+        for filter in [
+            getattr(self, name) for name in self.__class__.model_fields.keys()
+        ]:
+            # Any embedded list of filters are flattened and thus ANDed together
+            subfilters: list[EventDataFilter] = (
+                filter if isinstance(filter, list) else [filter]
+            )
+
+            for subfilter in subfilters:
+                if not isinstance(subfilter, EventDataFilter):
+                    continue
+
+                filters.append(subfilter)
+
         return filters
 
     def includes(self, event: Event) -> bool:
@@ -233,18 +245,20 @@ class EventFilter(EventDataFilter):
         default=None,
         description="Filter criteria for the event name",
     )
-    any_resource: Optional[EventAnyResourceFilter] = Field(
-        default=None,
-        description="Filter criteria for any resource involved in the event",
-    )
     resource: Optional[EventResourceFilter] = Field(
         default=None,
         description="Filter criteria for the resource of the event",
     )
-    related: Optional[EventRelatedFilter] = Field(
+    related: Optional[Union[EventRelatedFilter, list[EventRelatedFilter]]] = Field(
         default=None,
         description="Filter criteria for the related resources of the event",
     )
+    any_resource: Optional[
+        Union[EventAnyResourceFilter, list[EventAnyResourceFilter]]
+    ] = Field(
+        default=None,
+        description="Filter criteria for any resource involved in the event",
+    )
     id: EventIDFilter = Field(
         default_factory=lambda: EventIDFilter(id=[]),
         description="Filter criteria for the events' ID",

prefect/events/schemas/automations.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import textwrap
 from datetime import timedelta
@@ -103,7 +105,7 @@ class ResourceTrigger(Trigger, abc.ABC):
         default_factory=lambda: ResourceSpecification.model_validate({}),
         description="Labels for resources which this trigger will match.",
     )
-    match_related: ResourceSpecification = Field(
+    match_related: Union[ResourceSpecification, list[ResourceSpecification]] = Field(
         default_factory=lambda: ResourceSpecification.model_validate({}),
         description="Labels for related resources which this trigger will match.",
     )

prefect/events/schemas/events.py

@@ -13,7 +13,7 @@ from typing import (
     Tuple,
     Union,
 )
-from uuid import UUID, uuid4
+from uuid import UUID
 
 from pydantic import (
     AfterValidator,
@@ -26,6 +26,7 @@ from typing_extensions import Annotated, Self
 
 import prefect.types._datetime
 from prefect._internal.schemas.bases import PrefectBaseModel
+from prefect._internal.uuid7 import uuid7
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE,
@@ -135,7 +136,7 @@ class Event(PrefectBaseModel):
         description="An open-ended set of data describing what happened",
     )
     id: UUID = Field(
-        default_factory=uuid4,
+        default_factory=uuid7,
         description="The client-provided identifier of this event",
     )
     follows: Optional[UUID] = Field(

prefect/flows.py

@@ -404,7 +404,7 @@ class Flow(Generic[P, R]):
             module_name = inspect.getfile(fn)
             module = module_name if module_name != "__main__" else module
 
-        self._entrypoint = f"{module}:{fn.__name__}"
+        self._entrypoint = f"{module}:{getattr(fn, '__qualname__', fn.__name__)}"
 
     @property
     def ismethod(self) -> bool:

prefect/results.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 import asyncio
-import inspect
 import os
 import socket
 import threading
 import uuid
+from datetime import datetime
 from functools import partial
 from operator import methodcaller
 from pathlib import Path
@@ -34,6 +34,8 @@ from typing_extensions import ParamSpec, Self
 import prefect
 import prefect.types._datetime
 from prefect._internal.compatibility.async_dispatch import async_dispatch
+from prefect._internal.compatibility.blocks import call_explicitly_async_block_method
+from prefect._internal.compatibility.deprecated import deprecated_callable
 from prefect._internal.concurrency.event_loop import get_running_loop
 from prefect._result_records import R, ResultRecord, ResultRecordMetadata
 from prefect.blocks.core import Block
@@ -285,29 +287,6 @@ def _format_user_supplied_storage_key(key: str) -> str:
     return key.format(**runtime_vars, parameters=prefect.runtime.task_run.parameters)
 
 
-async def _call_explicitly_async_block_method(
-    block: WritableFileSystem | NullFileSystem,
-    method: str,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> Any:
-    """
-    TODO: remove this once we have explicit async methods on all storage blocks
-
-    see https://github.com/PrefectHQ/prefect/issues/15008
-    """
-    if hasattr(block, f"a{method}"):  # explicit async method
-        return await getattr(block, f"a{method}")(*args, **kwargs)
-    elif hasattr(getattr(block, method, None), "aio"):  # sync_compatible
-        return await getattr(block, method).aio(block, *args, **kwargs)
-    else:  # should not happen in prefect, but users can override impls
-        maybe_coro = getattr(block, method)(*args, **kwargs)
-        if inspect.isawaitable(maybe_coro):
-            return await maybe_coro
-        else:
-            return maybe_coro
-
-
 T = TypeVar("T")
 
 
@@ -505,7 +484,7 @@ class ResultStore(BaseModel):
             # TODO: Add an `exists` method to commonly used storage blocks
             # so the entire payload doesn't need to be read
             try:
-                metadata_content = await _call_explicitly_async_block_method(
+                metadata_content = await call_explicitly_async_block_method(
                     self.metadata_storage, "read_path", (key,), {}
                 )
                 if metadata_content is None:
@@ -516,7 +495,7 @@ class ResultStore(BaseModel):
                 return False
         else:
             try:
-                content = await _call_explicitly_async_block_method(
+                content = await call_explicitly_async_block_method(
                     self.result_storage, "read_path", (key,), {}
                 )
                 if content is None:
@@ -601,7 +580,7 @@ class ResultStore(BaseModel):
             self.result_storage = await aget_default_result_storage()
 
         if self.metadata_storage is not None:
-            metadata_content = await _call_explicitly_async_block_method(
+            metadata_content = await call_explicitly_async_block_method(
                 self.metadata_storage,
                 "read_path",
                 (key,),
@@ -611,7 +590,7 @@ class ResultStore(BaseModel):
             assert metadata.storage_key is not None, (
                 "Did not find storage key in metadata"
             )
-            result_content = await _call_explicitly_async_block_method(
+            result_content = await call_explicitly_async_block_method(
                 self.result_storage,
                 "read_path",
                 (metadata.storage_key,),
@@ -624,7 +603,7 @@ class ResultStore(BaseModel):
             )
             await emit_result_read_event(self, resolved_key_path)
         else:
-            content = await _call_explicitly_async_block_method(
+            content = await call_explicitly_async_block_method(
                 self.result_storage,
                 "read_path",
                 (key,),
@@ -806,13 +785,13 @@ class ResultStore(BaseModel):
 
         # If metadata storage is configured, write result and metadata separately
         if self.metadata_storage is not None:
-            await _call_explicitly_async_block_method(
+            await call_explicitly_async_block_method(
                 self.result_storage,
                 "write_path",
                 (result_record.metadata.storage_key,),
                 {"content": result_record.serialize_result()},
             )
-            await _call_explicitly_async_block_method(
+            await call_explicitly_async_block_method(
                 self.metadata_storage,
                 "write_path",
                 (base_key,),
@@ -821,7 +800,7 @@ class ResultStore(BaseModel):
             await emit_result_write_event(self, result_record.metadata.storage_key)
         # Otherwise, write the result metadata and result together
         else:
-            await _call_explicitly_async_block_method(
+            await call_explicitly_async_block_method(
                 self.result_storage,
                 "write_path",
                 (result_record.metadata.storage_key,),
@@ -998,6 +977,11 @@ class ResultStore(BaseModel):
 
     # TODO: These two methods need to find a new home
 
+    @deprecated_callable(
+        start_date=datetime(2025, 5, 10),
+        end_date=datetime(2025, 11, 10),
+        help="Use `store_parameters` from `prefect.task_worker` instead.",
+    )
     @sync_compatible
     async def store_parameters(self, identifier: UUID, parameters: dict[str, Any]):
         record = ResultRecord(
@@ -1007,21 +991,26 @@ class ResultStore(BaseModel):
             ),
         )
 
-        await _call_explicitly_async_block_method(
+        await call_explicitly_async_block_method(
             self.result_storage,
             "write_path",
             (f"parameters/{identifier}",),
             {"content": record.serialize()},
         )
 
+    @deprecated_callable(
+        start_date=datetime(2025, 5, 10),
+        end_date=datetime(2025, 11, 10),
+        help="Use `read_parameters` from `prefect.task_worker` instead.",
+    )
     @sync_compatible
     async def read_parameters(self, identifier: UUID) -> dict[str, Any]:
         if self.result_storage is None:
             raise ValueError(
                 "Result store is not configured - must have a result storage block to read parameters"
             )
-        record: ResultRecord[Any] = ResultRecord.deserialize(
-            await _call_explicitly_async_block_method(
+        record: ResultRecord[Any] = ResultRecord[Any].deserialize(
+            await call_explicitly_async_block_method(
                 self.result_storage,
                 "read_path",
                 (f"parameters/{identifier}",),

prefect/runner/runner.py

@@ -968,16 +968,9 @@ class Runner:
 
         pid = process_map_entry.get("pid") if process_map_entry else None
         if not pid:
-            if flow_run.state:
-                await self._run_on_cancellation_hooks(flow_run, flow_run.state)
-            await self._mark_flow_run_as_cancelled(
-                flow_run,
-                state_updates={
-                    "message": (
-                        "Could not find process ID for flow run"
-                        " and cancellation cannot be guaranteed."
-                    )
-                },
+            self._logger.debug(
+                "Received cancellation request for flow run %s but no process was found.",
+                flow_run.id,
             )
             return
 

prefect/serializers.py

@@ -12,6 +12,7 @@ bytes to an object respectively.
 """
 
 import base64
+import io
 from typing import Any, ClassVar, Generic, Optional, Union, overload
 
 from pydantic import (
@@ -46,6 +47,14 @@ def prefect_json_object_encoder(obj: Any) -> Any:
     """
     if isinstance(obj, BaseException):
         return {"__exc_type__": to_qualified_name(obj.__class__), "message": str(obj)}
+    elif isinstance(obj, io.IOBase):
+        return {
+            "__class__": to_qualified_name(obj.__class__),
+            "data": (
+                f"<Prefect IOStream Placeholder: type={obj.__class__.__name__}, "
+                f"repr={repr(obj)} (original content not read)>"
+            ),
+        }
     else:
         return {
             "__class__": to_qualified_name(obj.__class__),

prefect/server/api/workers.py

@@ -3,7 +3,7 @@ Routes for interacting with work queue objects.
 """
 
 from typing import TYPE_CHECKING, List, Optional
-from uuid import UUID, uuid4
+from uuid import UUID
 
 import sqlalchemy as sa
 from fastapi import (
@@ -20,6 +20,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 import prefect.server.api.dependencies as dependencies
 import prefect.server.models as models
 import prefect.server.schemas as schemas
+from prefect._internal.uuid7 import uuid7
 from prefect.server.api.validation import validate_job_variable_defaults_for_work_pool
 from prefect.server.database import PrefectDBInterface, provide_database_interface
 from prefect.server.models.deployments import mark_deployments_ready
@@ -184,7 +185,7 @@ async def create_work_pool(
             )
 
             await emit_work_pool_status_event(
-                event_id=uuid4(),
+                event_id=uuid7(),
                 occurred=now("UTC"),
                 pre_update_work_pool=None,
                 work_pool=model,

prefect/settings/models/tasks.py

@@ -1,9 +1,10 @@
-from typing import ClassVar, Optional, Union
+from typing import ClassVar, Optional
 
 from pydantic import AliasChoices, AliasPath, Field
 from pydantic_settings import SettingsConfigDict
 
 from prefect.settings.base import PrefectBaseSettings, build_settings_config
+from prefect.types import TaskRetryDelaySeconds
 
 
 class TasksRunnerSettings(PrefectBaseSettings):
@@ -73,7 +74,7 @@ class TasksSettings(PrefectBaseSettings):
         ),
     )
 
-    default_retry_delay_seconds: Union[int, float, list[float]] = Field(
+    default_retry_delay_seconds: TaskRetryDelaySeconds = Field(
         default=0,
         description="This value sets the default retry delay seconds for all tasks.",
         validation_alias=AliasChoices(

prefect/task_runners.py

@@ -21,6 +21,7 @@ from typing import (
 
 from typing_extensions import ParamSpec, Self, TypeVar
 
+from prefect._internal.uuid7 import uuid7
 from prefect.client.schemas.objects import TaskRunInput
 from prefect.exceptions import MappingLengthMismatch, MappingMissingIterable
 from prefect.futures import (
@@ -290,7 +291,7 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[R]]):
         from prefect.context import FlowRunContext
         from prefect.task_engine import run_task_async, run_task_sync
 
-        task_run_id = uuid.uuid4()
+        task_run_id = uuid7()
         cancel_event = threading.Event()
         self._cancel_events[task_run_id] = cancel_event
         context = copy_context()

prefect/task_worker.py

@@ -22,17 +22,20 @@ from websockets.exceptions import InvalidStatus
 
 import prefect.types._datetime
 from prefect import Task
+from prefect._internal.compatibility.blocks import call_explicitly_async_block_method
 from prefect._internal.concurrency.api import create_call, from_sync
 from prefect.cache_policies import DEFAULT, NO_CACHE
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import TaskRun
 from prefect.client.subscriptions import Subscription
 from prefect.logging.loggers import get_logger
-from prefect.results import ResultStore, get_or_create_default_task_scheduling_storage
-from prefect.settings import (
-    PREFECT_API_URL,
-    PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS,
+from prefect.results import (
+    ResultRecord,
+    ResultRecordMetadata,
+    ResultStore,
+    get_or_create_default_task_scheduling_storage,
 )
+from prefect.settings import get_current_settings
 from prefect.states import Pending
 from prefect.task_engine import run_task_async, run_task_sync
 from prefect.types import DateTime
@@ -43,6 +46,7 @@ from prefect.utilities.processutils import (
     _register_signal,  # pyright: ignore[reportPrivateUsage]
 )
 from prefect.utilities.services import start_client_metrics_server
+from prefect.utilities.timeout import timeout_async
 from prefect.utilities.urls import url_for
 
 if TYPE_CHECKING:
@@ -170,9 +174,13 @@ class TaskWorker:
         sys.exit(0)
 
     @sync_compatible
-    async def start(self) -> None:
+    async def start(self, timeout: Optional[float] = None) -> None:
         """
         Starts a task worker, which runs the tasks provided in the constructor.
+
+        Args:
+            timeout: If provided, the task worker will exit after the given number of
+                seconds. Defaults to None, meaning the task worker will run indefinitely.
         """
         _register_signal(signal.SIGTERM, self.handle_sigterm)
 
@@ -181,14 +189,16 @@ class TaskWorker:
         async with asyncnullcontext() if self.started else self:
             logger.info("Starting task worker...")
             try:
-                await self._subscribe_to_task_scheduling()
+                with timeout_async(timeout):
+                    await self._subscribe_to_task_scheduling()
             except InvalidStatus as exc:
                 if exc.response.status_code == 403:
                     logger.error(
                         "403: Could not establish a connection to the `/task_runs/subscriptions/scheduled`"
-                        f" endpoint found at:\n\n {PREFECT_API_URL.value()}"
-                        "\n\nPlease double-check the values of your"
-                        " `PREFECT_API_URL` and `PREFECT_API_KEY` environment variables."
+                        f" endpoint found at:\n\n {get_current_settings().api.url}"
+                        "\n\nPlease double-check the values of"
+                        " `PREFECT_API_AUTH_STRING` and `PREFECT_SERVER_API_AUTH_STRING` if running a Prefect server "
+                        "or `PREFECT_API_URL` and `PREFECT_API_KEY` environment variables if using Prefect Cloud."
                     )
                 else:
                     raise
@@ -228,7 +238,7 @@ class TaskWorker:
         return True
 
     async def _subscribe_to_task_scheduling(self):
-        base_url = PREFECT_API_URL.value()
+        base_url = get_current_settings().api.url
         if base_url is None:
             raise ValueError(
                 "`PREFECT_API_URL` must be set to use the task worker. "
@@ -282,7 +292,7 @@ class TaskWorker:
         task = next((t for t in self.tasks if t.task_key == task_run.task_key), None)
 
         if not task:
-            if PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS:
+            if get_current_settings().tasks.scheduling.delete_failed_submissions:
                 logger.warning(
                     f"Task {task_run.name!r} not found in task worker registry."
                 )
@@ -298,12 +308,18 @@ class TaskWorker:
         run_context = None
         if should_try_to_read_parameters(task, task_run):
             parameters_id = task_run.state.state_details.task_parameters_id
+            if parameters_id is None:
+                logger.warning(
+                    f"Task run {task_run.id!r} has no parameters ID. Skipping parameter retrieval."
+                )
+                return
+
             task.persist_result = True
             store = await ResultStore(
                 result_storage=await get_or_create_default_task_scheduling_storage()
             ).update_for_task(task)
             try:
-                run_data: dict[str, Any] = await store.read_parameters(parameters_id)
+                run_data: dict[str, Any] = await read_parameters(store, parameters_id)
                 parameters = run_data.get("parameters", {})
                 wait_for = run_data.get("wait_for", [])
                 run_context = run_data.get("context", None)
@@ -312,7 +328,7 @@ class TaskWorker:
                     f"Failed to read parameters for task run {task_run.id!r}",
                     exc_info=exc,
                 )
-                if PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS.value():
+                if get_current_settings().tasks.scheduling.delete_failed_submissions:
                     logger.info(
                         f"Deleting task run {task_run.id!r} because it failed to submit"
                     )
@@ -421,6 +437,7 @@ async def serve(
     *tasks: Task[P, R],
     limit: Optional[int] = 10,
     status_server_port: Optional[int] = None,
+    timeout: Optional[float] = None,
 ):
     """Serve the provided tasks so that their runs may be submitted to
     and executed in the engine. Tasks do not need to be within a flow run context to be
@@ -434,6 +451,8 @@ async def serve(
         - status_server_port: An optional port on which to start an HTTP server
             exposing status information about the task worker. If not provided, no
             status server will run.
+        - timeout: If provided, the task worker will exit after the given number of
+            seconds. Defaults to None, meaning the task worker will run indefinitely.
 
     Example:
         ```python
@@ -469,7 +488,13 @@ async def serve(
         status_server_task = loop.create_task(server.serve())
 
     try:
-        await task_worker.start()
+        await task_worker.start(timeout=timeout)
+
+    except TimeoutError:
+        if timeout is not None:
+            logger.info(f"Task worker timed out after {timeout} seconds. Exiting...")
+        else:
+            raise
 
     except BaseExceptionGroup as exc:  # novermin
         exceptions = exc.exceptions
@@ -492,3 +517,59 @@ async def serve(
                 await status_server_task
             except asyncio.CancelledError:
                 pass
+
+
+async def store_parameters(
+    result_store: ResultStore, identifier: UUID, parameters: dict[str, Any]
+) -> None:
+    """Store parameters for a task run in the result store.
+
+    Args:
+        result_store: The result store to store the parameters in.
+        identifier: The identifier of the task run.
+        parameters: The parameters to store.
+    """
+    if result_store.result_storage is None:
+        raise ValueError(
+            "Result store is not configured - must have a result storage block to store parameters"
+        )
+    record = ResultRecord(
+        result=parameters,
+        metadata=ResultRecordMetadata(
+            serializer=result_store.serializer, storage_key=str(identifier)
+        ),
+    )
+
+    await call_explicitly_async_block_method(
+        result_store.result_storage,
+        "write_path",
+        (f"parameters/{identifier}",),
+        {"content": record.serialize()},
+    )
+
+
+async def read_parameters(
+    result_store: ResultStore, identifier: UUID
+) -> dict[str, Any]:
+    """Read parameters for a task run from the result store.
+
+    Args:
+        result_store: The result store to read the parameters from.
+        identifier: The identifier of the task run.
+
+    Returns:
+        The parameters for the task run.
+    """
+    if result_store.result_storage is None:
+        raise ValueError(
+            "Result store is not configured - must have a result storage block to read parameters"
+        )
+    record: ResultRecord[Any] = ResultRecord[Any].deserialize(
+        await call_explicitly_async_block_method(
+            result_store.result_storage,
+            "read_path",
+            (f"parameters/{identifier}",),
+            {},
+        )
+    )
+    return record.result

prefect/tasks.py

@@ -32,6 +32,7 @@ from uuid import UUID, uuid4
 from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypeIs
 
 import prefect.states
+from prefect._internal.uuid7 import uuid7
 from prefect.cache_policies import DEFAULT, NO_CACHE, CachePolicy
 from prefect.client.orchestration import get_client
 from prefect.client.schemas import TaskRun
@@ -809,6 +810,8 @@ class Task(Generic[P, R]):
             # store parameters for background tasks so that task worker
             # can retrieve them at runtime
             if deferred and (parameters or wait_for):
+                from prefect.task_worker import store_parameters
+
                 parameters_id = uuid4()
                 state.state_details.task_parameters_id = parameters_id
 
@@ -824,7 +827,7 @@ class Task(Generic[P, R]):
                     data["parameters"] = parameters
                 if wait_for:
                     data["wait_for"] = wait_for
-                await store.store_parameters(parameters_id, data)
+                await store_parameters(store, parameters_id, data)
 
             # collect task inputs
             task_inputs = {
@@ -910,6 +913,8 @@ class Task(Generic[P, R]):
             # store parameters for background tasks so that task worker
             # can retrieve them at runtime
             if deferred and (parameters or wait_for):
+                from prefect.task_worker import store_parameters
+
                 parameters_id = uuid4()
                 state.state_details.task_parameters_id = parameters_id
 
@@ -925,7 +930,7 @@ class Task(Generic[P, R]):
                     data["parameters"] = parameters
                 if wait_for:
                     data["wait_for"] = wait_for
-                await store.store_parameters(parameters_id, data)
+                await store_parameters(store, parameters_id, data)
 
             # collect task inputs
             task_inputs = {
@@ -953,7 +958,7 @@ class Task(Generic[P, R]):
                 if flow_run_context and flow_run_context.flow_run
                 else None
             )
-            task_run_id = id or uuid4()
+            task_run_id = id or uuid7()
             state = prefect.states.Pending(
                 state_details=StateDetails(
                     task_run_id=task_run_id,