prefect-client 3.1.12__py3-none-any.whl → 3.1.14__py3-none-any.whl

prefect/context.py

@@ -337,10 +337,15 @@ class EngineContext(RunContext):
         flow: The flow instance associated with the run
         flow_run: The API metadata for the flow run
         task_runner: The task runner instance being used for the flow run
-        task_run_futures: A list of futures for task runs submitted within this flow run
-        task_run_states: A list of states for task runs created within this flow run
         task_run_results: A mapping of result ids to task run states for this flow run
-        flow_run_states: A list of states for flow runs created within this flow run
+        log_prints: Whether to log print statements from the flow run
+        parameters: The parameters passed to the flow run
+        detached: Flag indicating if context has been serialized and sent to remote infrastructure
+        result_store: The result store used to persist results
+        persist_result: Whether to persist the flow run result
+        task_run_dynamic_keys: Counter for task calls allowing unique keys
+        observed_flow_pauses: Counter for flow pauses
+        events: Events worker to emit events
     """
 
     flow: Optional["Flow[Any, Any]"] = None
@@ -373,7 +378,7 @@ class EngineContext(RunContext):
     __var__: ClassVar[ContextVar[Self]] = ContextVar("flow_run")
 
     def serialize(self: Self, include_secrets: bool = True) -> dict[str, Any]:
-        return self.model_dump(
+        serialized = self.model_dump(
             include={
                 "flow_run",
                 "flow",
@@ -381,13 +386,18 @@ class EngineContext(RunContext):
                 "log_prints",
                 "start_time",
                 "input_keyset",
-                "result_store",
                 "persist_result",
             },
             exclude_unset=True,
-            serialize_as_any=True,
             context={"include_secrets": include_secrets},
         )
+        if self.result_store:
+            serialized["result_store"] = self.result_store.model_dump(
+                serialize_as_any=True,
+                exclude_unset=True,
+                context={"include_secrets": include_secrets},
+            )
+        return serialized
 
 
 FlowRunContext = EngineContext  # for backwards compatibility

prefect/deployments/base.py

@@ -19,6 +19,7 @@ from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.objects import ConcurrencyLimitStrategy
 from prefect.client.schemas.schedules import IntervalSchedule
 from prefect.utilities._git import get_git_branch, get_git_remote_origin_url
+from prefect.utilities.annotations import NotSet
 from prefect.utilities.filesystem import create_default_ignore_file
 from prefect.utilities.templating import apply_values
 
@@ -113,7 +114,9 @@ def create_default_prefect_yaml(
     return True
 
 
-def configure_project_by_recipe(recipe: str, **formatting_kwargs) -> dict:
+def configure_project_by_recipe(
+    recipe: str, **formatting_kwargs: Any
+) -> dict[str, Any] | type[NotSet]:
     """
     Given a recipe name, returns a dictionary representing base configuration options.
 
@@ -131,13 +134,13 @@ def configure_project_by_recipe(recipe: str, **formatting_kwargs) -> dict:
         raise ValueError(f"Unknown recipe {recipe!r} provided.")
 
     with recipe_path.open(mode="r") as f:
-        config = yaml.safe_load(f)
+        config: dict[str, Any] = yaml.safe_load(f)
 
-    config = apply_values(
+    templated_config = apply_values(
         template=config, values=formatting_kwargs, remove_notset=False
     )
 
-    return config
+    return templated_config
 
 
 def initialize_project(

prefect/deployments/flow_runs.py

@@ -29,7 +29,11 @@ prefect.client.schemas.StateCreate.model_rebuild(
     }
 )
 
-logger = get_logger(__name__)
+
+if TYPE_CHECKING:
+    import logging
+
+logger: "logging.Logger" = get_logger(__name__)
 
 
 @sync_compatible

prefect/deployments/runner.py

@@ -36,7 +36,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Iterable, List, Optional, Union
 from uuid import UUID
 
-from exceptiongroup import ExceptionGroup  # novermin
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -361,7 +360,11 @@ class RunnerDeployment(BaseModel):
 
             # We plan to support SLA configuration on the Prefect Server in the future.
             # For now, we only support it on Prefect Cloud.
-            if self._sla:
+
+            # If we're provided with an empty list, we will call the apply endpoint
+            # to remove existing SLAs for the deployment. If the argument is not provided,
+            # we will not call the endpoint.
+            if self._sla or self._sla == []:
                 await self._create_slas(deployment_id, client)
 
             return deployment_id
@@ -371,15 +374,7 @@ class RunnerDeployment(BaseModel):
             self._sla = [self._sla]
 
         if client.server_type == ServerType.CLOUD:
-            exceptions = []
-            for sla in self._sla:
-                try:
-                    sla.set_deployment_id(deployment_id)
-                    await client.create_sla(sla)
-                except Exception as e:
-                    exceptions.append(e)
-            if exceptions:
-                raise ExceptionGroup("Failed to create SLAs", exceptions)  # novermin
+            await client.apply_slas_for_deployment(deployment_id, self._sla)
         else:
             raise ValueError(
                 "SLA configuration is currently only supported on Prefect Cloud."

prefect/deployments/steps/core.py

@@ -141,7 +141,7 @@ async def run_steps(
     steps: List[Dict[str, Any]],
     upstream_outputs: Optional[Dict[str, Any]] = None,
     print_function: Any = print,
-):
+) -> dict[str, Any]:
     upstream_outputs = deepcopy(upstream_outputs) if upstream_outputs else {}
     for step in steps:
         if not step:

prefect/deployments/steps/pull.py

@@ -12,7 +12,10 @@ from prefect.logging.loggers import get_logger
 from prefect.runner.storage import BlockStorageAdapter, GitRepository, RemoteStorage
 from prefect.utilities.asyncutils import run_coro_as_sync
 
-deployment_logger = get_logger("deployment")
+if TYPE_CHECKING:
+    import logging
+
+deployment_logger: "logging.Logger" = get_logger("deployment")
 
 if TYPE_CHECKING:
     from prefect.blocks.core import Block
@@ -197,7 +200,7 @@ def git_clone(
     return dict(directory=str(storage.destination.relative_to(Path.cwd())))
 
 
-async def pull_from_remote_storage(url: str, **settings: Any):
+async def pull_from_remote_storage(url: str, **settings: Any) -> dict[str, Any]:
     """
     Pulls code from a remote storage location into the current working directory.
 
@@ -239,7 +242,9 @@ async def pull_from_remote_storage(url: str, **settings: Any):
     return {"directory": directory}
 
 
-async def pull_with_block(block_document_name: str, block_type_slug: str):
+async def pull_with_block(
+    block_document_name: str, block_type_slug: str
+) -> dict[str, Any]:
     """
     Pulls code using a block.
 

prefect/deployments/steps/utility.py

@@ -26,7 +26,7 @@ import shlex
 import string
 import subprocess
 import sys
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 from anyio import create_task_group
 from anyio.streams.text import TextReceiveStream
@@ -205,7 +205,7 @@ async def pip_install_requirements(
     directory: Optional[str] = None,
     requirements_file: str = "requirements.txt",
     stream_output: bool = True,
-):
+) -> dict[str, Any]:
     """
     Installs dependencies from a requirements.txt file.
 

prefect/docker/docker_image.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 from pendulum import now as pendulum_now
 
@@ -34,7 +34,11 @@ class DockerImage:
     """
 
     def __init__(
-        self, name: str, tag: Optional[str] = None, dockerfile="auto", **build_kwargs
+        self,
+        name: str,
+        tag: Optional[str] = None,
+        dockerfile: str = "auto",
+        **build_kwargs: Any,
     ):
         image_name, image_tag = parse_image_tag(name)
         if tag and image_tag:
@@ -49,16 +53,16 @@ class DockerImage:
             namespace = PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE.value()
         # join the namespace and repository to create the full image name
         # ignore namespace if it is None
-        self.name = "/".join(filter(None, [namespace, repository]))
-        self.tag = tag or image_tag or slugify(pendulum_now("utc").isoformat())
-        self.dockerfile = dockerfile
-        self.build_kwargs = build_kwargs
+        self.name: str = "/".join(filter(None, [namespace, repository]))
+        self.tag: str = tag or image_tag or slugify(pendulum_now("utc").isoformat())
+        self.dockerfile: str = dockerfile
+        self.build_kwargs: dict[str, Any] = build_kwargs
 
     @property
-    def reference(self):
+    def reference(self) -> str:
         return f"{self.name}:{self.tag}"
 
-    def build(self):
+    def build(self) -> None:
         full_image_name = self.reference
         build_kwargs = self.build_kwargs.copy()
         build_kwargs["context"] = Path.cwd()
@@ -72,7 +76,7 @@ class DockerImage:
             build_kwargs["dockerfile"] = self.dockerfile
             build_image(**build_kwargs)
 
-    def push(self):
+    def push(self) -> None:
         with docker_client() as client:
             events = client.api.push(
                 repository=self.name, tag=self.tag, stream=True, decode=True

prefect/engine.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 from uuid import UUID
 
 from prefect._internal.compatibility.migration import getattr_migration
@@ -15,12 +15,19 @@ from prefect.utilities.asyncutils import (
     run_coro_as_sync,
 )
 
-engine_logger = get_logger("engine")
+if TYPE_CHECKING:
+    import logging
+
+    from prefect.flow_engine import FlowRun
+    from prefect.flows import Flow
+    from prefect.logging.loggers import LoggingAdapter
+
+engine_logger: "logging.Logger" = get_logger("engine")
 
 
 if __name__ == "__main__":
     try:
-        flow_run_id = UUID(
+        flow_run_id: UUID = UUID(
             sys.argv[1] if len(sys.argv) > 1 else os.environ.get("PREFECT__FLOW_RUN_ID")
         )
     except Exception:
@@ -37,11 +44,11 @@ if __name__ == "__main__":
             run_flow,
         )
 
-        flow_run = load_flow_run(flow_run_id=flow_run_id)
-        run_logger = flow_run_logger(flow_run=flow_run)
+        flow_run: "FlowRun" = load_flow_run(flow_run_id=flow_run_id)
+        run_logger: "LoggingAdapter" = flow_run_logger(flow_run=flow_run)
 
         try:
-            flow = load_flow(flow_run)
+            flow: "Flow[..., Any]" = load_flow(flow_run)
         except Exception:
             run_logger.error(
                 "Unexpected exception encountered when trying to load flow",
@@ -55,15 +62,17 @@ if __name__ == "__main__":
         else:
             run_flow(flow, flow_run=flow_run, error_logger=run_logger)
 
-    except Abort as exc:
+    except Abort as abort_signal:
+        abort_signal: Abort
         engine_logger.info(
             f"Engine execution of flow run '{flow_run_id}' aborted by orchestrator:"
-            f" {exc}"
+            f" {abort_signal}"
         )
         exit(0)
-    except Pause as exc:
+    except Pause as pause_signal:
+        pause_signal: Pause
         engine_logger.info(
-            f"Engine execution of flow run '{flow_run_id}' is paused: {exc}"
+            f"Engine execution of flow run '{flow_run_id}' is paused: {pause_signal}"
         )
         exit(0)
     except Exception:

prefect/events/cli/automations.py

@@ -3,7 +3,7 @@ Command line interface for working with automations.
 """
 
 import functools
-from typing import Optional, Type
+from typing import Any, Callable, Optional, Type
 from uuid import UUID
 
 import orjson
@@ -21,16 +21,16 @@ from prefect.client.orchestration import get_client
 from prefect.events.schemas.automations import Automation
 from prefect.exceptions import PrefectHTTPStatusError
 
-automations_app = PrefectTyper(
+automations_app: PrefectTyper = PrefectTyper(
     name="automation",
     help="Manage automations.",
 )
 app.add_typer(automations_app, aliases=["automations"])
 
 
-def requires_automations(func):
+def requires_automations(func: Callable[..., Any]) -> Callable[..., Any]:
     @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return await func(*args, **kwargs)
         except RuntimeError as exc:

prefect/events/clients.py

@@ -70,18 +70,21 @@ EVENT_WEBSOCKET_CHECKPOINTS = Counter(
     labelnames=["client"],
 )
 
-logger = get_logger(__name__)
+if TYPE_CHECKING:
+    import logging
+
+logger: "logging.Logger" = get_logger(__name__)
 
 
-def http_to_ws(url: str):
+def http_to_ws(url: str) -> str:
     return url.replace("https://", "wss://").replace("http://", "ws://").rstrip("/")
 
 
-def events_in_socket_from_api_url(url: str):
+def events_in_socket_from_api_url(url: str) -> str:
     return http_to_ws(url) + "/events/in"
 
 
-def events_out_socket_from_api_url(url: str):
+def events_out_socket_from_api_url(url: str) -> str:
     return http_to_ws(url) + "/events/out"
 
 
@@ -250,11 +253,11 @@ class AssertingEventsClient(EventsClient):
     last: ClassVar["Optional[AssertingEventsClient]"] = None
     all: ClassVar[List["AssertingEventsClient"]] = []
 
-    args: Tuple
-    kwargs: Dict[str, Any]
-    events: List[Event]
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
+    events: list[Event]
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any):
         AssertingEventsClient.last = self
         AssertingEventsClient.all.append(self)
         self.args = args
@@ -431,13 +434,13 @@ class AssertingPassthroughEventsClient(PrefectEventsClient):
     during tests AND sends them to a Prefect server."""
 
     last: ClassVar["Optional[AssertingPassthroughEventsClient]"] = None
-    all: ClassVar[List["AssertingPassthroughEventsClient"]] = []
+    all: ClassVar[list["AssertingPassthroughEventsClient"]] = []
 
-    args: Tuple
-    kwargs: Dict[str, Any]
-    events: List[Event]
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
+    events: list[Event]
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any):
         super().__init__(*args, **kwargs)
         AssertingPassthroughEventsClient.last = self
         AssertingPassthroughEventsClient.all.append(self)
@@ -449,7 +452,7 @@ class AssertingPassthroughEventsClient(PrefectEventsClient):
         cls.last = None
         cls.all = []
 
-    def pop_events(self) -> List[Event]:
+    def pop_events(self) -> list[Event]:
         events = self.events
         self.events = []
         return events

prefect/events/filters.py

@@ -1,7 +1,6 @@
-from typing import List, Optional, Tuple, cast
+from typing import Optional
 from uuid import UUID
 
-import pendulum
 from pydantic import Field
 
 from prefect._internal.schemas.bases import PrefectBaseModel
@@ -23,7 +22,7 @@ class AutomationFilterCreated(PrefectBaseModel):
 class AutomationFilterName(PrefectBaseModel):
     """Filter by `Automation.created`."""
 
-    any_: Optional[List[str]] = Field(
+    any_: Optional[list[str]] = Field(
         default=None,
         description="Only include automations with names that match any of these strings",
     )
@@ -41,8 +40,8 @@ class AutomationFilter(PrefectBaseModel):
 class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-arg]
     """A base class for filtering event data."""
 
-    def get_filters(self) -> List["EventDataFilter"]:
-        filters: List["EventDataFilter"] = [
+    def get_filters(self) -> list["EventDataFilter"]:
+        filters: list["EventDataFilter"] = [
             filter
             for filter in [getattr(self, name) for name in self.model_fields]
             if isinstance(filter, EventDataFilter)
@@ -60,14 +59,11 @@ class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-ar
 
 class EventOccurredFilter(EventDataFilter):
     since: DateTime = Field(
-        default_factory=lambda: cast(
-            DateTime,
-            pendulum.now("UTC").start_of("day").subtract(days=180),
-        ),
+        default_factory=lambda: DateTime.now("UTC").start_of("day").subtract(days=180),
         description="Only include events after this time (inclusive)",
     )
     until: DateTime = Field(
-        default_factory=lambda: cast(DateTime, pendulum.now("UTC")),
+        default_factory=lambda: DateTime.now("UTC"),
         description="Only include events prior to this time (inclusive)",
     )
 
@@ -76,18 +72,18 @@ class EventOccurredFilter(EventDataFilter):
 
 
 class EventNameFilter(EventDataFilter):
-    prefix: Optional[List[str]] = Field(
+    prefix: Optional[list[str]] = Field(
         default=None, description="Only include events matching one of these prefixes"
     )
-    exclude_prefix: Optional[List[str]] = Field(
+    exclude_prefix: Optional[list[str]] = Field(
         default=None, description="Exclude events matching one of these prefixes"
     )
 
-    name: Optional[List[str]] = Field(
+    name: Optional[list[str]] = Field(
         default=None,
         description="Only include events matching one of these names exactly",
     )
-    exclude_name: Optional[List[str]] = Field(
+    exclude_name: Optional[list[str]] = Field(
         default=None, description="Exclude events matching one of these names exactly"
     )
 
@@ -112,20 +108,20 @@ class EventNameFilter(EventDataFilter):
 
 
 class EventResourceFilter(EventDataFilter):
-    id: Optional[List[str]] = Field(
-        None, description="Only include events for resources with these IDs"
+    id: Optional[list[str]] = Field(
+        default=None, description="Only include events for resources with these IDs"
     )
-    id_prefix: Optional[List[str]] = Field(
-        None,
+    id_prefix: Optional[list[str]] = Field(
+        default=None,
         description=(
             "Only include events for resources with IDs starting with these prefixes."
         ),
     )
     labels: Optional[ResourceSpecification] = Field(
-        None, description="Only include events for resources with these labels"
+        default=None, description="Only include events for resources with these labels"
     )
     distinct: bool = Field(
-        False,
+        default=False,
         description="Only include events for distinct resources",
     )
 
@@ -148,35 +144,39 @@ class EventResourceFilter(EventDataFilter):
 
 
 class EventRelatedFilter(EventDataFilter):
-    id: Optional[List[str]] = Field(
-        None, description="Only include events for related resources with these IDs"
+    id: Optional[list[str]] = Field(
+        default=None,
+        description="Only include events for related resources with these IDs",
     )
-    role: Optional[List[str]] = Field(
-        None, description="Only include events for related resources in these roles"
+    role: Optional[list[str]] = Field(
+        default=None,
+        description="Only include events for related resources in these roles",
     )
-    resources_in_roles: Optional[List[Tuple[str, str]]] = Field(
-        None,
+    resources_in_roles: Optional[list[tuple[str, str]]] = Field(
+        default=None,
         description=(
             "Only include events with specific related resources in specific roles"
         ),
     )
     labels: Optional[ResourceSpecification] = Field(
-        None, description="Only include events for related resources with these labels"
+        default=None,
+        description="Only include events for related resources with these labels",
     )
 
 
 class EventAnyResourceFilter(EventDataFilter):
-    id: Optional[List[str]] = Field(
-        None, description="Only include events for resources with these IDs"
+    id: Optional[list[str]] = Field(
+        default=None, description="Only include events for resources with these IDs"
     )
-    id_prefix: Optional[List[str]] = Field(
-        None,
+    id_prefix: Optional[list[str]] = Field(
+        default=None,
         description=(
             "Only include events for resources with IDs starting with these prefixes"
         ),
     )
     labels: Optional[ResourceSpecification] = Field(
-        None, description="Only include events for related resources with these labels"
+        default=None,
+        description="Only include events for related resources with these labels",
     )
 
     def includes(self, event: Event) -> bool:
@@ -202,8 +202,8 @@ class EventAnyResourceFilter(EventDataFilter):
 
 
 class EventIDFilter(EventDataFilter):
-    id: Optional[List[UUID]] = Field(
-        None, description="Only include events with one of these IDs"
+    id: Optional[list[UUID]] = Field(
+        default=None, description="Only include events with one of these IDs"
     )
 
     def includes(self, event: Event) -> bool:

prefect/events/schemas/automations.py

@@ -52,7 +52,7 @@ class Trigger(PrefectBaseModel, abc.ABC, extra="ignore"):  # type: ignore[call-a
 
     _deployment_id: Optional[UUID] = PrivateAttr(default=None)
 
-    def set_deployment_id(self, deployment_id: UUID):
+    def set_deployment_id(self, deployment_id: UUID) -> None:
         self._deployment_id = deployment_id
 
     def owner_resource(self) -> Optional[str]:
@@ -277,7 +277,7 @@ class MetricTriggerQuery(PrefectBaseModel):
     )
 
     @field_validator("range", "firing_for")
-    def enforce_minimum_range(cls, value: timedelta):
+    def enforce_minimum_range(cls, value: timedelta) -> timedelta:
         if value < timedelta(seconds=300):
             raise ValueError("The minimum range is 300 seconds (5 minutes)")
         return value
@@ -404,13 +404,17 @@ class AutomationCore(PrefectBaseModel, extra="ignore"):  # type: ignore[call-arg
     """Defines an action a user wants to take when a certain number of events
     do or don't happen to the matching resources"""
 
-    name: str = Field(..., description="The name of this automation")
-    description: str = Field("", description="A longer description of this automation")
+    name: str = Field(default=..., description="The name of this automation")
+    description: str = Field(
+        default="", description="A longer description of this automation"
+    )
 
-    enabled: bool = Field(True, description="Whether this automation will be evaluated")
+    enabled: bool = Field(
+        default=True, description="Whether this automation will be evaluated"
+    )
 
     trigger: TriggerTypes = Field(
-        ...,
+        default=...,
         description=(
             "The criteria for which events this Automation covers and how it will "
             "respond to the presence or absence of those events"
@@ -418,7 +422,7 @@ class AutomationCore(PrefectBaseModel, extra="ignore"):  # type: ignore[call-arg
     )
 
     actions: List[ActionTypes] = Field(
-        ...,
+        default=...,
         description="The actions to perform when this Automation triggers",
     )
 
@@ -438,4 +442,4 @@ class AutomationCore(PrefectBaseModel, extra="ignore"):  # type: ignore[call-arg
 
 
 class Automation(AutomationCore):
-    id: UUID = Field(..., description="The ID of this automation")
+    id: UUID = Field(default=..., description="The ID of this automation")

prefect/events/schemas/events.py

@@ -1,6 +1,7 @@
 import copy
 from collections import defaultdict
 from typing import (
+    TYPE_CHECKING,
     Any,
     ClassVar,
     Dict,
@@ -32,7 +33,10 @@ from prefect.types import DateTime
 
 from .labelling import Labelled
 
-logger = get_logger(__name__)
+if TYPE_CHECKING:
+    import logging
+
+logger: "logging.Logger" = get_logger(__name__)
 
 
 class Resource(Labelled):

prefect/events/worker.py

@@ -82,7 +82,7 @@ class EventsWorker(QueueService[Event]):
 
         await self._client.emit(event)
 
-    async def attach_related_resources_from_context(self, event: Event):
+    async def attach_related_resources_from_context(self, event: Event) -> None:
         if "prefect.resource.lineage-group" in event.resource:
             # We attach related resources to lineage events in `emit_lineage_event`,
             # instead of the worker, because not all run-related resources are

prefect/filesystems.py

@@ -281,7 +281,7 @@ class RemoteFileSystem(WritableFileSystem, WritableDeploymentStorage):
     _filesystem: fsspec.AbstractFileSystem = None
 
     @field_validator("basepath")
-    def check_basepath(cls, value):
+    def check_basepath(cls, value: str) -> str:
         return validate_basepath(value)
 
     def _resolve_path(self, path: str) -> str: