prefect-client 2.17.1__py3-none-any.whl → 2.18.1__py3-none-any.whl

prefect/client/schemas/objects.py

@@ -19,11 +19,12 @@ from prefect._internal.compatibility.deprecated import (
     DeprecatedInfraOverridesField,
 )
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect.types import NonNegativeInteger, PositiveInteger
 
 if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, HttpUrl, conint, root_validator, validator
+    from pydantic.v1 import Field, HttpUrl, root_validator, validator
 else:
-    from pydantic import Field, HttpUrl, conint, root_validator, validator
+    from pydantic import Field, HttpUrl, root_validator, validator
 
 from typing_extensions import Literal
 
@@ -1188,10 +1189,10 @@ class WorkQueue(ObjectBaseModel):
     is_paused: bool = Field(
         default=False, description="Whether or not the work queue is paused."
     )
-    concurrency_limit: Optional[conint(ge=0)] = Field(
+    concurrency_limit: Optional[NonNegativeInteger] = Field(
         default=None, description="An optional concurrency limit for the work queue."
     )
-    priority: conint(ge=1) = Field(
+    priority: PositiveInteger = Field(
         default=1,
         description=(
             "The queue's priority. Lower values are higher priority (1 is the highest)."
@@ -1351,7 +1352,7 @@ class WorkPool(ObjectBaseModel):
         default=False,
         description="Pausing the work pool stops the delivery of all work.",
     )
-    concurrency_limit: Optional[conint(ge=0)] = Field(
+    concurrency_limit: Optional[NonNegativeInteger] = Field(
         default=None, description="A concurrency limit for the work pool."
     )
     status: Optional[WorkPoolStatus] = Field(

prefect/client/schemas/schedules.py

@@ -15,11 +15,11 @@ from prefect._internal.schemas.fields import DateTimeTZ
 from prefect._internal.schemas.validators import (
     default_anchor_date,
     default_timezone,
-    interval_schedule_must_be_positive,
     validate_cron_string,
     validate_rrule_string,
     validate_rrule_timezone,
 )
+from prefect.types import PositiveDuration
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import Field, validator
@@ -64,14 +64,10 @@ class IntervalSchedule(PrefectBaseModel):
         extra = "forbid"
         exclude_none = True
 
-    interval: datetime.timedelta
+    interval: PositiveDuration
     anchor_date: DateTimeTZ = None
     timezone: Optional[str] = Field(default=None, examples=["America/New_York"])
 
-    @validator("interval")
-    def validate_interval_schedule(cls, v):
-        return interval_schedule_must_be_positive(v)
-
     @validator("anchor_date", always=True)
     def validate_anchor_date(cls, v):
         return default_anchor_date(v)

prefect/client/schemas/sorting.py

@@ -27,6 +27,15 @@ class TaskRunSort(AutoEnum):
     END_TIME_DESC = AutoEnum.auto()
 
 
+class AutomationSort(AutoEnum):
+    """Defines automation sorting options."""
+
+    CREATED_DESC = AutoEnum.auto()
+    UPDATED_DESC = AutoEnum.auto()
+    NAME_ASC = AutoEnum.auto()
+    NAME_DESC = AutoEnum.auto()
+
+
 class LogSort(AutoEnum):
     """Defines log sorting options."""
 

prefect/client/utilities.py

@@ -6,14 +6,25 @@ Utilities for working with clients.
 # circular imports for decorators such as `inject_client` which are widely used.
 
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, Tuple, cast
-
-from typing_extensions import ParamSpec
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Coroutine,
+    Optional,
+    Tuple,
+    TypeVar,
+    cast,
+)
+
+from typing_extensions import Concatenate, ParamSpec
 
 if TYPE_CHECKING:
     from prefect.client.orchestration import PrefectClient
 
 P = ParamSpec("P")
+R = TypeVar("R")
 
 
 def get_or_create_client(
@@ -52,6 +63,17 @@ def get_or_create_client(
         return get_httpx_client(), False
 
 
+def client_injector(
+    func: Callable[Concatenate["PrefectClient", P], Awaitable[R]],
+) -> Callable[P, Awaitable[R]]:
+    @wraps(func)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        client, _ = get_or_create_client()
+        return await func(client, *args, **kwargs)
+
+    return wrapper
+
+
 def inject_client(
     fn: Callable[P, Coroutine[Any, Any, Any]],
 ) -> Callable[P, Coroutine[Any, Any, Any]]:

prefect/concurrency/asyncio.py

@@ -1,10 +1,16 @@
 import asyncio
 from contextlib import asynccontextmanager
-from typing import List, Literal, Union
+from typing import List, Literal, Union, cast
 
 import httpx
 import pendulum
 
+try:
+    from pendulum import Interval
+except ImportError:
+    # pendulum < 3
+    from pendulum.period import Period as Interval  # type: ignore
+
 from prefect import get_client
 from prefect.client.schemas.responses import MinimalConcurrencyLimitResponse
 
@@ -30,10 +36,10 @@ async def concurrency(names: Union[str, List[str]], occupy: int = 1):
     try:
         yield
     finally:
-        occupancy_seconds: float = (
-            pendulum.now("UTC") - acquisition_time
-        ).total_seconds()
-        await _release_concurrency_slots(names, occupy, occupancy_seconds)
+        occupancy_period = cast(Interval, (pendulum.now("UTC") - acquisition_time))
+        await _release_concurrency_slots(
+            names, occupy, occupancy_period.total_seconds()
+        )
         _emit_concurrency_release_events(limits, occupy, emitted_events)
 
 

prefect/concurrency/events.py

@@ -12,11 +12,11 @@ def _emit_concurrency_event(
     slots: int,
     follows: Union[Event, None] = None,
 ) -> Union[Event, None]:
-    resource = {
+    resource: Dict[str, str] = {
         "prefect.resource.id": f"prefect.concurrency-limit.{primary_limit.id}",
         "prefect.resource.name": primary_limit.name,
-        "slots-acquired": slots,
-        "limit": primary_limit.limit,
+        "slots-acquired": str(slots),
+        "limit": str(primary_limit.limit),
     }
 
     related = [

prefect/concurrency/services.py

@@ -64,7 +64,7 @@ class ConcurrencySlotAcquisitionService(QueueService):
                 raise RuntimeError("Cannot put items in a stopped service instance.")
 
             logger.debug("Service %r enqueuing item %r", self, item)
-            future = concurrent.futures.Future()
+            future: concurrent.futures.Future = concurrent.futures.Future()
 
             occupy, mode = item
             self._queue.put_nowait((occupy, mode, future))

prefect/concurrency/sync.py

@@ -1,8 +1,14 @@
 from contextlib import contextmanager
-from typing import List, Union
+from typing import List, Union, cast
 
 import pendulum
 
+try:
+    from pendulum import Interval
+except ImportError:
+    # pendulum < 3
+    from pendulum.period import Period as Interval  # type: ignore
+
 from prefect._internal.concurrency.api import create_call, from_sync
 from prefect._internal.concurrency.event_loop import get_running_loop
 from prefect.client.schemas.responses import MinimalConcurrencyLimitResponse
@@ -30,11 +36,9 @@ def concurrency(names: Union[str, List[str]], occupy: int = 1):
     try:
         yield
     finally:
-        occupancy_seconds: float = (
-            pendulum.now("UTC") - acquisition_time
-        ).total_seconds()
+        occupancy_period = cast(Interval, pendulum.now("UTC") - acquisition_time)
         _call_async_function_from_sync(
-            _release_concurrency_slots, names, occupy, occupancy_seconds
+            _release_concurrency_slots, names, occupy, occupancy_period.total_seconds()
         )
         _emit_concurrency_release_events(limits, occupy, emitted_events)
 

prefect/deployments/__init__.py

@@ -1,9 +1,7 @@
 import prefect.deployments.base
 import prefect.deployments.steps
 from prefect.deployments.base import (
-    find_prefect_directory,
     initialize_project,
-    register_flow,
 )
 
 from prefect.deployments.deployments import (

prefect/deployments/base.py

@@ -1,5 +1,5 @@
 """
-Core primitives for managing Prefect projects.  Projects provide a minimally opinionated
+Core primitives for managing Prefect deployments via `prefect deploy`, providing a minimally opinionated
 build system for managing flows and deployments.
 
 To get started, follow along with [the deloyments tutorial](/tutorials/deployments/).
@@ -7,7 +7,6 @@ To get started, follow along with [the deloyments tutorial](/tutorials/deploymen
 
 import ast
 import asyncio
-import json
 import math
 import os
 import subprocess
@@ -22,50 +21,13 @@ from ruamel.yaml import YAML
 
 from prefect.client.schemas.objects import MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import IntervalSchedule
-from prefect.flows import load_flow_from_entrypoint
 from prefect.logging import get_logger
 from prefect.settings import PREFECT_DEBUG_MODE
-from prefect.utilities.asyncutils import LazySemaphore, run_sync_in_worker_thread
+from prefect.utilities.asyncutils import LazySemaphore
 from prefect.utilities.filesystem import create_default_ignore_file, get_open_file_limit
 from prefect.utilities.templating import apply_values
 
 
-def find_prefect_directory(path: Path = None) -> Optional[Path]:
-    """
-    Given a path, recurses upward looking for .prefect/ directories.
-
-    Once found, returns absolute path to the ./prefect directory, which is assumed to reside within the
-    root for the current project.
-
-    If one is never found, `None` is returned.
-    """
-    path = Path(path or ".").resolve()
-    parent = path.parent.resolve()
-    while path != parent:
-        prefect_dir = path.joinpath(".prefect")
-        if prefect_dir.is_dir():
-            return prefect_dir
-
-        path = parent.resolve()
-        parent = path.parent.resolve()
-
-
-def set_prefect_hidden_dir(path: str = None) -> bool:
-    """
-    Creates default `.prefect/` directory if one does not already exist.
-    Returns boolean specifying whether or not a directory was created.
-
-    If a path is provided, the directory will be created in that location.
-    """
-    path = Path(path or ".") / ".prefect"
-
-    # use exists so that we dont accidentally overwrite a file
-    if path.exists():
-        return False
-    path.mkdir(mode=0o0700)
-    return True
-
-
 def create_default_prefect_yaml(
     path: str, name: str = None, contents: Optional[Dict[str, Any]] = None
 ) -> bool:
@@ -270,114 +232,10 @@ def initialize_project(
         files.append(".prefectignore")
     if create_default_prefect_yaml(".", name=project_name, contents=configuration):
         files.append("prefect.yaml")
-    if set_prefect_hidden_dir():
-        files.append(".prefect/")
 
     return files
 
 
-async def register_flow(entrypoint: str, force: bool = False):
-    """
-    Register a flow with this project from an entrypoint.
-
-    Args:
-        entrypoint (str): the entrypoint to the flow to register
-        force (bool, optional): whether or not to overwrite an existing flow with the same name
-
-    Raises:
-        ValueError: if `force` is `False` and registration would overwrite an existing flow
-    """
-    try:
-        fpath, obj_name = entrypoint.rsplit(":", 1)
-    except ValueError as exc:
-        if str(exc) == "not enough values to unpack (expected 2, got 1)":
-            missing_flow_name_msg = (
-                "Your flow entrypoint must include the name of the function that is"
-                f" the entrypoint to your flow.\nTry {entrypoint}:<flow_name> as your"
-                f" entrypoint. If you meant to specify '{entrypoint}' as the deployment"
-                f" name, try `prefect deploy -n {entrypoint}`."
-            )
-            raise ValueError(missing_flow_name_msg)
-        else:
-            raise exc
-
-    flow = await run_sync_in_worker_thread(load_flow_from_entrypoint, entrypoint)
-
-    fpath = Path(fpath).absolute()
-    prefect_dir = find_prefect_directory()
-    if not prefect_dir:
-        raise FileNotFoundError(
-            "No .prefect directory could be found - run `prefect project"
-            " init` to create one."
-        )
-
-    entrypoint = f"{fpath.relative_to(prefect_dir.parent)!s}:{obj_name}"
-
-    flows_file = prefect_dir / "flows.json"
-    if flows_file.exists():
-        with flows_file.open(mode="r") as f:
-            flows = json.load(f)
-    else:
-        flows = {}
-
-    ## quality control
-    if flow.name in flows and flows[flow.name] != entrypoint:
-        if not force:
-            raise ValueError(
-                f"Conflicting entry found for flow with name {flow.name!r}.\nExisting"
-                f" entrypoint: {flows[flow.name]}\nAttempted entrypoint:"
-                f" {entrypoint}\n\nYou can try removing the existing entry for"
-                f" {flow.name!r} from your [yellow]~/.prefect/flows.json[/yellow]."
-            )
-
-    flows[flow.name] = entrypoint
-
-    with flows_file.open(mode="w") as f:
-        json.dump(flows, f, sort_keys=True, indent=2)
-
-    return flow
-
-
-def _copy_deployments_into_prefect_file():
-    """
-    Copy deployments from the `deloyment.yaml` file into the `prefect.yaml` file.
-
-    Used to migrate users from the old `prefect.yaml` + `deployment.yaml` structure
-    to a single `prefect.yaml` file.
-    """
-    prefect_file = Path("prefect.yaml")
-    deployment_file = Path("deployment.yaml")
-    if not deployment_file.exists() or not prefect_file.exists():
-        raise FileNotFoundError(
-            "Could not find `prefect.yaml` or `deployment.yaml` files."
-        )
-
-    with deployment_file.open(mode="r") as f:
-        raw_deployment_file_contents = f.read()
-        parsed_deployment_file_contents = yaml.safe_load(raw_deployment_file_contents)
-
-    deployments = parsed_deployment_file_contents.get("deployments")
-
-    with prefect_file.open(mode="a") as f:
-        # If deployment.yaml is empty, write an empty deployments list to prefect.yaml.
-        if not parsed_deployment_file_contents:
-            f.write("\n")
-            f.write(yaml.dump({"deployments": []}, sort_keys=False))
-        # If there is no 'deployments' key in deployment.yaml, assume that the
-        # entire file is a single deployment.
-        elif not deployments:
-            f.write("\n")
-            f.write(
-                yaml.dump(
-                    {"deployments": [parsed_deployment_file_contents]}, sort_keys=False
-                )
-            )
-        # Write all of deployment.yaml to prefect.yaml.
-        else:
-            f.write("\n")
-            f.write(raw_deployment_file_contents)
-
-
 def _format_deployment_for_saving_to_prefect_file(
     deployment: Dict,
 ) -> Dict:

prefect/deployments/deployments.py

@@ -16,6 +16,13 @@ import anyio
 import pendulum
 import yaml
 
+from prefect._internal.pydantic import HAS_PYDANTIC_V2
+
+if HAS_PYDANTIC_V2:
+    from pydantic.v1 import BaseModel, Field, parse_obj_as, root_validator, validator
+else:
+    from pydantic import BaseModel, Field, parse_obj_as, root_validator, validator
+
 from prefect._internal.compatibility.deprecated import (
     DeprecatedInfraOverridesField,
     deprecated_callable,
@@ -23,7 +30,6 @@ from prefect._internal.compatibility.deprecated import (
     deprecated_parameter,
     handle_deprecated_infra_overrides_parameter,
 )
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.validators import (
     handle_openapi_schema,
     infrastructure_must_have_capabilities,
@@ -32,16 +38,10 @@ from prefect._internal.schemas.validators import (
     validate_automation_names,
     validate_deprecated_schedule_fields,
 )
-from prefect.client.schemas.actions import DeploymentScheduleCreate
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel, Field, parse_obj_as, root_validator, validator
-else:
-    from pydantic import BaseModel, Field, parse_obj_as, root_validator, validator
-
 from prefect.blocks.core import Block
 from prefect.blocks.fields import SecretDict
-from prefect.client.orchestration import PrefectClient, ServerType, get_client
+from prefect.client.orchestration import PrefectClient, get_client
+from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.objects import (
     FlowRun,
     MinimalDeploymentSchedule,
@@ -53,11 +53,12 @@ from prefect.deployments.schedules import (
     FlexibleScheduleList,
 )
 from prefect.deployments.steps.core import run_steps
-from prefect.events import DeploymentTriggerTypes
+from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     BlockMissingCapabilities,
     ObjectAlreadyExists,
     ObjectNotFound,
+    PrefectHTTPStatusError,
 )
 from prefect.filesystems import LocalFileSystem
 from prefect.flows import Flow, load_flow_from_entrypoint
@@ -609,7 +610,7 @@ class Deployment(DeprecatedInfraOverridesField, BaseModel):
         description="The parameter schema of the flow, including defaults.",
     )
     timestamp: datetime = Field(default_factory=partial(pendulum.now, "UTC"))
-    triggers: List[DeploymentTriggerTypes] = Field(
+    triggers: List[Union[DeploymentTriggerTypes, TriggerTypes]] = Field(
         default_factory=list,
         description="The triggers that should cause this deployment to run.",
     )
@@ -901,15 +902,23 @@ class Deployment(DeprecatedInfraOverridesField, BaseModel):
                 enforce_parameter_schema=self.enforce_parameter_schema,
             )
 
-            if client.server_type == ServerType.CLOUD:
-                # The triggers defined in the deployment spec are, essentially,
-                # anonymous and attempting truly sync them with cloud is not
-                # feasible. Instead, we remove all automations that are owned
-                # by the deployment, meaning that they were created via this
-                # mechanism below, and then recreate them.
-                await client.delete_resource_owned_automations(
-                    f"prefect.deployment.{deployment_id}"
-                )
+            if client.server_type.supports_automations():
+                try:
+                    # The triggers defined in the deployment spec are, essentially,
+                    # anonymous and attempting truly sync them with cloud is not
+                    # feasible. Instead, we remove all automations that are owned
+                    # by the deployment, meaning that they were created via this
+                    # mechanism below, and then recreate them.
+                    await client.delete_resource_owned_automations(
+                        f"prefect.deployment.{deployment_id}"
+                    )
+                except PrefectHTTPStatusError as e:
+                    if e.response.status_code == 404:
+                        # This Prefect server does not support automations, so we can safely
+                        # ignore this 404 and move on.
+                        return deployment_id
+                    raise e
+
                 for trigger in self.triggers:
                     trigger.set_deployment_id(deployment_id)
                     await client.create_automation(trigger.as_automation())

prefect/deployments/runner.py

@@ -42,27 +42,20 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn, track
 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 (
-    reconcile_paused_deployment,
-    reconcile_schedules_runner,
-    validate_automation_names,
-)
-from prefect.runner.storage import RunnerStorage
-from prefect.settings import (
-    PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE,
-    PREFECT_DEFAULT_WORK_POOL_NAME,
-    PREFECT_UI_URL,
-)
-from prefect.utilities.collections import get_from_dict, isiterable
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import BaseModel, Field, PrivateAttr, root_validator, validator
 else:
     from pydantic import BaseModel, Field, PrivateAttr, root_validator, validator
 
-from prefect.client.orchestration import ServerType, get_client
+from prefect._internal.concurrency.api import create_call, from_async
+from prefect._internal.schemas.validators import (
+    reconcile_paused_deployment,
+    reconcile_schedules_runner,
+    validate_automation_names,
+)
+from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import (
     SCHEDULE_TYPES,
@@ -72,13 +65,20 @@ from prefect.deployments.schedules import (
     FlexibleScheduleList,
     create_minimal_deployment_schedule,
 )
-from prefect.events import DeploymentTriggerTypes
+from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     ObjectNotFound,
     PrefectHTTPStatusError,
 )
+from prefect.runner.storage import RunnerStorage
+from prefect.settings import (
+    PREFECT_DEFAULT_DOCKER_BUILD_NAMESPACE,
+    PREFECT_DEFAULT_WORK_POOL_NAME,
+    PREFECT_UI_URL,
+)
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.callables import ParameterSchema, parameter_schema
+from prefect.utilities.collections import get_from_dict, isiterable
 from prefect.utilities.dockerutils import (
     PushError,
     build_image,
@@ -179,7 +179,7 @@ class RunnerDeployment(BaseModel):
             "The path to the entrypoint for the workflow, relative to the `path`."
         ),
     )
-    triggers: List[DeploymentTriggerTypes] = Field(
+    triggers: List[Union[DeploymentTriggerTypes, TriggerTypes]] = Field(
         default_factory=list,
         description="The triggers that should cause this deployment to run.",
     )
@@ -325,15 +325,23 @@ class RunnerDeployment(BaseModel):
                     f"Error while applying deployment: {str(exc)}"
                 ) from exc
 
-            if client.server_type == ServerType.CLOUD:
-                # The triggers defined in the deployment spec are, essentially,
-                # anonymous and attempting truly sync them with cloud is not
-                # feasible. Instead, we remove all automations that are owned
-                # by the deployment, meaning that they were created via this
-                # mechanism below, and then recreate them.
-                await client.delete_resource_owned_automations(
-                    f"prefect.deployment.{deployment_id}"
-                )
+            if client.server_type.supports_automations():
+                try:
+                    # The triggers defined in the deployment spec are, essentially,
+                    # anonymous and attempting truly sync them with cloud is not
+                    # feasible. Instead, we remove all automations that are owned
+                    # by the deployment, meaning that they were created via this
+                    # mechanism below, and then recreate them.
+                    await client.delete_resource_owned_automations(
+                        f"prefect.deployment.{deployment_id}"
+                    )
+                except PrefectHTTPStatusError as e:
+                    if e.response.status_code == 404:
+                        # This Prefect server does not support automations, so we can safely
+                        # ignore this 404 and move on.
+                        return deployment_id
+                    raise e
+
                 for trigger in self.triggers:
                     trigger.set_deployment_id(deployment_id)
                     await client.create_automation(trigger.as_automation())
@@ -446,7 +454,7 @@ class RunnerDeployment(BaseModel):
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
@@ -582,7 +590,7 @@ class RunnerDeployment(BaseModel):
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
@@ -680,7 +688,7 @@ class RunnerDeployment(BaseModel):
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,

prefect/deployments/steps/core.py

@@ -1,11 +1,11 @@
 """
-Core primitives for running Prefect project steps.
+Core primitives for running Prefect deployment steps.
 
-Project steps are YAML representations of Python functions along with their inputs.
+Deployment steps are YAML representations of Python functions along with their inputs.
 
 Whenever a step is run, the following actions are taken:
 
-- The step's inputs and block / variable references are resolved (see [the projects concepts documentation](/concepts/projects/#templating-options) for more details)
+- The step's inputs and block / variable references are resolved (see [the `prefect deploy` documentation](/guides/prefect-deploy/#templating-options) for more details)
 - The step's function is imported; if it cannot be found, the `requires` keyword is used to install the necessary packages
 - The step's function is called with the resolved inputs
 - The step's output is returned and used to resolve inputs for subsequent steps

prefect/deprecated/packaging/serializers.py

@@ -55,20 +55,21 @@ class PickleSerializer(Serializer):
 
     picklelib: str = "cloudpickle"
     picklelib_version: str = None
+
     pickle_modules: List[str] = pydantic.Field(default_factory=list)
 
     @pydantic.validator("picklelib")
     def check_picklelib(cls, value):
         return validate_picklelib(value)
 
-    @pydantic.root_validator
-    def check_picklelib_version(cls, values):
-        return validate_picklelib_version(values)
-
     @pydantic.root_validator
     def check_picklelib_and_modules(cls, values):
         return validate_picklelib_and_modules(values)
 
+    @pydantic.root_validator
+    def check_picklelib_version(cls, values):
+        return validate_picklelib_version(values)
+
     def dumps(self, obj: Any) -> bytes:
         pickler = from_qualified_name(self.picklelib)