prefect-client 2.20.2__py3-none-any.whl → 3.0.0__py3-none-any.whl

prefect/_internal/pydantic/utilities/model_rebuild.py

@@ -1,80 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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, "parse_obj")(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

@@ -1,68 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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
-) -> 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.
-
-    !!! note Replacing Pydantic V1 `pre=True` kwarg:
-    To replace a @root_validator that uses Pydantic V1's `pre=True` parameter, e.g. `@root_validator('a', pre=True)`,
-    you can use the @model_validator with the `mode='before'` parameter, (and also add a check that the field is not None, if necessary).
-    This will map to the `pre` parameter of `root_validator` in Pydantic V1, if the value is `True`.
-
-    !!! note Replacing Pydantic V1 `skip_on_failure=True` kwarg:
-    To replace a @root_validator that uses Pydantic V1's `skip_on_failure=True` parameter, e.g. `@root_validator('a', skip_on_failure=True)`,
-    we'll simply remove it. Pydantic V2 does not have an equivalent parameter, and we use it in only 3 places in Prefect, none of which are critical.
-
-    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)
-
-        pre: bool = mode == "before"
-
-        return root_validator(
-            pre=pre,
-        )(wrapper)  # type: ignore
-
-    if _func is None:
-        return decorator
-    return decorator(_func)

prefect/_internal/pydantic/utilities/type_adapter.py

@@ -1,71 +0,0 @@
-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/_vendor/fastapi/__init__.py

@@ -1,25 +0,0 @@
-"""FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
-
-__version__ = "0.99.1"
-
-from prefect._vendor.starlette import status as status
-
-from .applications import FastAPI as FastAPI
-from .background import BackgroundTasks as BackgroundTasks
-from .datastructures import UploadFile as UploadFile
-from .exceptions import HTTPException as HTTPException
-from .exceptions import WebSocketException as WebSocketException
-from .param_functions import Body as Body
-from .param_functions import Cookie as Cookie
-from .param_functions import Depends as Depends
-from .param_functions import File as File
-from .param_functions import Form as Form
-from .param_functions import Header as Header
-from .param_functions import Path as Path
-from .param_functions import Query as Query
-from .param_functions import Security as Security
-from .requests import Request as Request
-from .responses import Response as Response
-from .routing import APIRouter as APIRouter
-from .websockets import WebSocket as WebSocket
-from .websockets import WebSocketDisconnect as WebSocketDisconnect