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

prefect/__init__.py

@@ -106,24 +106,6 @@ from prefect._internal.compatibility.deprecated import (
     register_renamed_module,
 )
 
-register_renamed_module(
-    "prefect.client.orchestration",
-    "prefect.client.orchestration",
-    start_date="Feb 2023",
-)
-register_renamed_module(
-    "prefect.docker",
-    "prefect.utilities.dockerutils",
-    start_date="Mar 2023",
-)
-register_renamed_module(
-    "prefect.infrastructure.docker",
-    "prefect.infrastructure.container",
-    start_date="Mar 2023",
-)
-register_renamed_module(
-    "prefect.projects", "prefect.deployments", start_date="Jun 2023"
-)
 register_renamed_module(
     "prefect.packaging", "prefect.deprecated.packaging", start_date="Mar 2024"
 )

prefect/_internal/compatibility/deprecated.py

@@ -12,16 +12,18 @@ e.g. Jan 2023.
 import functools
 import sys
 import warnings
-from typing import Any, Callable, List, Optional, Type, TypeVar
+from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union
 
 import pendulum
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
+    from pydantic.v1 import BaseModel, Field, root_validator
+    from pydantic.v1.schema import default_ref_template
 else:
-    import pydantic
+    from pydantic import BaseModel, Field, root_validator
+    from pydantic.schema import default_ref_template
 
 from prefect.utilities.callables import get_call_parameters
 from prefect.utilities.importtools import (
@@ -31,7 +33,7 @@ from prefect.utilities.importtools import (
 )
 
 T = TypeVar("T", bound=Callable)
-M = TypeVar("M", bound=pydantic.BaseModel)
+M = TypeVar("M", bound=BaseModel)
 
 
 DEPRECATED_WARNING = (
@@ -207,7 +209,7 @@ def deprecated_field(
         ```python
 
         @deprecated_field("x", when=lambda x: x is not None)
-        class Model(pydantic.BaseModel)
+        class Model(BaseModel)
             x: Optional[int] = None
             y: str
         ```
@@ -276,3 +278,104 @@ def register_renamed_module(old_name: str, new_name: str, start_date: str):
     DEPRECATED_MODULE_ALIASES.append(
         AliasedModuleDefinition(old_name, new_name, callback)
     )
+
+
+class DeprecatedInfraOverridesField(BaseModel):
+    """
+    A model mixin that handles the deprecated `infra_overrides` field.
+
+    The `infra_overrides` field has been renamed to `job_variables`. This mixin maintains
+    backwards compatibility with users of the `infra_overrides` field while presenting
+    `job_variables` as the user-facing field.
+
+    When we remove support for `infra_overrides`, we can remove this class as a parent of
+    all schemas that use it, leaving them with only the `job_variables` field.
+    """
+
+    infra_overrides: Optional[Dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Deprecated field. Use `job_variables` instead.",
+    )
+
+    @root_validator(pre=True)
+    def _job_variables_from_infra_overrides(
+        cls, values: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Validate that only one of `infra_overrides` or `job_variables` is used
+        and keep them in sync during init.
+        """
+        job_variables = values.get("job_variables")
+        infra_overrides = values.get("infra_overrides")
+
+        if job_variables is not None and infra_overrides is not None:
+            if job_variables != infra_overrides:
+                raise ValueError(
+                    "The `infra_overrides` field has been renamed to `job_variables`."
+                    "Use one of these fields, but not both."
+                )
+            return values
+        elif job_variables is not None and infra_overrides is None:
+            values["infra_overrides"] = job_variables
+        elif job_variables is None and infra_overrides is not None:
+            values["job_variables"] = infra_overrides
+        return values
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        Override the default __setattr__ to ensure that setting `infra_overrides` or
+        `job_variables` will update both fields.
+        """
+        if key == "infra_overrides" or key == "job_variables":
+            updates = {"infra_overrides": value, "job_variables": value}
+            self.__dict__.update(updates)
+            return
+        super().__setattr__(key, value)
+
+    def dict(self, **kwargs) -> Dict[str, Any]:
+        """
+        Override the default dict method to ensure only `infra_overrides` is serialized.
+        This preserves backwards compatibility for newer clients talking to older servers.
+        """
+        exclude: Union[set, Dict[str, Any]] = kwargs.pop("exclude", set())
+        exclude_type = type(exclude)
+
+        if exclude_type is set:
+            exclude.add("job_variables")
+        elif exclude_type is dict:
+            exclude["job_variables"] = True
+        kwargs["exclude"] = exclude
+
+        return super().dict(**kwargs)
+
+    @classmethod
+    def schema(
+        cls, by_alias: bool = True, ref_template: str = default_ref_template
+    ) -> Dict[str, Any]:
+        """
+        Don't use the mixin docstring as the description if this class is missing a
+        docstring.
+        """
+        schema = super().schema(by_alias=by_alias, ref_template=ref_template)
+
+        if not cls.__doc__:
+            schema.pop("description", None)
+
+        return schema
+
+
+def handle_deprecated_infra_overrides_parameter(
+    job_variables: Dict[str, Any], infra_overrides: Dict[str, Any]
+) -> Optional[Dict[str, Any]]:
+    if infra_overrides is not None and job_variables is not None:
+        raise RuntimeError(
+            "The `infra_overrides` argument has been renamed to `job_variables`."
+            "Use one or the other, but not both."
+        )
+    elif infra_overrides is not None and job_variables is None:
+        jv = infra_overrides
+    elif job_variables is not None and infra_overrides is None:
+        jv = job_variables
+    else:
+        jv = None
+    return jv

prefect/_internal/pydantic/__init__.py

@@ -21,6 +21,8 @@ from ._compat import (
     BaseModel,
     Field,
     FieldInfo,
+    field_validator,
+    model_validator,
 )
 
 from ._types import IncEx
@@ -39,4 +41,6 @@ __all__ = [
     "HAS_PYDANTIC_V2",
     "Field",
     "FieldInfo",
+    "field_validator",
+    "model_validator",
 ]

prefect/_internal/pydantic/_base_model.py

@@ -1,3 +1,6 @@
+"""
+This file introduces a conditional import of `BaseModel` from Pydantic, depending on the Pydantic version available. If Pydantic V2 is not used, it falls back to importing `BaseModel` from Pydantic V1. This is to ensure compatibility with different versions of Pydantic.
+"""
 import typing
 
 from prefect._internal.pydantic._flags import (
@@ -6,14 +9,43 @@ from prefect._internal.pydantic._flags import (
 )
 
 if typing.TYPE_CHECKING:
-    from pydantic import BaseModel, Field
+    from pydantic import (
+        BaseModel,
+        ConfigDict,
+        Field,
+        PrivateAttr,
+        SecretStr,
+        ValidationError,
+    )
     from pydantic.fields import FieldInfo
 
 if HAS_PYDANTIC_V2 and not USE_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel, Field
+    from pydantic.v1 import (
+        BaseModel,
+        ConfigDict,
+        Field,
+        PrivateAttr,
+        SecretStr,
+        ValidationError,
+    )
     from pydantic.v1.fields import FieldInfo
 else:
-    from pydantic import BaseModel, Field
+    from pydantic import (
+        BaseModel,
+        ConfigDict,
+        Field,
+        PrivateAttr,
+        SecretStr,
+        ValidationError,
+    )
     from pydantic.fields import FieldInfo
 
-__all__ = ["BaseModel", "Field", "FieldInfo"]
+__all__ = [
+    "BaseModel",
+    "Field",
+    "FieldInfo",
+    "PrivateAttr",
+    "SecretStr",
+    "ConfigDict",
+    "ValidationError",
+]

prefect/_internal/pydantic/_compat.py

@@ -1,17 +1,39 @@
+"""
+Functions within this module check for Pydantic V2 compatibility and provide mechanisms for copying,
+ dumping, and validating models in a way that is agnostic to the underlying Pydantic version.
+"""
+import typing
+
 from ._base_model import BaseModel as PydanticBaseModel
-from ._base_model import Field, FieldInfo
+from ._base_model import (
+    ConfigDict,
+    Field,
+    FieldInfo,
+    PrivateAttr,
+    SecretStr,
+    ValidationError,
+)
 from ._flags import HAS_PYDANTIC_V2, USE_PYDANTIC_V2
+from .utilities.config_dict import ConfigMixin
+from .utilities.field_validator import field_validator
 from .utilities.model_construct import ModelConstructMixin, model_construct
 from .utilities.model_copy import ModelCopyMixin, model_copy
 from .utilities.model_dump import ModelDumpMixin, model_dump
 from .utilities.model_dump_json import ModelDumpJsonMixin, model_dump_json
 from .utilities.model_fields import ModelFieldMixin
+from .utilities.model_fields_set import ModelFieldsSetMixin, model_fields_set
 from .utilities.model_json_schema import ModelJsonSchemaMixin, model_json_schema
 from .utilities.model_validate import ModelValidateMixin, model_validate
 from .utilities.model_validate_json import ModelValidateJsonMixin, model_validate_json
+from .utilities.model_validator import model_validator
 from .utilities.type_adapter import TypeAdapter, validate_python
 
-if HAS_PYDANTIC_V2 and USE_PYDANTIC_V2:
+if typing.TYPE_CHECKING:
+
+    class BaseModel(PydanticBaseModel):  # type: ignore
+        pass
+
+elif HAS_PYDANTIC_V2 and USE_PYDANTIC_V2:
     # In this case, there's no functionality to add, so we just alias the Pydantic v2 BaseModel
     class BaseModel(PydanticBaseModel):  # type: ignore
         pass
@@ -29,6 +51,8 @@ else:
         ModelValidateMixin,
         ModelValidateJsonMixin,
         ModelFieldMixin,
+        ConfigMixin,
+        ModelFieldsSetMixin,
         PydanticBaseModel,
     ):
         pass
@@ -42,9 +66,16 @@ __all__ = [
     "model_json_schema",
     "model_validate",
     "model_validate_json",
+    "model_fields_set",
     "TypeAdapter",
     "validate_python",
     "BaseModel",
     "Field",
     "FieldInfo",
+    "field_validator",
+    "model_validator",
+    "PrivateAttr",
+    "SecretStr",
+    "ConfigDict",
+    "ValidationError",
 ]

prefect/_internal/pydantic/_flags.py

@@ -1,3 +1,6 @@
+"""
+This file defines flags that determine whether Pydantic V2 is available and whether its features should be used.
+"""
 import os
 
 # Retrieve current version of Pydantic installed in environment

prefect/_internal/pydantic/utilities/config_dict.py

@@ -0,0 +1,72 @@
+import typing
+
+from prefect._internal.pydantic._base_model import BaseModel, ConfigDict
+from prefect._internal.pydantic._flags import HAS_PYDANTIC_V2, USE_PYDANTIC_V2
+
+if HAS_PYDANTIC_V2:
+    from pydantic.v1.main import ModelMetaclass as PydanticModelMetaclass
+else:
+    from pydantic.main import ModelMetaclass as PydanticModelMetaclass
+
+
+if USE_PYDANTIC_V2:
+
+    class ConfigMixin(BaseModel):  # type: ignore
+        pass
+
+else:
+    T = typing.TypeVar("T")
+
+    CONFIG_V1_V2_KEYS: typing.Dict[str, str] = {
+        "allow_population_by_field_name": "populate_by_name",
+        "anystr_lower": "str_to_lower",
+        "anystr_strip_whitespace": "str_strip_whitespace",
+        "anystr_upper": "str_to_upper",
+        "keep_untouched": "ignored_types",
+        "max_anystr_length": "str_max_length",
+        "min_anystr_length": "str_min_length",
+        "orm_mode": "from_attributes",
+        "schema_extra": "json_schema_extra",
+        "validate_all": "validate_default",
+        "copy_on_model_validation": "revalidate_instances",
+    }
+
+    CONFIG_V2_V1_KEYS: typing.Dict[str, str] = {
+        v: k for k, v in CONFIG_V1_V2_KEYS.items()
+    }
+
+    def _convert_v2_config_to_v1_config(
+        config_dict: typing.Union[ConfigDict, typing.Dict[str, typing.Any]],
+    ) -> type:
+        deprecated_renamed_keys = CONFIG_V2_V1_KEYS.keys() & config_dict.keys()
+        output: typing.Dict[str, typing.Any] = {}
+        for k in sorted(deprecated_renamed_keys):
+            if CONFIG_V2_V1_KEYS[k] == "copy_on_model_validation":
+                value = config_dict.get(k)
+                if value == "never":
+                    output[CONFIG_V2_V1_KEYS[k]] = "none"
+                if value == "always":
+                    output[CONFIG_V2_V1_KEYS[k]] = "deep"
+                if value == "subclass-instances":
+                    output[CONFIG_V2_V1_KEYS[k]] = "deep"
+            else:
+                output[CONFIG_V2_V1_KEYS[k]] = config_dict.get(k)
+        return type("Config", (), output)
+
+    class ConfigMeta(PydanticModelMetaclass):  # type: ignore
+        def __new__(  # type: ignore
+            cls,
+            name: str,
+            bases: typing.Any,
+            namespace: typing.Dict[str, typing.Any],
+            **kwargs: typing.Any,
+        ):  # type: ignore
+            if model_config := namespace.get("model_config"):
+                namespace["Config"] = _convert_v2_config_to_v1_config(model_config)
+            return super().__new__(cls, name, bases, namespace, **kwargs)  # type: ignore
+
+    class ConfigMixin(BaseModel, metaclass=ConfigMeta):
+        model_config: typing.ClassVar[ConfigDict]
+
+
+__all__ = ["ConfigMixin"]

prefect/_internal/pydantic/utilities/field_validator.py

@@ -0,0 +1,135 @@
+"""
+Conditional decorator for fields depending on Pydantic version.
+"""
+
+import functools
+from inspect import signature
+from typing import TYPE_CHECKING, Any, Callable, Dict, Literal, Optional, TypeVar, Union
+
+from typing_extensions import TypeAlias
+
+from prefect._internal.pydantic._flags import HAS_PYDANTIC_V2, USE_V2_MODELS
+
+FieldValidatorModes: TypeAlias = Literal["before", "after", "wrap", "plain"]
+T = TypeVar("T", bound=Callable[..., Any])
+
+if TYPE_CHECKING:
+    from prefect._internal.pydantic._compat import BaseModel
+
+
+def field_validator(
+    field: str,
+    /,
+    *fields: str,
+    mode: FieldValidatorModes = "after",  # v2 only
+    check_fields: Union[bool, None] = None,
+    pre: bool = False,  # v1 only
+    allow_reuse: Optional[bool] = None,
+    always: bool = False,  # v1 only
+) -> Callable[[Any], Any]:
+    """Usage docs: https://docs.pydantic.dev/2.7/concepts/validators/#field-validators
+    Returns a decorator that conditionally applies Pydantic's `field_validator` or `validator`,
+    based on the Pydantic version available, for specified field(s) of a Pydantic model.
+
+    In Pydantic V2, it uses `field_validator` allowing more granular control over validation,
+    including pre-validation and post-validation modes. In Pydantic V1, it falls back to
+    using `validator`, which is less flexible but maintains backward compatibility.
+
+    Decorate methods on the class indicating that they should be used to validate fields.
+
+    Example usage:
+    ```py
+    from typing import Any
+
+    from pydantic import (
+        BaseModel,
+        ValidationError,
+        field_validator,
+    )
+
+    class Model(BaseModel):
+        a: str
+
+        @field_validator('a')
+        @classmethod
+        def ensure_foobar(cls, v: Any):
+            if 'foobar' not in v:
+                raise ValueError('"foobar" not found in a')
+            return v
+
+    print(repr(Model(a='this is foobar good')))
+    #> Model(a='this is foobar good')
+
+    try:
+        Model(a='snap')
+    except ValidationError as exc_info:
+        print(exc_info)
+        '''
+        1 validation error for Model
+        a
+        Value error, "foobar" not found in a [type=value_error, input_value='snap', input_type=str]
+        '''
+    ```
+
+        For more in depth examples, see https://docs.pydantic.dev/latest/concepts/validators/#field-validators
+
+    Args:
+        field: The first field the `field_validator` should be called on; this is separate
+            from `fields` to ensure an error is raised if you don't pass at least one.
+        *fields: Additional field(s) the `field_validator` should be called on.
+        mode: Specifies whether to validate the fields before or after validation.
+        check_fields: Whether to check that the fields actually exist on the model.
+
+    Returns:
+        A decorator that can be used to decorate a function to be used as a field_validator.
+
+    Raises:
+        PydanticUserError:
+            - If `@field_validator` is used bare (with no fields).
+            - If the args passed to `@field_validator` as fields are not strings.
+            - If `@field_validator` applied to instance methods.
+    """
+
+    def decorator(validate_func: T) -> T:
+        if USE_V2_MODELS:
+            from pydantic import field_validator  # type: ignore
+
+            return field_validator(
+                field, *fields, mode=mode, check_fields=check_fields
+            )(validate_func)
+        elif HAS_PYDANTIC_V2:
+            from pydantic.v1 import validator  # type: ignore
+        else:
+            from pydantic import validator
+
+        # Extract the parameters of the validate_func function
+        # e.g. if validate_func has a signature of (cls, v, values, config), we want to
+        # filter the kwargs to include only those expected by validate_func, which may
+        # look like (cls, v) or (cls, v, values) etc.
+        validate_func_params = signature(validate_func).parameters
+
+        @functools.wraps(validate_func)
+        def wrapper(
+            cls: "BaseModel",
+            v: Any,
+            **kwargs: Any,
+        ) -> Any:
+            filtered_kwargs: Dict[str, Any] = {
+                k: v for k, v in kwargs.items() if k in validate_func_params
+            }
+
+            return validate_func(cls, v, **filtered_kwargs)
+
+        # In Pydantic V1, `allow_reuse` is by default False, while in Pydantic V2, it is by default True.
+        # We default to False in Pydantic V1 to maintain backward compatibility
+        # e.g. One uses @validator("a", pre=True, allow_reuse=True) in Pydantic V1
+        validator_kwargs: Dict[str, Any] = {
+            "pre": pre,
+            "always": always,
+            "check_fields": check_fields if check_fields is not None else True,
+            "allow_reuse": allow_reuse if allow_reuse is not None else False,
+        }
+
+        return validator(field, *fields, **validator_kwargs)(wrapper)  # type: ignore
+
+    return decorator

prefect/_internal/pydantic/utilities/model_fields_set.py

@@ -0,0 +1,29 @@
+import typing
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+
+def model_fields_set(model_instance: "BaseModel") -> typing.Set[str]:
+    """
+    Returns a set of the model's fields.
+    """
+    if USE_V2_MODELS:
+        return getattr(model_instance, "__pydantic_fields_set__")
+    else:
+        return getattr(model_instance, "__fields_set__")
+
+
+class ModelFieldsSetMixin(BaseModel):
+    @property
+    def model_fields_set(self) -> typing.Set[str]:
+        """Returns the set of fields that have been explicitly set on this model instance.
+
+        Returns:
+            A set of strings representing the fields that have been set,
+                i.e. that were not filled from defaults.
+        """
+        return model_fields_set(self)
+
+
+__all__ = ["ModelFieldsSetMixin", "model_fields_set"]

prefect/_internal/pydantic/utilities/model_validator.py

@@ -0,0 +1,79 @@
+import functools
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, TypeVar
+
+from prefect._internal.pydantic._flags import HAS_PYDANTIC_V2, USE_V2_MODELS
+
+T = TypeVar("T", bound=Callable[..., Any])
+
+if TYPE_CHECKING:
+    from prefect._internal.pydantic._compat import BaseModel
+
+
+def model_validator(
+    _func: Optional[Callable] = None,
+    *,
+    mode: Literal["wrap", "before", "after"] = "before",  # v2 only
+    pre: bool = False,  # v1 only
+    skip_on_failure: bool = False,  # v1 only
+) -> Any:
+    """Usage docs: https://docs.pydantic.dev/2.6/concepts/validators/#model-validators
+
+    A decorator designed for Pydantic model methods to facilitate additional validations.
+    It can be applied to instance methods, class methods, or static methods of a class,
+    wrapping around the designated function to inject validation logic.
+
+    The `model_validator` does not differentiate between the types of methods it decorates
+    (instance, class, or static methods). It generically wraps the given function,
+    allowing the class's mechanism to determine how the method is treated
+    (e.g., passing `self` for instance methods or `cls` for class methods).
+
+    The actual handling of method types (instance, class, or static) is governed by the class
+    definition itself, using Python's standard `@classmethod` and `@staticmethod` decorators
+    where appropriate. This decorator simply intercepts the method call, allowing for custom
+    validation logic before, after, or wrapping the original method call, depending on the
+    `mode` parameter.
+
+    Args:
+        _func: The function to be decorated. If None, the decorator is applied with parameters.
+        mode: Specifies when the validation should occur. 'before' or 'after' are for v1 compatibility,
+              'wrap' introduces v2 behavior where the validation wraps the original call.
+        pre: (v1 only) If True, the validator is called before Pydantic's own validators.
+        skip_on_failure: (v1 only) If True, skips validation if an earlier validation failed.
+
+    Returns:
+        The decorated function with added validation logic.
+
+    Note:
+        - The behavior of the decorator changes depending on the version of Pydantic being used.
+        - The specific logic for validation should be defined within the decorated function.
+    """
+
+    def decorator(validate_func: T) -> T:
+        if USE_V2_MODELS:
+            from pydantic import model_validator
+
+            return model_validator(
+                mode=mode,
+            )(validate_func)  # type: ignore
+
+        elif HAS_PYDANTIC_V2:
+            from pydantic.v1 import root_validator
+
+        else:
+            from pydantic import root_validator
+
+        @functools.wraps(validate_func)
+        def wrapper(
+            cls: "BaseModel",
+            v: Any,
+        ) -> Any:
+            return validate_func(cls, v)
+
+        return root_validator(
+            pre=pre,
+            skip_on_failure=skip_on_failure,
+        )(wrapper)  # type: ignore
+
+    if _func is None:
+        return decorator
+    return decorator(_func)

prefect/agent.py

@@ -445,7 +445,7 @@ class PrefectAgent:
         # attributes of the infrastructure block
         doc_dict = infra_document.dict()
         infra_dict = doc_dict.get("data", {})
-        for override, value in (deployment.infra_overrides or {}).items():
+        for override, value in (deployment.job_variables or {}).items():
             nested_fields = override.split(".")
             data = infra_dict
             for field in nested_fields[:-1]: