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

prefect/_internal/pydantic/utilities/model_rebuild.py

@@ -0,0 +1,80 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_rebuild(
+    model_instance: typing.Type[T],
+    *,
+    force: bool = False,
+    raise_errors: bool = True,
+    _parent_namespace_depth: int = 2,
+    _types_namespace: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> typing.Optional[bool]:
+    """Try to rebuild the pydantic-core schema for the model.
+
+    This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
+    the initial attempt to build the schema, and automatic rebuilding fails.
+
+    Args:
+        force: Whether to force the rebuilding of the model schema, defaults to `False`.
+        raise_errors: Whether to raise errors, defaults to `True`.
+        _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
+        _types_namespace: The types namespace, defaults to `None`.
+
+    Returns:
+        Returns `None` if the schema is already "complete" and rebuilding was not required.
+        If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
+    """
+
+    if USE_V2_MODELS:
+        return model_instance.model_rebuild(
+            force=force,
+            raise_errors=raise_errors,
+            _parent_namespace_depth=_parent_namespace_depth,
+            _types_namespace=_types_namespace,
+        )
+    else:
+        return getattr(model_instance, "update_forward_refs")()
+
+
+class ModelRebuildMixin(BaseModel):
+    @classmethod
+    def model_rebuild(
+        cls: typing.Type["Self"],
+        *,
+        force: bool = False,
+        raise_errors: bool = True,
+        _parent_namespace_depth: int = 2,
+        _types_namespace: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> typing.Optional[bool]:
+        """Try to rebuild the pydantic-core schema for the model.
+
+        This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
+        the initial attempt to build the schema, and automatic rebuilding fails.
+
+        Args:
+            force: Whether to force the rebuilding of the model schema, defaults to `False`.
+            raise_errors: Whether to raise errors, defaults to `True`.
+            _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
+            _types_namespace: The types namespace, defaults to `None`.
+
+        Returns:
+            Returns `None` if the schema is already "complete" and rebuilding was not required.
+            If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
+        """
+        return model_rebuild(
+            cls,
+            force=force,
+            raise_errors=raise_errors,
+            _parent_namespace_depth=_parent_namespace_depth,
+            _types_namespace=_types_namespace,
+        )
+
+
+__all__ = ["model_rebuild", "ModelRebuildMixin"]

prefect/_internal/pydantic/utilities/model_validate.py

@@ -0,0 +1,75 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_validate(
+    model_instance: typing.Type[T],
+    obj: typing.Any,
+    *,
+    strict: typing.Optional[bool] = False,
+    from_attributes: typing.Optional[bool] = False,
+    context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> T:
+    """
+    Validate a pydantic model instance.
+
+    Args:
+        obj: The object to validate.
+        strict: Whether to enforce types strictly.
+        from_attributes: Whether to extract data from object attributes.
+        context: Additional context to pass to the validator.
+
+    Raises:
+        ValidationError: If the object could not be validated.
+
+    Returns:
+        The validated model instance.
+    """
+    if USE_V2_MODELS:
+        return model_instance.model_validate(
+            obj,
+            strict=strict,
+            from_attributes=from_attributes,
+            context=context,
+        )
+    else:
+        return getattr(model_instance, "validate")(obj)
+
+
+class ModelValidateMixin(BaseModel):
+    @classmethod
+    def model_validate(
+        cls: typing.Type["Self"],
+        obj: typing.Any,
+        *,
+        strict: typing.Optional[bool] = False,
+        from_attributes: typing.Optional[bool] = False,
+        context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> "Self":
+        """
+        Validate a pydantic model instance.
+
+        Args:
+            obj: The object to validate.
+            strict: Whether to enforce types strictly.
+            from_attributes: Whether to extract data from object attributes.
+            context: Additional context to pass to the validator.
+
+        Raises:
+            ValidationError: If the object could not be validated.
+
+        Returns:
+            The validated model instance.
+        """
+        return model_validate(
+            cls, obj, strict=strict, from_attributes=from_attributes, context=context
+        )
+
+
+__all__ = ["model_validate"]

prefect/_internal/pydantic/utilities/model_validate_json.py

@@ -0,0 +1,68 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_validate_json(
+    model: typing.Type[T],
+    json_data: typing.Union[str, bytes, bytearray],
+    *,
+    strict: typing.Optional[bool] = False,
+    context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> T:
+    """
+    Validate the given JSON data against the Pydantic model.
+
+    Args:
+        json_data: The JSON data to validate.
+        strict: Whether to enforce types strictly.
+        context: Extra variables to pass to the validator.
+
+    Returns:
+        The validated Pydantic model.
+
+    Raises:
+        ValueError: If `json_data` is not a JSON string.
+    """
+    if USE_V2_MODELS:
+        return model.model_validate_json(
+            json_data,
+            strict=strict,
+            context=context,
+        )
+    else:
+        return getattr(model, "parse_raw")(json_data)
+
+
+class ModelValidateJsonMixin(BaseModel):
+    @classmethod
+    def model_validate_json(
+        cls: typing.Type["Self"],
+        json_data: typing.Union[str, bytes, bytearray],
+        *,
+        strict: typing.Optional[bool] = False,
+        context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> "Self":
+        """
+        Validate the given JSON data against the Pydantic model.
+
+        Args:
+            json_data: The JSON data to validate.
+            strict: Whether to enforce types strictly.
+            context: Extra variables to pass to the validator.
+
+        Returns:
+            The validated Pydantic model.
+
+        Raises:
+            ValueError: If `json_data` is not a JSON string.
+        """
+        return model_validate_json(cls, json_data, strict=strict, context=context)
+
+
+__all__ = ["model_validate_json", "ModelValidateJsonMixin"]

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/_internal/pydantic/utilities/type_adapter.py

@@ -0,0 +1,71 @@
+import typing
+
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T")
+
+if USE_V2_MODELS:
+    from pydantic import TypeAdapter  # type: ignore
+
+else:
+    from pydantic import parse_obj_as  # type: ignore
+
+    class TypeAdapter(typing.Generic[T]):
+        """
+        Type adapters provide a flexible way to perform validation and serialization based on a Python type.
+
+        A `TypeAdapter` instance exposes some of the functionality from `BaseModel` instance methods
+        for types that do not have such methods (such as dataclasses, primitive types, and more).
+
+        **Note:** `TypeAdapter` instances are not types, and cannot be used as type annotations for fields.
+
+        Attributes:
+            core_schema: The core schema for the type.
+            validator (SchemaValidator): The schema validator for the type.
+            serializer: The schema serializer for the type.
+        """
+
+        def __init__(self, type_: typing.Union[T, typing.Type[T]]) -> None:
+            self.type_ = type_
+
+        def validate_python(
+            self,
+            __object: typing.Any,
+            /,
+            *,
+            strict: typing.Optional[bool] = None,
+            from_attributes: typing.Optional[bool] = None,
+            context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        ) -> T:
+            return parse_obj_as(self.type_, __object)  # type: ignore
+
+
+def validate_python(
+    type_: typing.Union[T, typing.Type[T]],
+    __object: typing.Any,
+    /,
+    *,
+    strict: typing.Optional[bool] = None,
+    from_attributes: typing.Optional[bool] = None,
+    context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> T:
+    """Validate a Python object against the model.
+
+    Args:
+        type_: The type to validate against.
+        __object: The Python object to validate against the model.
+        strict: Whether to strictly check types.
+        from_attributes: Whether to extract data from object attributes.
+        context: Additional context to pass to the validator.
+
+    !!! note
+        When using `TypeAdapter` with a Pydantic `dataclass`, the use of the `from_attributes`
+        argument is not supported.
+
+    Returns:
+        The validated object.
+    """
+    return TypeAdapter(type_).validate_python(__object)
+
+
+__all__ = ["TypeAdapter", "validate_python"]

prefect/_internal/schemas/bases.py

@@ -1,6 +1,7 @@
 """
 Utilities for creating and working with Prefect REST API schemas.
 """
+
 import datetime
 import json
 import os
@@ -23,7 +24,6 @@ else:
     from pydantic import BaseModel, Field, SecretField
     from pydantic.json import custom_pydantic_encoder
 
-from prefect._internal.compatibility.experimental import experiment_enabled
 from prefect._internal.schemas.fields import DateTimeTZ
 from prefect._internal.schemas.serializers import orjson_dumps_extra_compatible
 
@@ -131,22 +131,6 @@ class PrefectBaseModel(BaseModel):
             dict
         """
 
-        experimental_fields = [
-            field
-            for _, field in self.__fields__.items()
-            if field.field_info.extra.get("experimental")
-        ]
-        experimental_fields_to_exclude = [
-            field.name
-            for field in experimental_fields
-            if not experiment_enabled(field.field_info.extra["experimental-group"])
-        ]
-
-        if experimental_fields_to_exclude:
-            kwargs["exclude"] = (kwargs.get("exclude") or set()).union(
-                experimental_fields_to_exclude
-            )
-
         if json_compatible and shallow:
             raise ValueError(
                 "`json_compatible` can only be applied to the entire object."