prefect-client 2.19.4__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

prefect/deployments/runner.py

@@ -38,32 +38,31 @@ from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Union
 from uuid import UUID
 
 import pendulum
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    PrivateAttr,
+    model_validator,
+)
 from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn, track
 from rich.table import Table
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-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._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.actions import DeploymentScheduleCreate
 from prefect.client.schemas.schedules import (
     SCHEDULE_TYPES,
     construct_schedule,
 )
 from prefect.deployments.schedules import (
     FlexibleScheduleList,
-    create_minimal_deployment_schedule,
+    create_deployment_schedule_create,
 )
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
@@ -144,8 +143,7 @@ class RunnerDeployment(BaseModel):
             available settings.
     """
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     name: str = Field(..., description="The name of the deployment.")
     flow_name: Optional[str] = Field(
@@ -161,7 +159,7 @@ class RunnerDeployment(BaseModel):
         default_factory=list,
         description="One of more tags to apply to this deployment.",
     )
-    schedules: Optional[List[MinimalDeploymentSchedule]] = Field(
+    schedules: Optional[List[DeploymentScheduleCreate]] = Field(
         default=None,
         description="The schedules that should cause this deployment to run.",
     )
@@ -184,7 +182,7 @@ class RunnerDeployment(BaseModel):
         description="The triggers that should cause this deployment to run.",
     )
     enforce_parameter_schema: bool = Field(
-        default=False,
+        default=True,
         description=(
             "Whether or not the Prefect API should enforce the parameter schema for"
             " this deployment."
@@ -232,16 +230,22 @@ class RunnerDeployment(BaseModel):
     def entrypoint_type(self) -> EntrypointType:
         return self._entrypoint_type
 
-    @validator("triggers", allow_reuse=True)
-    def validate_automation_names(cls, field_value, values):
+    @model_validator(mode="after")
+    def validate_automation_names(self):
         """Ensure that each trigger has a name for its automation if none is provided."""
-        return validate_automation_names(field_value, values)
+        trigger: Union[DeploymentTriggerTypes, TriggerTypes]
+        for i, trigger in enumerate(self.triggers, start=1):
+            if trigger.name is None:
+                trigger.name = f"{self.name}__automation_{i}"
+        return self
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def reconcile_paused(cls, values):
         return reconcile_paused_deployment(values)
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def reconcile_schedules(cls, values):
         return reconcile_schedules_runner(values)
 
@@ -301,7 +305,9 @@ class RunnerDeployment(BaseModel):
                 entrypoint=self.entrypoint,
                 storage_document_id=None,
                 infrastructure_document_id=None,
-                parameter_openapi_schema=self._parameter_openapi_schema.dict(),
+                parameter_openapi_schema=self._parameter_openapi_schema.model_dump(
+                    exclude_unset=True
+                ),
                 enforce_parameter_schema=self.enforce_parameter_schema,
             )
 
@@ -325,26 +331,25 @@ class RunnerDeployment(BaseModel):
                     f"Error while applying deployment: {str(exc)}"
                 ) from exc
 
-            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
+            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())
+            for trigger in self.triggers:
+                trigger.set_deployment_id(deployment_id)
+                await client.create_automation(trigger.as_automation())
 
             return deployment_id
 
@@ -359,7 +364,7 @@ class RunnerDeployment(BaseModel):
         timezone: Optional[str] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         schedules: Optional[FlexibleScheduleList] = None,
-    ) -> Union[List[MinimalDeploymentSchedule], FlexibleScheduleList]:
+    ) -> Union[List[DeploymentScheduleCreate], FlexibleScheduleList]:
         """
         Construct a schedule or schedules from the provided arguments.
 
@@ -417,7 +422,7 @@ class RunnerDeployment(BaseModel):
                 value = [value]
 
             return [
-                create_minimal_deployment_schedule(
+                create_deployment_schedule_create(
                     construct_schedule(
                         **{
                             schedule_type: v,
@@ -429,7 +434,7 @@ class RunnerDeployment(BaseModel):
                 for v in value
             ]
         else:
-            return [create_minimal_deployment_schedule(schedule)]
+            return [create_deployment_schedule_create(schedule)]
 
     def _set_defaults_from_flow(self, flow: "Flow"):
         self._parameter_openapi_schema = parameter_schema(flow)
@@ -458,7 +463,7 @@ class RunnerDeployment(BaseModel):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
-        enforce_parameter_schema: bool = False,
+        enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
         job_variables: Optional[Dict[str, Any]] = None,
@@ -594,7 +599,7 @@ class RunnerDeployment(BaseModel):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
-        enforce_parameter_schema: bool = False,
+        enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
         job_variables: Optional[Dict[str, Any]] = None,
@@ -692,7 +697,7 @@ class RunnerDeployment(BaseModel):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
-        enforce_parameter_schema: bool = False,
+        enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
         job_variables: Optional[Dict[str, Any]] = None,

prefect/deployments/schedules.py

@@ -1,42 +1,43 @@
-from typing import List, Optional, Sequence, Union, get_args
+from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Union, get_args
 
-from prefect.client.schemas.objects import MinimalDeploymentSchedule
-from prefect.client.schemas.schedules import SCHEDULE_TYPES
+from prefect.client.schemas.actions import DeploymentScheduleCreate
 
-try:
-    from prefect.server.schemas.schedules import SCHEDULE_TYPES as SERVER_SCHEDULE_TYPES
+if TYPE_CHECKING:
+    from prefect.client.schemas.schedules import SCHEDULE_TYPES
 
-    SERVER_SCHEDULE_TYPES = get_args(SERVER_SCHEDULE_TYPES)
-except ImportError:
-    # `prefect-client` does not have access to the server schemas.
-    SERVER_SCHEDULE_TYPES = ()
+FlexibleScheduleList = Sequence[Union[DeploymentScheduleCreate, dict, "SCHEDULE_TYPES"]]
 
-FlexibleScheduleList = Sequence[Union[MinimalDeploymentSchedule, dict, SCHEDULE_TYPES]]
 
-
-def create_minimal_deployment_schedule(
-    schedule: SCHEDULE_TYPES,
+def create_deployment_schedule_create(
+    schedule: "SCHEDULE_TYPES",
     active: Optional[bool] = True,
-) -> MinimalDeploymentSchedule:
-    return MinimalDeploymentSchedule(
+    max_active_runs: Optional[int] = None,
+    catchup: bool = False,
+) -> DeploymentScheduleCreate:
+    """Create a DeploymentScheduleCreate object from common schedule parameters."""
+    return DeploymentScheduleCreate(
         schedule=schedule,
         active=active if active is not None else True,
+        max_active_runs=max_active_runs,
+        catchup=catchup,
     )
 
 
-def normalize_to_minimal_deployment_schedules(
-    schedules: Optional[FlexibleScheduleList],
-) -> List[MinimalDeploymentSchedule]:
+def normalize_to_deployment_schedule_create(
+    schedules: Optional["FlexibleScheduleList"],
+) -> List[DeploymentScheduleCreate]:
+    from prefect.client.schemas.schedules import SCHEDULE_TYPES
+
     normalized = []
     if schedules is not None:
         for obj in schedules:
             if isinstance(obj, get_args(SCHEDULE_TYPES)):
-                normalized.append(create_minimal_deployment_schedule(obj))
+                normalized.append(create_deployment_schedule_create(obj))
             elif isinstance(obj, dict):
-                normalized.append(create_minimal_deployment_schedule(**obj))
-            elif isinstance(obj, MinimalDeploymentSchedule):
+                normalized.append(create_deployment_schedule_create(**obj))
+            elif isinstance(obj, DeploymentScheduleCreate):
                 normalized.append(obj)
-            elif isinstance(obj, SERVER_SCHEDULE_TYPES):
+            elif _is_server_schema(obj):
                 raise ValueError(
                     "Server schema schedules are not supported. Please use "
                     "the schedule objects from `prefect.client.schemas.schedules`"
@@ -44,7 +45,11 @@ def normalize_to_minimal_deployment_schedules(
             else:
                 raise ValueError(
                     "Invalid schedule provided. Must be a schedule object, a dict,"
-                    " or a MinimalDeploymentSchedule."
+                    "or a `DeploymentScheduleCreate` object"
                 )
 
     return normalized
+
+
+def _is_server_schema(obj: Any):
+    return obj.__class__.__module__.startswith("prefect.server.schemas")

prefect/deployments/steps/__init__.py

@@ -1,7 +1,6 @@
 from .core import run_step
 from .pull import (
     git_clone,
-    git_clone_project,
     set_working_directory,
     pull_from_remote_storage,
     pull_with_block,

prefect/deployments/steps/core.py

@@ -10,6 +10,7 @@ Whenever a step is run, the following actions are taken:
 - The step's function is called with the resolved inputs
 - The step's output is returned and used to resolve inputs for subsequent steps
 """
+
 import os
 import re
 import subprocess

prefect/deployments/steps/pull.py

@@ -3,16 +3,17 @@ Core set of steps for specifying a Prefect project pull step.
 """
 import os
 from pathlib import Path
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
-from prefect._internal.compatibility.deprecated import deprecated_callable
-from prefect.blocks.core import Block
 from prefect.logging.loggers import get_logger
 from prefect.runner.storage import BlockStorageAdapter, GitRepository, RemoteStorage
 from prefect.utilities.asyncutils import sync_compatible
 
 deployment_logger = get_logger("deployment")
 
+if TYPE_CHECKING:
+    from prefect.blocks.core import Block
+
 
 def set_working_directory(directory: str) -> dict:
     """
@@ -35,7 +36,7 @@ async def git_clone(
     branch: Optional[str] = None,
     include_submodules: bool = False,
     access_token: Optional[str] = None,
-    credentials: Optional[Block] = None,
+    credentials: Optional["Block"] = None,
 ) -> dict:
     """
     Clones a git repository into the current working directory.
@@ -177,6 +178,8 @@ async def pull_with_block(block_document_name: str, block_type_slug: str):
         block_document_name: The name of the block document to use
         block_type_slug: The slug of the type of block to use
     """
+    from prefect.blocks.core import Block
+
     full_slug = f"{block_type_slug}/{block_document_name}"
     try:
         block = await Block.load(full_slug)
@@ -199,20 +202,3 @@ async def pull_with_block(block_document_name: str, block_type_slug: str):
         "Pulled code using block '%s' into '%s'", full_slug, directory
     )
     return {"directory": directory}
-
-
-@deprecated_callable(start_date="Jun 2023", help="Use 'git clone' instead.")
-@sync_compatible
-async def git_clone_project(
-    repository: str,
-    branch: Optional[str] = None,
-    include_submodules: bool = False,
-    access_token: Optional[str] = None,
-) -> dict:
-    """Deprecated. Use `git_clone` instead."""
-    return await git_clone(
-        repository=repository,
-        branch=branch,
-        include_submodules=include_submodules,
-        access_token=access_token,
-    )