prefect-client 2.16.8__py3-none-any.whl → 2.17.0__py3-none-any.whl

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(
@@ -324,9 +306,9 @@ class RunnerDeployment(BaseModel):
             )
 
             if work_pool_name:
-                create_payload["infra_overrides"] = self.job_variables
+                create_payload["job_variables"] = self.job_variables
                 if image:
-                    create_payload["infra_overrides"]["image"] = image
+                    create_payload["job_variables"]["image"] = image
                 create_payload["path"] = None if self.storage else self._path
                 create_payload["pull_steps"] = (
                     [self.storage.to_pull_step()] if self.storage else []

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)