prefect-client 3.2.13__py3-none-any.whl → 3.2.15__py3-none-any.whl

prefect/runner/utils.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from copy import deepcopy
-from typing import Any
+from typing import Any, Hashable
 
 from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
@@ -8,7 +10,7 @@ from prefect import __version__ as PREFECT_VERSION
 
 
 def inject_schemas_into_openapi(
-    webserver: FastAPI, schemas_to_inject: dict[str, Any]
+    webserver: FastAPI, schemas_to_inject: dict[Hashable, Any]
 ) -> dict[str, Any]:
     """
     Augments the webserver's OpenAPI schema with additional schemas from deployments / flows / tasks.
@@ -29,7 +31,7 @@ def inject_schemas_into_openapi(
 
 
 def merge_definitions(
-    injected_schemas: dict[str, Any], openapi_schema: dict[str, Any]
+    injected_schemas: dict[Hashable, Any], openapi_schema: dict[str, Any]
 ) -> dict[str, Any]:
     """
     Integrates definitions from injected schemas into the OpenAPI components.
@@ -51,7 +53,9 @@ def merge_definitions(
     return openapi_schema_copy
 
 
-def update_refs_in_schema(schema_item: Any, new_ref: str) -> None:
+def update_refs_in_schema(
+    schema_item: dict[str, Any] | list[Any], new_ref: str
+) -> None:
     """
     Recursively replaces `$ref` with a new reference base in a schema item.
 
@@ -64,7 +68,7 @@ def update_refs_in_schema(schema_item: Any, new_ref: str) -> None:
             schema_item["$ref"] = schema_item["$ref"].replace("#/definitions/", new_ref)
         for value in schema_item.values():
             update_refs_in_schema(value, new_ref)
-    elif isinstance(schema_item, list):
+    elif isinstance(schema_item, list):  # pyright: ignore[reportUnnecessaryIsInstance]
         for item in schema_item:
             update_refs_in_schema(item, new_ref)
 

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

@@ -559,7 +559,7 @@
               "description": "To use any private container registry with a username and password, choose DockerRegistry. To use a private Azure Container Registry with a managed identity, choose ACRManagedIdentity.",
               "anyOf": [
                 {
-                  "$ref": "#/definitions/DockerRegistry"
+                  "$ref": "#/definitions/DockerRegistryCredentials"
                 },
                 {
                   "$ref": "#/definitions/ACRManagedIdentity"
@@ -637,8 +637,8 @@
             "subscription_id"
           ],
           "definitions": {
-            "DockerRegistry": {
-              "title": "DockerRegistry",
+            "DockerRegistryCredentials": {
+              "title": "DockerRegistryCredentials",
               "description": "Connects to a Docker registry.\n\nRequires a Docker Engine to be connectable.",
               "type": "object",
               "properties": {
@@ -671,7 +671,7 @@
                 "password",
                 "registry_url"
               ],
-              "block_type_slug": "docker-registry",
+              "block_type_slug": "docker-registry-credentials",
               "secret_fields": [
                 "password"
               ],

prefect/server/api/flow_runs.py

@@ -29,6 +29,7 @@ import prefect.server.schemas as schemas
 from prefect.logging import get_logger
 from prefect.server.api.run_history import run_history
 from prefect.server.api.validation import validate_job_variables_for_deployment_flow_run
+from prefect.server.api.workers import WorkerLookups
 from prefect.server.database import PrefectDBInterface, provide_database_interface
 from prefect.server.exceptions import FlowRunGraphTooLarge
 from prefect.server.models.flow_runs import (
@@ -68,6 +69,7 @@ async def create_flow_run(
         orchestration_dependencies.provide_flow_orchestration_parameters
     ),
     api_version: str = Depends(dependencies.provide_request_api_version),
+    worker_lookups: WorkerLookups = Depends(WorkerLookups),
 ) -> schemas.responses.FlowRunResponse:
     """
     Create a flow run. If a flow run with the same flow_id and
@@ -91,6 +93,25 @@ async def create_flow_run(
     right_now = now("UTC")
 
     async with db.session_context(begin_transaction=True) as session:
+        if flow_run.work_pool_name:
+            if flow_run.work_queue_name:
+                work_queue_id = await worker_lookups._get_work_queue_id_from_name(
+                    session=session,
+                    work_pool_name=flow_run.work_pool_name,
+                    work_queue_name=flow_run.work_queue_name,
+                )
+            else:
+                work_queue_id = (
+                    await worker_lookups._get_default_work_queue_id_from_work_pool_name(
+                        session=session,
+                        work_pool_name=flow_run.work_pool_name,
+                    )
+                )
+        else:
+            work_queue_id = None
+
+        flow_run_object.work_queue_id = work_queue_id
+
         model = await models.flow_runs.create_flow_run(
             session=session,
             flow_run=flow_run_object,

prefect/server/api/task_runs.py

@@ -16,6 +16,7 @@ from fastapi import (
     WebSocket,
     status,
 )
+from fastapi.responses import ORJSONResponse
 from starlette.websockets import WebSocketDisconnect
 
 import prefect.server.api.dependencies as dependencies
@@ -27,7 +28,10 @@ from prefect.server.database import PrefectDBInterface, provide_database_interfa
 from prefect.server.orchestration import dependencies as orchestration_dependencies
 from prefect.server.orchestration.core_policy import CoreTaskPolicy
 from prefect.server.orchestration.policies import TaskRunOrchestrationPolicy
-from prefect.server.schemas.responses import OrchestrationResult
+from prefect.server.schemas.responses import (
+    OrchestrationResult,
+    TaskRunPaginationResponse,
+)
 from prefect.server.task_queue import MultiQueue, TaskQueue
 from prefect.server.utilities import subscriptions
 from prefect.server.utilities.server import PrefectRouter
@@ -214,6 +218,53 @@ async def read_task_runs(
         )
 
 
+@router.post("/paginate", response_class=ORJSONResponse)
+async def paginate_task_runs(
+    sort: schemas.sorting.TaskRunSort = Body(schemas.sorting.TaskRunSort.ID_DESC),
+    limit: int = dependencies.LimitBody(),
+    page: int = Body(1, ge=1),
+    flows: Optional[schemas.filters.FlowFilter] = None,
+    flow_runs: Optional[schemas.filters.FlowRunFilter] = None,
+    task_runs: Optional[schemas.filters.TaskRunFilter] = None,
+    deployments: Optional[schemas.filters.DeploymentFilter] = None,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> TaskRunPaginationResponse:
+    """
+    Pagination query for task runs.
+    """
+    offset = (page - 1) * limit
+
+    async with db.session_context() as session:
+        runs = await models.task_runs.read_task_runs(
+            session=session,
+            flow_filter=flows,
+            flow_run_filter=flow_runs,
+            task_run_filter=task_runs,
+            deployment_filter=deployments,
+            offset=offset,
+            limit=limit,
+            sort=sort,
+        )
+
+        total_count = await models.task_runs.count_task_runs(
+            session=session,
+            flow_filter=flows,
+            flow_run_filter=flow_runs,
+            task_run_filter=task_runs,
+            deployment_filter=deployments,
+        )
+
+        return TaskRunPaginationResponse.model_validate(
+            dict(
+                results=runs,
+                count=total_count,
+                limit=limit,
+                pages=(total_count + limit - 1) // limit,
+                page=page,
+            )
+        )
+
+
 @router.delete("/{id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_task_run(
     task_run_id: UUID = Path(..., description="The task run id", alias="id"),

prefect/settings/models/tasks.py

@@ -57,6 +57,11 @@ class TasksSettings(PrefectBaseSettings):
         description="If `True`, enables a refresh of cached results: re-executing the task will refresh the cached results.",
     )
 
+    default_no_cache: bool = Field(
+        default=False,
+        description="If `True`, sets the default cache policy on all tasks to `NO_CACHE`.",
+    )
+
     default_retries: int = Field(
         default=0,
         ge=0,

prefect/task_engine.py

@@ -755,11 +755,14 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                 if self._telemetry.span
                 else nullcontext()
             ):
-                self.begin_run()
-                try:
-                    yield
-                finally:
-                    self.call_hooks()
+                # Acquire a concurrency slot for each tag, but only if a limit
+                # matching the tag already exists.
+                with concurrency(list(self.task_run.tags), self.task_run.id):
+                    self.begin_run()
+                    try:
+                        yield
+                    finally:
+                        self.call_hooks()
 
     @contextmanager
     def transaction_context(self) -> Generator[Transaction, None, None]:
@@ -820,13 +823,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
         if transaction.is_committed():
             result = transaction.read()
         else:
-            if self.task_run.tags:
-                # Acquire a concurrency slot for each tag, but only if a limit
-                # matching the tag already exists.
-                with concurrency(list(self.task_run.tags), self.task_run.id):
-                    result = call_with_parameters(self.task.fn, parameters)
-            else:
-                result = call_with_parameters(self.task.fn, parameters)
+            result = call_with_parameters(self.task.fn, parameters)
         self.handle_success(result, transaction=transaction)
         return result
 
@@ -1288,11 +1285,14 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                 if self._telemetry.span
                 else nullcontext()
             ):
-                await self.begin_run()
-                try:
-                    yield
-                finally:
-                    await self.call_hooks()
+                # Acquire a concurrency slot for each tag, but only if a limit
+                # matching the tag already exists.
+                async with aconcurrency(list(self.task_run.tags), self.task_run.id):
+                    await self.begin_run()
+                    try:
+                        yield
+                    finally:
+                        await self.call_hooks()
 
     @asynccontextmanager
     async def transaction_context(self) -> AsyncGenerator[Transaction, None]:
@@ -1352,13 +1352,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
         if transaction.is_committed():
             result = transaction.read()
         else:
-            if self.task_run and self.task_run.tags:
-                # Acquire a concurrency slot for each tag, but only if a limit
-                # matching the tag already exists.
-                async with aconcurrency(list(self.task_run.tags), self.task_run.id):
-                    result = await call_with_parameters(self.task.fn, parameters)
-            else:
-                result = await call_with_parameters(self.task.fn, parameters)
+            result = await call_with_parameters(self.task.fn, parameters)
         await self.handle_success(result, transaction=transaction)
         return result
 

prefect/tasks.py

@@ -1,8 +1,10 @@
 """
 Module containing the base workflow task class and decorator - for most use cases, using the [`@task` decorator][prefect.tasks.task] is preferred.
 """
+
 # This file requires type-checking with pyright because mypy does not yet support PEP612
 # See https://github.com/python/mypy/issues/8645
+from __future__ import annotations
 
 import asyncio
 import datetime
@@ -314,7 +316,7 @@ class Task(Generic[P, R]):
     #       exactly in the @task decorator
     def __init__(
         self,
-        fn: Callable[P, R],
+        fn: Callable[P, R] | "classmethod[Any, P, R]" | "staticmethod[P, R]",
         name: Optional[str] = None,
         description: Optional[str] = None,
         tags: Optional[Iterable[str]] = None,
@@ -378,6 +380,13 @@ class Task(Generic[P, R]):
                             " my_task():\n\tpass"
                         )
 
+        if isinstance(fn, classmethod):
+            fn = cast(Callable[P, R], fn.__func__)
+
+        if isinstance(fn, staticmethod):
+            fn = cast(Callable[P, R], fn.__func__)
+            setattr(fn, "__prefect_static__", True)
+
         if not callable(fn):
             raise TypeError("'fn' must be callable")
 
@@ -422,6 +431,11 @@ class Task(Generic[P, R]):
 
         self.task_key: str = _generate_task_key(self.fn)
 
+        # determine cache and result configuration
+        settings = get_current_settings()
+        if settings.tasks.default_no_cache and cache_policy is NotSet:
+            cache_policy = NO_CACHE
+
         if cache_policy is not NotSet and cache_key_fn is not None:
             logger.warning(
                 f"Both `cache_policy` and `cache_key_fn` are set on task {self}. `cache_key_fn` will be used."
@@ -458,7 +472,7 @@ class Task(Generic[P, R]):
                 )
         elif cache_policy is NotSet and result_storage_key is None:
             self.cache_policy = DEFAULT
-        elif result_storage_key:
+        elif cache_policy != NO_CACHE and result_storage_key:
             # TODO: handle this situation with double storage
             self.cache_policy = None
         else:
@@ -468,7 +482,6 @@ class Task(Generic[P, R]):
         # TODO: We can instantiate a `TaskRunPolicy` and add Pydantic bound checks to
         #       validate that the user passes positive numbers here
 
-        settings = get_current_settings()
         self.retries: int = (
             retries if retries is not None else settings.tasks.default_retries
         )
@@ -532,6 +545,14 @@ class Task(Generic[P, R]):
     def ismethod(self) -> bool:
         return hasattr(self.fn, "__prefect_self__")
 
+    @property
+    def isclassmethod(self) -> bool:
+        return hasattr(self.fn, "__prefect_cls__")
+
+    @property
+    def isstaticmethod(self) -> bool:
+        return getattr(self.fn, "__prefect_static__", False)
+
     def __get__(self, instance: Any, owner: Any) -> "Task[P, R]":
         """
         Implement the descriptor protocol so that the task can be used as an instance method.
@@ -539,10 +560,15 @@ class Task(Generic[P, R]):
         an argument. We return a copy of the task with that instance bound to the task's function.
         """
 
-        # if no instance is provided, it's being accessed on the class
-        if instance is None:
+        if self.isstaticmethod:
             return self
 
+        # wrapped function is a classmethod
+        if not instance:
+            bound_task = copy(self)
+            setattr(bound_task.fn, "__prefect_cls__", owner)
+            return bound_task
+
         # if the task is being accessed on an instance, bind the instance to the __prefect_self__ attribute
         # of the task's function. This will allow it to be automatically added to the task's parameters
         else:
@@ -1847,9 +1873,6 @@ def task(
     """
 
     if __fn:
-        if isinstance(__fn, (classmethod, staticmethod)):
-            method_decorator = type(__fn).__name__
-            raise TypeError(f"@{method_decorator} should be applied on top of @task")
         return Task(
             fn=__fn,
             name=name,

prefect/transactions.py

@@ -23,6 +23,7 @@ from prefect.exceptions import (
     MissingContextError,
     SerializationError,
 )
+from prefect.filesystems import NullFileSystem
 from prefect.logging.loggers import LoggingAdapter, get_logger, get_run_logger
 from prefect.results import (
     ResultRecord,
@@ -453,6 +454,10 @@ def transaction(
     if key and not store:
         store = get_result_store()
 
+    # Avoid inheriting a NullFileSystem for metadata_storage from a flow's result store
+    if store and isinstance(store.metadata_storage, NullFileSystem):
+        store = store.model_copy(update={"metadata_storage": None})
+
     try:
         _logger: Union[logging.Logger, LoggingAdapter] = logger or get_run_logger()
     except MissingContextError:

prefect/utilities/callables.py

@@ -63,6 +63,8 @@ def get_call_parameters(
     """
     if hasattr(fn, "__prefect_self__"):
         call_args = (getattr(fn, "__prefect_self__"), *call_args)
+    if hasattr(fn, "__prefect_cls__"):
+        call_args = (getattr(fn, "__prefect_cls__"), *call_args)
 
     try:
         bound_signature = inspect.signature(fn).bind(*call_args, **call_kwargs)

prefect/utilities/engine.py

@@ -63,7 +63,7 @@ engine_logger: Logger = get_logger("engine")
 T = TypeVar("T")
 
 
-async def collect_task_run_inputs(expr: Any, max_depth: int = -1) -> set[TaskRunInput]:
+async def collect_task_run_inputs(expr: Any, max_depth: int = -1) -> set[TaskRunResult]:
     """
     This function recurses through an expression to generate a set of any discernible
     task run inputs it finds in the data structure. It produces a set of all inputs
@@ -76,7 +76,7 @@ async def collect_task_run_inputs(expr: Any, max_depth: int = -1) -> set[TaskRun
     """
     # TODO: This function needs to be updated to detect parameters and constants
 
-    inputs: set[TaskRunInput] = set()
+    inputs: set[TaskRunResult] = set()
 
     def add_futures_and_states_to_inputs(obj: Any) -> None:
         if isinstance(obj, PrefectFuture):

prefect/utilities/importtools.py

@@ -93,8 +93,11 @@ def load_script_as_module(path: str) -> ModuleType:
     parent_path = str(Path(path).resolve().parent)
     working_directory = os.getcwd()
 
-    # Generate unique module name for thread safety
-    module_name = f"__prefect_loader_{id(path)}__"
+    module_name = os.path.splitext(Path(path).name)[0]
+
+    # fall back in case of filenames with the same names as modules
+    if module_name in sys.modules:
+        module_name = f"__prefect_loader_{id(path)}__"
 
     spec = importlib.util.spec_from_file_location(
         module_name,
@@ -112,15 +115,9 @@ def load_script_as_module(path: str) -> ModuleType:
         with _get_sys_path_lock():
             sys.path.insert(0, working_directory)
             sys.path.insert(0, parent_path)
-            try:
-                spec.loader.exec_module(module)
-            finally:
-                sys.path.remove(parent_path)
-                sys.path.remove(working_directory)
+            spec.loader.exec_module(module)
     except Exception as exc:
         raise ScriptError(user_exc=exc, path=path) from exc
-    finally:
-        sys.modules.pop(module_name)
 
     return module
 

prefect/workers/base.py

@@ -60,6 +60,7 @@ from prefect.settings import (
     get_current_settings,
 )
 from prefect.states import (
+    Cancelled,
     Crashed,
     Pending,
     exception_to_failed_state,
@@ -1249,10 +1250,14 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
     ) -> None:
         state_updates = state_updates or {}
         state_updates.setdefault("name", "Cancelled")
-        state_updates.setdefault("type", StateType.CANCELLED)
-        if TYPE_CHECKING:
-            assert flow_run.state
-        state = flow_run.state.model_copy(update=state_updates)
+
+        if flow_run.state:
+            state_updates.setdefault("type", StateType.CANCELLED)
+            state = flow_run.state.model_copy(update=state_updates)
+        else:
+            # Unexpectedly when flow run does not have a state, create a new one
+            # does not need to explicitly set the type
+            state = Cancelled(**state_updates)
 
         await self.client.set_flow_run_state(flow_run.id, state, force=True)
 

{prefect_client-3.2.13.dist-info → prefect_client-3.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.2.13
+Version: 3.2.15
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io
@@ -48,13 +48,14 @@ Requires-Dist: pydantic-settings>2.2.1
 Requires-Dist: python-dateutil<3.0.0,>=2.8.2
 Requires-Dist: python-slugify<9.0,>=5.0
 Requires-Dist: python-socks[asyncio]<3.0,>=2.5.3
+Requires-Dist: pytz<2026,>=2021.1
 Requires-Dist: pyyaml<7.0.0,>=5.4.1
 Requires-Dist: rfc3339-validator<0.2.0,>=0.1.4
 Requires-Dist: rich<14.0,>=11.0
 Requires-Dist: ruamel-yaml>=0.17.0
 Requires-Dist: sniffio<2.0.0,>=1.3.0
 Requires-Dist: toml>=0.10.0
-Requires-Dist: typing-extensions<5.0.0,>=4.5.0
+Requires-Dist: typing-extensions<5.0.0,>=4.10.0
 Requires-Dist: ujson<6.0.0,>=5.8.0
 Requires-Dist: uvicorn!=0.29.0,>=0.14.0
 Requires-Dist: websockets<16.0,>=13.0