gnx/Hotel-Booking
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updates

Browse Source
This commit is contained in:
Iliyan Angelov
2025-12-06 03:27:35 +02:00
parent 7667eb5eda
commit 5a8ca3c475
2211 changed files with 28086 additions and 37066 deletions
Download Patch File Download Diff File Expand all files Collapse all files

494
Backend/venv/lib/python3.12/site-packages/pydantic/functional_validators.py
View File

@@ -4,19 +4,18 @@ from __future__ import annotations as _annotations
import dataclasses
import sys
import warnings
from functools import partialmethod
from types import FunctionType
from typing import TYPE_CHECKING, Annotated, Any, Callable, Literal, TypeVar, Union, cast, overload
from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union, cast, overload
from pydantic_core import PydanticUndefined, core_schema
from typing_extensions import Self, TypeAlias
from pydantic_core import core_schema
from pydantic_core import core_schema as _core_schema
from typing_extensions import Annotated, Literal, TypeAlias
from ._internal import _decorators, _generics, _internal_dataclass
from . import GetCoreSchemaHandler as _GetCoreSchemaHandler
from ._internal import _core_metadata, _decorators, _generics, _internal_dataclass
from .annotated_handlers import GetCoreSchemaHandler
from .errors import PydanticUserError
from .version import version_short
from .warnings import ArbitraryTypeWarning, PydanticDeprecatedSince212
if sys.version_info < (3, 11):
from typing_extensions import Protocol
@@ -28,8 +27,7 @@ _inspect_validator = _decorators.inspect_validator
@dataclasses.dataclass(frozen=True, **_internal_dataclass.slots_true)
class AfterValidator:
"""!!! abstract "Usage Documentation"
[field *after* validators](../concepts/validators.md#field-after-validator)
"""Usage docs: https://docs.pydantic.dev/2.5/concepts/validators/#annotated-validators
A metadata class that indicates that a validation should be applied **after** the inner validation logic.
@@ -37,8 +35,8 @@ class AfterValidator:
func: The validator function.
Example:
```python
from typing import Annotated
```py
from typing_extensions import Annotated
from pydantic import AfterValidator, BaseModel, ValidationError
@@ -72,36 +70,29 @@ class AfterValidator:
func: core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction
def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
def __get_pydantic_core_schema__(self, source_type: Any, handler: _GetCoreSchemaHandler) -> core_schema.CoreSchema:
schema = handler(source_type)
info_arg = _inspect_validator(self.func, mode='after', type='field')
info_arg = _inspect_validator(self.func, 'after')
if info_arg:
func = cast(core_schema.WithInfoValidatorFunction, self.func)
return core_schema.with_info_after_validator_function(func, schema=schema)
return core_schema.with_info_after_validator_function(func, schema=schema, field_name=handler.field_name)
else:
func = cast(core_schema.NoInfoValidatorFunction, self.func)
return core_schema.no_info_after_validator_function(func, schema=schema)
@classmethod
def _from_decorator(cls, decorator: _decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]) -> Self:
return cls(func=decorator.func)
@dataclasses.dataclass(frozen=True, **_internal_dataclass.slots_true)
class BeforeValidator:
"""!!! abstract "Usage Documentation"
[field *before* validators](../concepts/validators.md#field-before-validator)
"""Usage docs: https://docs.pydantic.dev/2.5/concepts/validators/#annotated-validators
A metadata class that indicates that a validation should be applied **before** the inner validation logic.
Attributes:
func: The validator function.
json_schema_input_type: The input type used to generate the appropriate
JSON Schema (in validation mode). The actual input type is `Any`.
Example:
```python
from typing import Annotated
```py
from typing_extensions import Annotated
from pydantic import BaseModel, BeforeValidator
@@ -122,153 +113,68 @@ class BeforeValidator:
"""
func: core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction
json_schema_input_type: Any = PydanticUndefined
def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
def __get_pydantic_core_schema__(self, source_type: Any, handler: _GetCoreSchemaHandler) -> core_schema.CoreSchema:
schema = handler(source_type)
input_schema = (
None
if self.json_schema_input_type is PydanticUndefined
else handler.generate_schema(self.json_schema_input_type)
)
info_arg = _inspect_validator(self.func, mode='before', type='field')
info_arg = _inspect_validator(self.func, 'before')
if info_arg:
func = cast(core_schema.WithInfoValidatorFunction, self.func)
return core_schema.with_info_before_validator_function(
func,
schema=schema,
json_schema_input_schema=input_schema,
)
return core_schema.with_info_before_validator_function(func, schema=schema, field_name=handler.field_name)
else:
func = cast(core_schema.NoInfoValidatorFunction, self.func)
return core_schema.no_info_before_validator_function(
func, schema=schema, json_schema_input_schema=input_schema
)
@classmethod
def _from_decorator(cls, decorator: _decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]) -> Self:
return cls(
func=decorator.func,
json_schema_input_type=decorator.info.json_schema_input_type,
)
return core_schema.no_info_before_validator_function(func, schema=schema)
@dataclasses.dataclass(frozen=True, **_internal_dataclass.slots_true)
class PlainValidator:
"""!!! abstract "Usage Documentation"
[field *plain* validators](../concepts/validators.md#field-plain-validator)
"""Usage docs: https://docs.pydantic.dev/2.5/concepts/validators/#annotated-validators
A metadata class that indicates that a validation should be applied **instead** of the inner validation logic.
!!! note
Before v2.9, `PlainValidator` wasn't always compatible with JSON Schema generation for `mode='validation'`.
You can now use the `json_schema_input_type` argument to specify the input type of the function
to be used in the JSON schema when `mode='validation'` (the default). See the example below for more details.
Attributes:
func: The validator function.
json_schema_input_type: The input type used to generate the appropriate
JSON Schema (in validation mode). The actual input type is `Any`.
Example:
```python
from typing import Annotated, Union
```py
from typing_extensions import Annotated
from pydantic import BaseModel, PlainValidator
def validate(v: object) -> int:
if not isinstance(v, (int, str)):
raise ValueError(f'Expected int or str, go {type(v)}')
return int(v) + 1
MyInt = Annotated[
int,
PlainValidator(validate, json_schema_input_type=Union[str, int]), # (1)!
]
MyInt = Annotated[int, PlainValidator(lambda v: int(v) + 1)]
class Model(BaseModel):
a: MyInt
print(Model(a='1').a)
#> 2
print(Model(a=1).a)
#> 2
```
1. In this example, we've specified the `json_schema_input_type` as `Union[str, int]` which indicates to the JSON schema
generator that in validation mode, the input type for the `a` field can be either a [`str`][] or an [`int`][].
"""
func: core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction
json_schema_input_type: Any = Any
def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
# Note that for some valid uses of PlainValidator, it is not possible to generate a core schema for the
# source_type, so calling `handler(source_type)` will error, which prevents us from generating a proper
# serialization schema. To work around this for use cases that will not involve serialization, we simply
# catch any PydanticSchemaGenerationError that may be raised while attempting to build the serialization schema
# and abort any attempts to handle special serialization.
from pydantic import PydanticSchemaGenerationError
try:
schema = handler(source_type)
# TODO if `schema['serialization']` is one of `'include-exclude-dict/sequence',
# schema validation will fail. That's why we use 'type ignore' comments below.
serialization = schema.get(
'serialization',
core_schema.wrap_serializer_function_ser_schema(
function=lambda v, h: h(v),
schema=schema,
return_schema=handler.generate_schema(source_type),
),
)
except PydanticSchemaGenerationError:
serialization = None
input_schema = handler.generate_schema(self.json_schema_input_type)
info_arg = _inspect_validator(self.func, mode='plain', type='field')
def __get_pydantic_core_schema__(self, source_type: Any, handler: _GetCoreSchemaHandler) -> core_schema.CoreSchema:
info_arg = _inspect_validator(self.func, 'plain')
if info_arg:
func = cast(core_schema.WithInfoValidatorFunction, self.func)
return core_schema.with_info_plain_validator_function(
func,
serialization=serialization, # pyright: ignore[reportArgumentType]
json_schema_input_schema=input_schema,
)
return core_schema.with_info_plain_validator_function(func, field_name=handler.field_name)
else:
func = cast(core_schema.NoInfoValidatorFunction, self.func)
return core_schema.no_info_plain_validator_function(
func,
serialization=serialization, # pyright: ignore[reportArgumentType]
json_schema_input_schema=input_schema,
)
@classmethod
def _from_decorator(cls, decorator: _decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]) -> Self:
return cls(
func=decorator.func,
json_schema_input_type=decorator.info.json_schema_input_type,
)
return core_schema.no_info_plain_validator_function(func)
@dataclasses.dataclass(frozen=True, **_internal_dataclass.slots_true)
class WrapValidator:
"""!!! abstract "Usage Documentation"
[field *wrap* validators](../concepts/validators.md#field-wrap-validator)
"""Usage docs: https://docs.pydantic.dev/2.5/concepts/validators/#annotated-validators
A metadata class that indicates that a validation should be applied **around** the inner validation logic.
Attributes:
func: The validator function.
json_schema_input_type: The input type used to generate the appropriate
JSON Schema (in validation mode). The actual input type is `Any`.
```python
```py
from datetime import datetime
from typing import Annotated
from typing_extensions import Annotated
from pydantic import BaseModel, ValidationError, WrapValidator
@@ -295,133 +201,95 @@ class WrapValidator:
"""
func: core_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunction
json_schema_input_type: Any = PydanticUndefined
def __get_pydantic_core_schema__(self, source_type: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
def __get_pydantic_core_schema__(self, source_type: Any, handler: _GetCoreSchemaHandler) -> core_schema.CoreSchema:
schema = handler(source_type)
input_schema = (
None
if self.json_schema_input_type is PydanticUndefined
else handler.generate_schema(self.json_schema_input_type)
)
info_arg = _inspect_validator(self.func, mode='wrap', type='field')
info_arg = _inspect_validator(self.func, 'wrap')
if info_arg:
func = cast(core_schema.WithInfoWrapValidatorFunction, self.func)
return core_schema.with_info_wrap_validator_function(
func,
schema=schema,
json_schema_input_schema=input_schema,
)
return core_schema.with_info_wrap_validator_function(func, schema=schema, field_name=handler.field_name)
else:
func = cast(core_schema.NoInfoWrapValidatorFunction, self.func)
return core_schema.no_info_wrap_validator_function(
func,
schema=schema,
json_schema_input_schema=input_schema,
)
@classmethod
def _from_decorator(cls, decorator: _decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]) -> Self:
return cls(
func=decorator.func,
json_schema_input_type=decorator.info.json_schema_input_type,
)
return core_schema.no_info_wrap_validator_function(func, schema=schema)
if TYPE_CHECKING:
class _OnlyValueValidatorClsMethod(Protocol):
def __call__(self, cls: Any, value: Any, /) -> Any: ...
def __call__(self, __cls: Any, __value: Any) -> Any:
...
class _V2ValidatorClsMethod(Protocol):
def __call__(self, cls: Any, value: Any, info: core_schema.ValidationInfo[Any], /) -> Any: ...
class _OnlyValueWrapValidatorClsMethod(Protocol):
def __call__(self, cls: Any, value: Any, handler: core_schema.ValidatorFunctionWrapHandler, /) -> Any: ...
def __call__(self, __cls: Any, __input_value: Any, __info: _core_schema.ValidationInfo) -> Any:
...
class _V2WrapValidatorClsMethod(Protocol):
def __call__(
self,
cls: Any,
value: Any,
handler: core_schema.ValidatorFunctionWrapHandler,
info: core_schema.ValidationInfo[Any],
/,
) -> Any: ...
__cls: Any,
__input_value: Any,
__validator: _core_schema.ValidatorFunctionWrapHandler,
__info: _core_schema.ValidationInfo,
) -> Any:
...
_V2Validator = Union[
_V2ValidatorClsMethod,
core_schema.WithInfoValidatorFunction,
_core_schema.WithInfoValidatorFunction,
_OnlyValueValidatorClsMethod,
core_schema.NoInfoValidatorFunction,
_core_schema.NoInfoValidatorFunction,
]
_V2WrapValidator = Union[
_V2WrapValidatorClsMethod,
core_schema.WithInfoWrapValidatorFunction,
_OnlyValueWrapValidatorClsMethod,
core_schema.NoInfoWrapValidatorFunction,
_core_schema.WithInfoWrapValidatorFunction,
]
_PartialClsOrStaticMethod: TypeAlias = Union[classmethod[Any, Any, Any], staticmethod[Any, Any], partialmethod[Any]]
_V2BeforeAfterOrPlainValidatorType = TypeVar(
'_V2BeforeAfterOrPlainValidatorType',
bound=Union[_V2Validator, _PartialClsOrStaticMethod],
_V2Validator,
_PartialClsOrStaticMethod,
)
_V2WrapValidatorType = TypeVar('_V2WrapValidatorType', bound=Union[_V2WrapValidator, _PartialClsOrStaticMethod])
_V2WrapValidatorType = TypeVar('_V2WrapValidatorType', _V2WrapValidator, _PartialClsOrStaticMethod)
@overload
def field_validator(
__field: str,
*fields: str,
mode: Literal['before', 'after', 'plain'] = ...,
check_fields: bool | None = ...,
) -> Callable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]:
...
@overload
def field_validator(
__field: str,
*fields: str,
mode: Literal['wrap'],
check_fields: bool | None = ...,
) -> Callable[[_V2WrapValidatorType], _V2WrapValidatorType]:
...
FieldValidatorModes: TypeAlias = Literal['before', 'after', 'wrap', 'plain']
@overload
def field_validator(
field: str,
/,
*fields: str,
mode: Literal['wrap'],
check_fields: bool | None = ...,
json_schema_input_type: Any = ...,
) -> Callable[[_V2WrapValidatorType], _V2WrapValidatorType]: ...
@overload
def field_validator(
field: str,
/,
*fields: str,
mode: Literal['before', 'plain'],
check_fields: bool | None = ...,
json_schema_input_type: Any = ...,
) -> Callable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]: ...
@overload
def field_validator(
field: str,
/,
*fields: str,
mode: Literal['after'] = ...,
check_fields: bool | None = ...,
) -> Callable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]: ...
def field_validator(
field: str,
/,
__field: str,
*fields: str,
mode: FieldValidatorModes = 'after',
check_fields: bool | None = None,
json_schema_input_type: Any = PydanticUndefined,
) -> Callable[[Any], Any]:
"""!!! abstract "Usage Documentation"
[field validators](../concepts/validators.md#field-validators)
"""Usage docs: https://docs.pydantic.dev/2.5/concepts/validators/#field-validators
Decorate methods on the class indicating that they should be used to validate fields.
Example usage:
```python
```py
from typing import Any
from pydantic import (
@@ -457,14 +325,11 @@ def field_validator(
For more in depth examples, see [Field Validators](../concepts/validators.md#field-validators).
Args:
field: The first field the `field_validator` should be called on; this is separate
__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.
json_schema_input_type: The input type of the function. This is only used to generate
the appropriate JSON Schema (in validation mode) and can only specified
when `mode` is either `'before'`, `'plain'` or `'wrap'`.
Returns:
A decorator that can be used to decorate a function to be used as a field_validator.
@@ -475,23 +340,13 @@ def field_validator(
- If the args passed to `@field_validator` as fields are not strings.
- If `@field_validator` applied to instance methods.
"""
if isinstance(field, FunctionType):
if isinstance(__field, FunctionType):
raise PydanticUserError(
'`@field_validator` should be used with fields and keyword arguments, not bare. '
"E.g. usage should be `@validator('<field_name>', ...)`",
code='validator-no-fields',
)
if mode not in ('before', 'plain', 'wrap') and json_schema_input_type is not PydanticUndefined:
raise PydanticUserError(
f"`json_schema_input_type` can't be used when mode is set to {mode!r}",
code='validator-input-type',
)
if json_schema_input_type is PydanticUndefined and mode == 'plain':
json_schema_input_type = Any
fields = field, *fields
fields = __field, *fields
if not all(isinstance(field, str) for field in fields):
raise PydanticUserError(
'`@field_validator` fields should be passed as separate string args. '
@@ -500,7 +355,7 @@ def field_validator(
)
def dec(
f: Callable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any],
f: Callable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]
) -> _decorators.PydanticDescriptorProxy[Any]:
if _decorators.is_instance_method_from_sig(f):
raise PydanticUserError(
@@ -510,9 +365,7 @@ def field_validator(
# auto apply the @classmethod decorator
f = _decorators.ensure_classmethod_based_on_signature(f)
dec_info = _decorators.FieldValidatorDecoratorInfo(
fields=fields, mode=mode, check_fields=check_fields, json_schema_input_type=json_schema_input_type
)
dec_info = _decorators.FieldValidatorDecoratorInfo(fields=fields, mode=mode, check_fields=check_fields)
return _decorators.PydanticDescriptorProxy(f, dec_info)
return dec
@@ -522,20 +375,17 @@ _ModelType = TypeVar('_ModelType')
_ModelTypeCo = TypeVar('_ModelTypeCo', covariant=True)
class ModelWrapValidatorHandler(core_schema.ValidatorFunctionWrapHandler, Protocol[_ModelTypeCo]):
"""`@model_validator` decorated function handler argument type. This is used when `mode='wrap'`."""
class ModelWrapValidatorHandler(_core_schema.ValidatorFunctionWrapHandler, Protocol[_ModelTypeCo]):
"""@model_validator decorated function handler argument type. This is used when `mode='wrap'`."""
def __call__( # noqa: D102
self,
value: Any,
outer_location: str | int | None = None,
/,
self, input_value: Any, outer_location: str | int | None = None
) -> _ModelTypeCo: # pragma: no cover
...
class ModelWrapValidatorWithoutInfo(Protocol[_ModelType]):
"""A `@model_validator` decorated function signature.
"""A @model_validator decorated function signature.
This is used when `mode='wrap'` and the function does not have info argument.
"""
@@ -545,14 +395,14 @@ class ModelWrapValidatorWithoutInfo(Protocol[_ModelType]):
# this can be a dict, a model instance
# or anything else that gets passed to validate_python
# thus validators _must_ handle all cases
value: Any,
handler: ModelWrapValidatorHandler[_ModelType],
/,
) -> _ModelType: ...
__value: Any,
__handler: ModelWrapValidatorHandler[_ModelType],
) -> _ModelType:
...
class ModelWrapValidator(Protocol[_ModelType]):
"""A `@model_validator` decorated function signature. This is used when `mode='wrap'`."""
"""A @model_validator decorated function signature. This is used when `mode='wrap'`."""
def __call__( # noqa: D102
self,
@@ -560,30 +410,15 @@ class ModelWrapValidator(Protocol[_ModelType]):
# this can be a dict, a model instance
# or anything else that gets passed to validate_python
# thus validators _must_ handle all cases
value: Any,
handler: ModelWrapValidatorHandler[_ModelType],
info: core_schema.ValidationInfo,
/,
) -> _ModelType: ...
class FreeModelBeforeValidatorWithoutInfo(Protocol):
"""A `@model_validator` decorated function signature.
This is used when `mode='before'` and the function does not have info argument.
"""
def __call__( # noqa: D102
self,
# this can be a dict, a model instance
# or anything else that gets passed to validate_python
# thus validators _must_ handle all cases
value: Any,
/,
) -> Any: ...
__value: Any,
__handler: ModelWrapValidatorHandler[_ModelType],
__info: _core_schema.ValidationInfo,
) -> _ModelType:
...
class ModelBeforeValidatorWithoutInfo(Protocol):
"""A `@model_validator` decorated function signature.
"""A @model_validator decorated function signature.
This is used when `mode='before'` and the function does not have info argument.
"""
@@ -593,23 +428,9 @@ class ModelBeforeValidatorWithoutInfo(Protocol):
# this can be a dict, a model instance
# or anything else that gets passed to validate_python
# thus validators _must_ handle all cases
value: Any,
/,
) -> Any: ...
class FreeModelBeforeValidator(Protocol):
"""A `@model_validator` decorated function signature. This is used when `mode='before'`."""
def __call__( # noqa: D102
self,
# this can be a dict, a model instance
# or anything else that gets passed to validate_python
# thus validators _must_ handle all cases
value: Any,
info: core_schema.ValidationInfo[Any],
/,
) -> Any: ...
__value: Any,
) -> Any:
...
class ModelBeforeValidator(Protocol):
@@ -621,10 +442,10 @@ class ModelBeforeValidator(Protocol):
# this can be a dict, a model instance
# or anything else that gets passed to validate_python
# thus validators _must_ handle all cases
value: Any,
info: core_schema.ValidationInfo[Any],
/,
) -> Any: ...
__value: Any,
__info: _core_schema.ValidationInfo,
) -> Any:
...
ModelAfterValidatorWithoutInfo = Callable[[_ModelType], _ModelType]
@@ -632,13 +453,11 @@ ModelAfterValidatorWithoutInfo = Callable[[_ModelType], _ModelType]
have info argument.
"""
ModelAfterValidator = Callable[[_ModelType, core_schema.ValidationInfo[Any]], _ModelType]
ModelAfterValidator = Callable[[_ModelType, _core_schema.ValidationInfo], _ModelType]
"""A `@model_validator` decorated function signature. This is used when `mode='after'`."""
_AnyModelWrapValidator = Union[ModelWrapValidator[_ModelType], ModelWrapValidatorWithoutInfo[_ModelType]]
_AnyModelBeforeValidator = Union[
FreeModelBeforeValidator, ModelBeforeValidator, FreeModelBeforeValidatorWithoutInfo, ModelBeforeValidatorWithoutInfo
]
_AnyModeBeforeValidator = Union[ModelBeforeValidator, ModelBeforeValidatorWithoutInfo]
_AnyModelAfterValidator = Union[ModelAfterValidator[_ModelType], ModelAfterValidatorWithoutInfo[_ModelType]]
@@ -648,16 +467,16 @@ def model_validator(
mode: Literal['wrap'],
) -> Callable[
[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]
]: ...
]:
...
@overload
def model_validator(
*,
mode: Literal['before'],
) -> Callable[
[_AnyModelBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]
]: ...
) -> Callable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]:
...
@overload
@@ -666,33 +485,33 @@ def model_validator(
mode: Literal['after'],
) -> Callable[
[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]
]: ...
]:
...
def model_validator(
*,
mode: Literal['wrap', 'before', 'after'],
) -> Any:
"""!!! abstract "Usage Documentation"
[Model Validators](../concepts/validators.md#model-validators)
"""Usage docs: https://docs.pydantic.dev/2.5/concepts/validators/#model-validators
Decorate model methods for validation purposes.
Example usage:
```python
from typing_extensions import Self
```py
from typing import Optional
from pydantic import BaseModel, ValidationError, model_validator
class Square(BaseModel):
width: float
height: float
width: float
height: float
@model_validator(mode='after')
def verify_square(self) -> Self:
if self.width != self.height:
raise ValueError('width and height do not match')
return self
@model_validator(mode='after')
def verify_square(self) -> 'Rectangle':
if self.width != self.height:
raise ValueError('width and height do not match')
return self
s = Square(width=1, height=1)
print(repr(s))
@@ -704,7 +523,8 @@ def model_validator(
print(e)
'''
1 validation error for Square
Value error, width and height do not match [type=value_error, input_value={'width': 1, 'height': 2}, input_type=dict]
__root__
width and height do not match (type=value_error)
'''
```
@@ -719,18 +539,8 @@ def model_validator(
"""
def dec(f: Any) -> _decorators.PydanticDescriptorProxy[Any]:
# auto apply the @classmethod decorator. NOTE: in V3, do not apply the conversion for 'after' validators:
# auto apply the @classmethod decorator
f = _decorators.ensure_classmethod_based_on_signature(f)
if mode == 'after' and isinstance(f, classmethod):
warnings.warn(
category=PydanticDeprecatedSince212,
message=(
"Using `@model_validator` with mode='after' on a classmethod is deprecated. Instead, use an instance method. "
f'See the documentation at https://docs.pydantic.dev/{version_short()}/concepts/validators/#model-after-validator.'
),
stacklevel=2,
)
dec_info = _decorators.ModelValidatorDecoratorInfo(mode=mode)
return _decorators.PydanticDescriptorProxy(f, dec_info)
@@ -751,7 +561,7 @@ else:
'''Generic type for annotating a type that is an instance of a given class.
Example:
```python
```py
from pydantic import BaseModel, InstanceOf
class Foo:
@@ -829,10 +639,8 @@ else:
@classmethod
def __get_pydantic_core_schema__(cls, source: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
with warnings.catch_warnings():
warnings.simplefilter('ignore', ArbitraryTypeWarning)
original_schema = handler(source)
metadata = {'pydantic_js_annotation_functions': [lambda _c, h: h(original_schema)]}
original_schema = handler(source)
metadata = _core_metadata.build_metadata_dict(js_annotation_functions=[lambda _c, h: h(original_schema)])
return core_schema.any_schema(
metadata=metadata,
serialization=core_schema.wrap_serializer_function_ser_schema(
@@ -841,53 +649,3 @@ else:
)
__hash__ = object.__hash__
_FromTypeT = TypeVar('_FromTypeT')
class ValidateAs:
"""A helper class to validate a custom type from a type that is natively supported by Pydantic.
Args:
from_type: The type natively supported by Pydantic to use to perform validation.
instantiation_hook: A callable taking the validated type as an argument, and returning
the populated custom type.
Example:
```python {lint="skip"}
from typing import Annotated
from pydantic import BaseModel, TypeAdapter, ValidateAs
class MyCls:
def __init__(self, a: int) -> None:
self.a = a
def __repr__(self) -> str:
return f"MyCls(a={self.a})"
class Model(BaseModel):
a: int
ta = TypeAdapter(
Annotated[MyCls, ValidateAs(Model, lambda v: MyCls(a=v.a))]
)
print(ta.validate_python({'a': 1}))
#> MyCls(a=1)
```
"""
# TODO: make use of PEP 747
def __init__(self, from_type: type[_FromTypeT], /, instantiation_hook: Callable[[_FromTypeT], Any]) -> None:
self.from_type = from_type
self.instantiation_hook = instantiation_hook
def __get_pydantic_core_schema__(self, source: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
schema = handler(self.from_type)
return core_schema.no_info_after_validator_function(
self.instantiation_hook,
schema=schema,
)