prefect-client 2.16.7__py3-none-any.whl → 2.16.9__py3-none-any.whl

prefect/deployments/base.py

@@ -4,6 +4,7 @@ build system for managing flows and deployments.
 
 To get started, follow along with [the deloyments tutorial](/tutorials/deployments/).
 """
+
 import ast
 import asyncio
 import json
@@ -13,7 +14,7 @@ import subprocess
 import sys
 from copy import deepcopy
 from pathlib import Path
-from typing import Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 
 import anyio
 import yaml
@@ -74,7 +75,7 @@ def set_prefect_hidden_dir(path: str = None) -> bool:
 
 
 def create_default_prefect_yaml(
-    path: str, name: str = None, contents: dict = None
+    path: str, name: str = None, contents: Optional[Dict[str, Any]] = None
 ) -> bool:
     """
     Creates default `prefect.yaml` file in the provided path if one does not already exist;
@@ -221,7 +222,7 @@ def _get_git_branch() -> Optional[str]:
 
 
 def initialize_project(
-    name: str = None, recipe: str = None, inputs: dict = None
+    name: str = None, recipe: str = None, inputs: Optional[Dict[str, Any]] = None
 ) -> List[str]:
     """
     Initializes a basic project structure with base files.  If no name is provided, the name

prefect/deployments/runner.py

@@ -44,7 +44,11 @@ from rich.table import Table
 
 from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect._internal.schemas.validators import validate_automation_names
+from prefect._internal.schemas.validators import (
+    reconcile_paused_deployment,
+    reconcile_schedules_runner,
+    validate_automation_names,
+)
 from prefect.runner.storage import RunnerStorage
 from prefect.settings import (
     PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE,
@@ -67,7 +71,6 @@ from prefect.client.schemas.schedules import (
 from prefect.deployments.schedules import (
     FlexibleScheduleList,
     create_minimal_deployment_schedule,
-    normalize_to_minimal_deployment_schedules,
 )
 from prefect.events import DeploymentTriggerTypes
 from prefect.exceptions import (
@@ -236,32 +239,11 @@ class RunnerDeployment(BaseModel):
 
     @root_validator(pre=True)
     def reconcile_paused(cls, values):
-        paused = values.get("paused")
-        is_schedule_active = values.get("is_schedule_active")
-
-        if paused is not None:
-            values["paused"] = paused
-            values["is_schedule_active"] = not paused
-        elif is_schedule_active is not None:
-            values["paused"] = not is_schedule_active
-            values["is_schedule_active"] = is_schedule_active
-        else:
-            values["paused"] = False
-            values["is_schedule_active"] = True
-
-        return values
+        return reconcile_paused_deployment(values)
 
     @root_validator(pre=True)
     def reconcile_schedules(cls, values):
-        schedule = values.get("schedule")
-        schedules = values.get("schedules")
-
-        if schedules is None and schedule is not None:
-            values["schedules"] = [create_minimal_deployment_schedule(schedule)]
-        elif schedules is not None and len(schedules) > 0:
-            values["schedules"] = normalize_to_minimal_deployment_schedules(schedules)
-
-        return values
+        return reconcile_schedules_runner(values)
 
     @sync_compatible
     async def apply(

prefect/deprecated/packaging/base.py

@@ -4,7 +4,7 @@ This module is deprecated as of March 2024 and will not be available after Septe
 """
 
 import abc
-from typing import Generic, TypeVar
+from typing import Generic, Type, TypeVar
 
 from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
@@ -17,7 +17,7 @@ else:
 from prefect.flows import Flow
 from prefect.utilities.callables import ParameterSchema, parameter_schema
 from prefect.utilities.dispatch import lookup_type
-from prefect.utilities.pydantic import PartialModel, add_type_dispatch
+from prefect.utilities.pydantic import add_type_dispatch
 
 D = TypeVar("D")
 
@@ -81,10 +81,9 @@ class Packager(BaseModel, abc.ABC):
 
     type: str
 
-    def base_manifest(self, flow: Flow) -> PartialModel[PackageManifest]:
-        manifest_cls = lookup_type(PackageManifest, self.type)
-        return PartialModel(
-            manifest_cls,
+    def base_manifest(self, flow: Flow) -> PackageManifest:
+        manifest_cls: Type[BaseModel] = lookup_type(PackageManifest, self.type)
+        return manifest_cls.construct(
             type=self.type,
             flow_name=flow.name,
             flow_parameter_schema=parameter_schema(flow.fn),

prefect/deprecated/packaging/docker.py

@@ -10,6 +10,12 @@ from typing import Any, Mapping, Optional, Union
 
 from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect._internal.schemas.validators import (
+    assign_default_base_image,
+    base_image_xor_dockerfile,
+    set_default_python_environment,
+    validate_registry_url,
+)
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import AnyHttpUrl, root_validator, validator
@@ -25,7 +31,6 @@ from prefect.utilities.asyncutils import run_sync_in_worker_thread
 from prefect.utilities.dockerutils import (
     ImageBuilder,
     build_image,
-    get_prefect_image_name,
     push_image,
     to_run_command,
 )
@@ -63,7 +68,7 @@ class DockerPackager(Packager):
     registry, given by `registry_url`.
     """
 
-    type: Literal["docker"] = "docker"
+    type: str = "docker"
 
     base_image: Optional[str] = None
     python_environment: Optional[Union[PythonEnvironment, CondaEnvironment]] = None
@@ -74,36 +79,19 @@ class DockerPackager(Packager):
 
     @root_validator
     def set_default_base_image(cls, values):
-        if not values.get("base_image") and not values.get("dockerfile"):
-            values["base_image"] = get_prefect_image_name(
-                flavor=(
-                    "conda"
-                    if isinstance(values.get("python_environment"), CondaEnvironment)
-                    else None
-                )
-            )
-        return values
+        return assign_default_base_image(values)
 
     @root_validator
     def base_image_and_dockerfile_exclusive(cls, values: Mapping[str, Any]):
-        if values.get("base_image") and values.get("dockerfile"):
-            raise ValueError(
-                "Either `base_image` or `dockerfile` should be provided, but not both"
-            )
-        return values
+        return base_image_xor_dockerfile(values)
 
     @root_validator
     def default_python_environment(cls, values: Mapping[str, Any]):
-        if values.get("base_image") and not values.get("python_environment"):
-            values["python_environment"] = PythonEnvironment.from_environment()
-        return values
+        return set_default_python_environment(values)
 
     @validator("registry_url", pre=True)
     def ensure_registry_url_is_prefixed(cls, value):
-        if isinstance(value, str):
-            if "://" not in value:
-                return "https://" + value
-        return value
+        validate_registry_url(value)
 
     async def package(self, flow: Flow) -> DockerPackageManifest:
         """
@@ -117,8 +105,14 @@ class DockerPackager(Packager):
                 push_image, image_reference, self.registry_url, image_name
             )
 
-        return self.base_manifest(flow).finalize(
-            image=image_reference, image_flow_location=self.image_flow_location
+        return DockerPackageManifest(
+            **{
+                **self.base_manifest(flow).dict(),
+                **{
+                    "image": image_reference,
+                    "image_flow_location": self.image_flow_location,
+                },
+            }
         )
 
     async def _build_image(self, flow: Flow) -> str:

prefect/deprecated/packaging/file.py

@@ -34,7 +34,7 @@ class FilePackageManifest(PackageManifest):
     This class is deprecated as of version March 2024 and will not be available after September 2024.
     """
 
-    type: Literal["file"] = "file"
+    type: str = "file"
     serializer: Serializer
     key: str
     filesystem_id: UUID
@@ -80,8 +80,13 @@ class FilePackager(Packager):
             or await self.filesystem._save(is_anonymous=True)
         )
 
-        return self.base_manifest(flow).finalize(
-            serializer=self.serializer,
-            filesystem_id=filesystem_id,
-            key=key,
+        return FilePackageManifest(
+            **{
+                **self.base_manifest(flow).dict(),
+                **{
+                    "serializer": self.serializer,
+                    "filesystem_id": filesystem_id,
+                    "key": key,
+                },
+            }
         )

prefect/deprecated/packaging/orion.py

@@ -31,7 +31,7 @@ class OrionPackageManifest(PackageManifest):
     This class is deprecated as of version March 2024 and will not be available after September 2024.
     """
 
-    type: Literal["orion"] = "orion"
+    type: str = "orion"
     serializer: Serializer
     block_document_id: UUID
 
@@ -69,7 +69,12 @@ class OrionPackager(Packager):
             value={"flow": self.serializer.dumps(flow)}
         )._save(is_anonymous=True)
 
-        return self.base_manifest(flow).finalize(
-            serializer=self.serializer,
-            block_document_id=block_document_id,
+        return OrionPackageManifest(
+            **{
+                **self.base_manifest(flow).dict(),
+                **{
+                    "serializer": self.serializer,
+                    "block_document_id": block_document_id,
+                },
+            }
         )

prefect/deprecated/packaging/serializers.py

@@ -7,13 +7,17 @@ import base64
 import inspect
 import json
 import os.path
-import warnings
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import Any, List
 
 from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect._internal.schemas.validators import (
+    validate_picklelib,
+    validate_picklelib_and_modules,
+    validate_picklelib_version,
+)
 
 if HAS_PYDANTIC_V2:
     import pydantic.v1 as pydantic
@@ -55,69 +59,15 @@ class PickleSerializer(Serializer):
 
     @pydantic.validator("picklelib")
     def check_picklelib(cls, value):
-        """
-        Check that the given pickle library is importable and has dumps/loads methods.
-        """
-        try:
-            pickler = from_qualified_name(value)
-        except (ImportError, AttributeError) as exc:
-            raise ValueError(
-                f"Failed to import requested pickle library: {value!r}."
-            ) from exc
-
-        if not callable(getattr(pickler, "dumps", None)):
-            raise ValueError(
-                f"Pickle library at {value!r} does not have a 'dumps' method."
-            )
-
-        if not callable(getattr(pickler, "loads", None)):
-            raise ValueError(
-                f"Pickle library at {value!r} does not have a 'loads' method."
-            )
-
-        return value
+        return validate_picklelib(value)
 
     @pydantic.root_validator
     def check_picklelib_version(cls, values):
-        """
-        Infers a default value for `picklelib_version` if null or ensures it matches
-        the version retrieved from the `pickelib`.
-        """
-        picklelib = values.get("picklelib")
-        picklelib_version = values.get("picklelib_version")
-
-        if not picklelib:
-            raise ValueError("Unable to check version of unrecognized picklelib module")
-
-        pickler = from_qualified_name(picklelib)
-        pickler_version = getattr(pickler, "__version__", None)
-
-        if not picklelib_version:
-            values["picklelib_version"] = pickler_version
-        elif picklelib_version != pickler_version:
-            warnings.warn(
-                (
-                    f"Mismatched {picklelib!r} versions. Found {pickler_version} in the"
-                    f" environment but {picklelib_version} was requested. This may"
-                    " cause the serializer to fail."
-                ),
-                RuntimeWarning,
-                stacklevel=3,
-            )
-
-        return values
+        return validate_picklelib_version(values)
 
     @pydantic.root_validator
     def check_picklelib_and_modules(cls, values):
-        """
-        Prevents modules from being specified if picklelib is not cloudpickle
-        """
-        if values.get("picklelib") != "cloudpickle" and values.get("pickle_modules"):
-            raise ValueError(
-                "`pickle_modules` cannot be used without 'cloudpickle'. Got"
-                f" {values.get('picklelib')!r}."
-            )
-        return values
+        return validate_picklelib_and_modules(values)
 
     def dumps(self, obj: Any) -> bytes:
         pickler = from_qualified_name(self.picklelib)

prefect/engine.py

@@ -209,7 +209,6 @@ from prefect.utilities.callables import (
     parameters_to_args_kwargs,
 )
 from prefect.utilities.collections import StopVisiting, isiterable, visit_collection
-from prefect.utilities.pydantic import PartialModel
 from prefect.utilities.text import truncated_to
 
 R = TypeVar("R")
@@ -509,7 +508,7 @@ async def begin_flow_run(
     logger = flow_run_logger(flow_run, flow)
 
     log_prints = should_log_prints(flow)
-    flow_run_context = PartialModel(FlowRunContext, log_prints=log_prints)
+    flow_run_context = FlowRunContext.construct(log_prints=log_prints)
 
     async with AsyncExitStack() as stack:
         await stack.enter_async_context(
@@ -722,8 +721,7 @@ async def create_and_begin_subflow_run(
                     # interruptible as well
                     interruptible=parent_flow_run_context.timeout_scope is not None,
                     client=client,
-                    partial_flow_run_context=PartialModel(
-                        FlowRunContext,
+                    partial_flow_run_context=FlowRunContext.construct(
                         sync_portal=parent_flow_run_context.sync_portal,
                         task_runner=task_runner,
                         background_tasks=parent_flow_run_context.background_tasks,
@@ -758,7 +756,7 @@ async def orchestrate_flow_run(
     wait_for: Optional[Iterable[PrefectFuture]],
     interruptible: bool,
     client: PrefectClient,
-    partial_flow_run_context: PartialModel[FlowRunContext],
+    partial_flow_run_context: FlowRunContext,
     user_thread: threading.Thread,
 ) -> State:
     """
@@ -809,11 +807,16 @@ async def orchestrate_flow_run(
         # Update the flow run to the latest data
         flow_run = await client.read_flow_run(flow_run.id)
         try:
-            with partial_flow_run_context.finalize(
-                flow=flow,
-                flow_run=flow_run,
-                client=client,
-                parameters=parameters,
+            with FlowRunContext(
+                **{
+                    **partial_flow_run_context.dict(),
+                    **{
+                        "flow_run": flow_run,
+                        "flow": flow,
+                        "client": client,
+                        "parameters": parameters,
+                    },
+                }
             ) as flow_run_context:
                 # update flow run name
                 if not run_name_set and flow.flow_run_name:
@@ -857,7 +860,9 @@ async def orchestrate_flow_run(
                     )
                 ):
                     from_async.call_soon_in_waiting_thread(
-                        flow_call, thread=user_thread, timeout=flow.timeout_seconds
+                        flow_call,
+                        thread=user_thread,
+                        timeout=flow.timeout_seconds,
                     )
                 else:
                     from_async.call_soon_in_new_thread(
@@ -1395,12 +1400,6 @@ def enter_task_run_engine(
             client=get_client(),
         )
 
-    if TaskRunContext.get():
-        raise RuntimeError(
-            "Tasks cannot be run from within tasks. Did you mean to call this "
-            "task in a flow?"
-        )
-
     if flow_run_context.timeout_scope and flow_run_context.timeout_scope.cancel_called:
         raise TimeoutError("Flow run timed out")
 
@@ -1941,8 +1940,7 @@ async def orchestrate_task_run(
         flow_run = await client.read_flow_run(task_run.flow_run_id)
     logger = task_run_logger(task_run, task=task, flow_run=flow_run)
 
-    partial_task_run_context = PartialModel(
-        TaskRunContext,
+    partial_task_run_context = TaskRunContext.construct(
         task_run=task_run,
         task=task,
         client=client,
@@ -1982,17 +1980,20 @@ async def orchestrate_task_run(
 
     # Generate the cache key to attach to proposed states
     # The cache key uses a TaskRunContext that does not include a `timeout_context``
+
+    task_run_context = TaskRunContext(
+        **partial_task_run_context.dict(), parameters=resolved_parameters
+    )
+
     cache_key = (
         task.cache_key_fn(
-            partial_task_run_context.finalize(parameters=resolved_parameters),
+            task_run_context,
             resolved_parameters,
         )
         if task.cache_key_fn
         else None
     )
 
-    task_run_context = partial_task_run_context.finalize(parameters=resolved_parameters)
-
     # Ignore the cached results for a cache key, default = false
     # Setting on task level overrules the Prefect setting (env var)
     refresh_cache = (

prefect/events/actions.py

@@ -19,10 +19,17 @@ class Action(PrefectBaseModel):
     type: str
 
 
+class DoNothing(Action):
+    """Do nothing, which may be helpful for testing automations"""
+
+    type: Literal["do-nothing"] = "do-nothing"
+
+
 class RunDeployment(Action):
     """Run the given deployment with the given parameters"""
 
     type: Literal["run-deployment"] = "run-deployment"
+
     source: Literal["selected"] = "selected"
     parameters: Optional[Dict[str, Any]] = Field(
         None,
@@ -32,12 +39,20 @@ class RunDeployment(Action):
         ),
     )
     deployment_id: UUID = Field(..., description="The identifier of the deployment")
+    job_variables: Optional[Dict[str, Any]] = Field(
+        None,
+        description=(
+            "Job variables to pass to the run, or None to use the "
+            "deployment's default job variables"
+        ),
+    )
 
 
 class SendNotification(Action):
     """Send a notification with the given parameters"""
 
     type: Literal["send-notification"] = "send-notification"
+
     block_document_id: UUID = Field(
         ..., description="The identifier of the notification block"
     )
@@ -45,4 +60,4 @@ class SendNotification(Action):
     subject: Optional[str] = Field(None, description="Notification subject")
 
 
-ActionTypes = Union[RunDeployment, SendNotification]
+ActionTypes = Union[DoNothing, RunDeployment, SendNotification]

prefect/events/related.py

@@ -31,8 +31,8 @@ RESOURCE_CACHE: RelatedResourceCache = {}
 
 def tags_as_related_resources(tags: Iterable[str]) -> List[RelatedResource]:
     return [
-        RelatedResource(
-            __root__={
+        RelatedResource.parse_obj(
+            {
                 "prefect.resource.id": f"prefect.tag.{tag}",
                 "prefect.resource.role": "tag",
             }
@@ -44,8 +44,8 @@ def tags_as_related_resources(tags: Iterable[str]) -> List[RelatedResource]:
 def object_as_related_resource(kind: str, role: str, object: Any) -> RelatedResource:
     resource_id = f"prefect.{kind}.{object.id}"
 
-    return RelatedResource(
-        __root__={
+    return RelatedResource.parse_obj(
+        {
             "prefect.resource.id": resource_id,
             "prefect.resource.role": role,
             "prefect.resource.name": object.name,

prefect/events/schemas/automations.py

@@ -54,11 +54,11 @@ class ResourceTrigger(Trigger, abc.ABC):
     type: str
 
     match: ResourceSpecification = Field(
-        default_factory=lambda: ResourceSpecification(__root__={}),
+        default_factory=lambda: ResourceSpecification.parse_obj({}),
         description="Labels for resources which this trigger will match.",
     )
     match_related: ResourceSpecification = Field(
-        default_factory=lambda: ResourceSpecification(__root__={}),
+        default_factory=lambda: ResourceSpecification.parse_obj({}),
         description="Labels for related resources which this trigger will match.",
     )
 
@@ -294,6 +294,17 @@ class Automation(PrefectBaseModel, extra="ignore"):
         ...,
         description="The actions to perform when this Automation triggers",
     )
+
+    actions_on_trigger: List[ActionTypes] = Field(
+        default_factory=list,
+        description="The actions to perform when an Automation goes into a triggered state",
+    )
+
+    actions_on_resolve: List[ActionTypes] = Field(
+        default_factory=list,
+        description="The actions to perform when an Automation goes into a resolving state",
+    )
+
     owner_resource: Optional[str] = Field(
         default=None, description="The owning resource of this automation"
     )