관리-도구
편집 파일: functional_validators.cpython-38.pyc
U /?�f�^ � @ s0 U d Z ddlmZ ddlZddlZddlmZ ddlm Z ddl m Z m Z m Z mZmZmZmZ ddlmZ ddlmZ ddlmZmZmZ d d lmZ d d l m Z m Z m Z m Z d d l!mZ d d l"m#Z# ej$d k r�ddlm%Z% n ddl m%Z% e j&Z'ej(f ddie j)��G dd� d��Z*ej(f ddie j)��G dd� d��Z+ej(f ddie j)��G dd� d��Z,ej(f ddie j)��G dd� d��Z-e �r G dd� de%�Z.G dd � d e%�Z/G d d � d e%�Z0ee/ej1e.ej2f Z3ee0ej4f Z5ee6e e e f e7e e f ee f Z8d e9d < ed!e3e8�Z:ed"e5e8�Z;ed#d#d$�d%d%d&d'd(d)�d*d+��Z<ed#d,�d%d%d-d'd.d)�d/d+��Z<ed0 Z=d e9d1< d2dd$�d%d%d1d'd3d)�d4d+�Z<ed5�Z>ed6dd7�Z?G d8d9� d9ej@e%e? �ZAG d:d;� d;e%e> �ZBG d<d=� d=e%e> �ZCG d>d?� d?e%�ZDG d@dA� dAe%�ZEG dBdC� dCe%�ZFG dDdE� dEe%�ZGe e>ge>f ZHe e>ejIge>f ZJeeCe> eBe> f ZKeeFeGeDeEf ZLeeJe> eHe> f ZMed-dFdG�dHdI��ZNedJdKdG�dLdI��ZNedMdNdG�dOdI��ZNdPdQdG�dRdI�ZNedS�ZOe �r�eeOd#f ZPn ej(f e j)�G dTdU� dU��ZPe �reeOd#f ZQn ej(f e j)�G dVdW� dW��ZQdS )XzBThis module contains related classes and functions for validation.� )� annotationsN)� partialmethod)� FunctionType)� TYPE_CHECKING�Any�Callable�TypeVar�Union�cast�overload)� core_schema)� Annotated�Literal� TypeAlias� )�GetCoreSchemaHandler)�_core_metadata� _decorators� _generics�_internal_dataclass)�PydanticUserError)� � )�Protocol�frozenTc @ s, e Zd ZU dZded< dddd�dd �Zd S ) �AfterValidatora8 Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **after** the inner validation logic. Attributes: func: The validator function. Example: ```py from typing_extensions import Annotated from pydantic import AfterValidator, BaseModel, ValidationError MyInt = Annotated[int, AfterValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except ValidationError as e: print(e.json(indent=2)) ''' [ { "type": "int_parsing", "loc": [ "a" ], "msg": "Input should be a valid integer, unable to parse string as an integer", "input": "a", "url": "https://errors.pydantic.dev/2/v/int_parsing" } ] ''' ``` �Kcore_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction�funcr �_GetCoreSchemaHandler�core_schema.CoreSchema�� source_type�handler�returnc C sX ||�}t | jd�}|r8ttj| j�}tj|||jd�S ttj| j�}tj||d�S d S )N�after��schema� field_name�r& ) �_inspect_validatorr r r �WithInfoValidatorFunctionZ"with_info_after_validator_functionr' �NoInfoValidatorFunctionZ no_info_after_validator_function��selfr! r" r& �info_argr � r/ �L/opt/hc_python/lib/python3.8/site-packages/pydantic/functional_validators.py� __get_pydantic_core_schema__I s z+AfterValidator.__get_pydantic_core_schema__N��__name__� __module__� __qualname__�__doc__�__annotations__r1 r/ r/ r/ r0 r s )r c @ s, e Zd ZU dZded< dddd�dd �Zd S ) �BeforeValidatora� Usage docs: https://docs.pydantic.dev/2.8/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. Example: ```py from typing_extensions import Annotated from pydantic import BaseModel, BeforeValidator MyInt = Annotated[int, BeforeValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except TypeError as e: print(e) #> can only concatenate str (not "int") to str ``` r r r r r r c C sX ||�}t | jd�}|r8ttj| j�}tj|||jd�S ttj| j�}tj||d�S d S )N�beforer% r( ) r) r r r r* Z#with_info_before_validator_functionr' r+ Z!no_info_before_validator_functionr, r/ r/ r0 r1 u s z,BeforeValidator.__get_pydantic_core_schema__Nr2 r/ r/ r/ r0 r8 T s r8 c @ s, e Zd ZU dZded< dddd�dd �Zd S ) �PlainValidatora; Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#annotated-validators A metadata class that indicates that a validation should be applied **instead** of the inner validation logic. Attributes: func: The validator function. Example: ```py from typing_extensions import Annotated from pydantic import BaseModel, PlainValidator MyInt = Annotated[int, PlainValidator(lambda v: int(v) + 1)] class Model(BaseModel): a: MyInt print(Model(a='1').a) #> 2 ``` r r r r r r c C s� ddl m} z ||�}tjdd� |d�}W n |k rB d }Y nX t| jd�}|rtttj| j�}tj||j |d�S ttj | j�}tj ||d�S d S ) Nr �� PydanticSchemaGenerationErrorc S s || �S �Nr/ ��v�hr/ r/ r0 �<lambda>� � z=PlainValidator.__get_pydantic_core_schema__.<locals>.<lambda>��functionr& �plain)r' � serialization)rF ) �pydanticr< r �#wrap_serializer_function_ser_schemar) r r r* Z"with_info_plain_validator_functionr' r+ Z no_info_plain_validator_function)r- r! r" r< r& rF r. r r/ r/ r0 r1 � s �z+PlainValidator.__get_pydantic_core_schema__Nr2 r/ r/ r/ r0 r: � s r: c @ s, e Zd ZU dZded< dddd�dd �Zd S ) � WrapValidatora Usage docs: https://docs.pydantic.dev/2.8/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. ```py from datetime import datetime from typing_extensions import Annotated from pydantic import BaseModel, ValidationError, WrapValidator def validate_timestamp(v, handler): if v == 'now': # we don't want to bother with further validation, just return the new value return datetime.now() try: return handler(v) except ValidationError: # validation failed, in this case we want to return a default value return datetime(2000, 1, 1) MyTimestamp = Annotated[datetime, WrapValidator(validate_timestamp)] class Model(BaseModel): a: MyTimestamp print(Model(a='now').a) #> 2032-01-02 03:04:05.000006 print(Model(a='invalid').a) #> 2000-01-01 00:00:00 ``` zScore_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunctionr r r r r c C sX ||�}t | jd�}|r8ttj| j�}tj|||jd�S ttj| j�}tj||d�S d S )N�wrapr% r( ) r) r r r � WithInfoWrapValidatorFunctionZ!with_info_wrap_validator_functionr' ZNoInfoWrapValidatorFunctionZ no_info_wrap_validator_functionr, r/ r/ r0 r1 � s z*WrapValidator.__get_pydantic_core_schema__Nr2 r/ r/ r/ r0 rI � s $rI c @ s e Zd Zdddd�dd�ZdS )� _OnlyValueValidatorClsMethodr ��cls�valuer# c C s d S r= r/ �r- rN rO r/ r/ r0 �__call__� rB z%_OnlyValueValidatorClsMethod.__call__N�r3 r4 r5 rQ r/ r/ r/ r0 rL � s rL c @ s e Zd Zddddd�dd�ZdS )�_V2ValidatorClsMethodr �_core_schema.ValidationInfo�rN rO �infor# c C s d S r= r/ �r- rN rO rV r/ r/ r0 rQ � rB z _V2ValidatorClsMethod.__call__NrR r/ r/ r/ r0 rS � s rS c @ s" e Zd Zdddddd�dd�ZdS )�_V2WrapValidatorClsMethodr z)_core_schema.ValidatorFunctionWrapHandlerrT �rN rO r" rV r# c C s d S r= r/ �r- rN rO r" rV r/ r/ r0 rQ � s z"_V2WrapValidatorClsMethod.__call__NrR r/ r/ r/ r0 rX � s rX r �_PartialClsOrStaticMethod�"_V2BeforeAfterOrPlainValidatorType�_V2WrapValidatorType.)�mode� check_fields�strz%Literal[('before', 'after', 'plain')]z bool | NonezRCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType])�field�fieldsr^ r_ r# c G s d S r= r/ �ra r^ r_ rb r/ r/ r0 �field_validator s rd )r_ zLiteral['wrap']z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]c G s d S r= r/ rc r/ r/ r0 rd s )r9 r$ rJ rE �FieldValidatorModesr$ zCallable[[Any], Any]c sZ t | t�rtddd��| f���tdd� �D ��s>tddd��dd d �� ��fd d � }|S ) a: Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#field-validators 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 [Field Validators](../concepts/validators.md#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. z�`@field_validator` should be used with fields and keyword arguments, not bare. E.g. usage should be `@validator('<field_name>', ...)`zvalidator-no-fields��codec s s | ]}t |t�V qd S r= )� isinstancer` )�.0ra r/ r/ r0 � <genexpr>l s z"field_validator.<locals>.<genexpr>z�`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('<field_name_1>', '<field_name_2>', ...)`zvalidator-invalid-fieldszHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]�(_decorators.PydanticDescriptorProxy[Any]��fr# c s< t �| �rtddd��t �| �} t j��� d�}t �| |�S )Nz8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodrf )rb r^ r_ )r Zis_instance_method_from_sigr �%ensure_classmethod_based_on_signatureZFieldValidatorDecoratorInfo�PydanticDescriptorProxy�rm Zdec_info�r_ rb r^ r/ r0 �decs s � z field_validator.<locals>.dec)rh r r �all)ra r^ r_ rb rr r/ rq r0 rd & s ? � �� _ModelType� _ModelTypeCo)� covariantc @ s$ e Zd ZdZd dddd�dd�ZdS ) �ModelWrapValidatorHandlerz[@model_validator decorated function handler argument type. This is used when `mode='wrap'`.Nr zstr | int | Noneru )rO �outer_locationr# c C s d S r= r/ )r- rO rx r/ r/ r0 rQ � s z"ModelWrapValidatorHandler.__call__)N�r3 r4 r5 r6 rQ r/ r/ r/ r0 rw � s �rw c @ s$ e Zd ZdZddddd�dd�Zd S ) � ModelWrapValidatorWithoutInfoz�A @model_validator decorated function signature. This is used when `mode='wrap'` and the function does not have info argument. �type[_ModelType]r �%ModelWrapValidatorHandler[_ModelType]rt )rN rO r" r# c C s d S r= r/ )r- rN rO r" r/ r/ r0 rQ � s z&ModelWrapValidatorWithoutInfo.__call__Nry r/ r/ r/ r0 rz � s rz c @ s& e Zd ZdZdddddd�dd �Zd S ) �ModelWrapValidatorzQA @model_validator decorated function signature. This is used when `mode='wrap'`.r{ r r| rT rt rY c C s d S r= r/ rZ r/ r/ r0 rQ � s zModelWrapValidator.__call__Nry r/ r/ r/ r0 r} � s r} c @ s e Zd ZdZddd�dd�ZdS )�#FreeModelBeforeValidatorWithoutInfo��A @model_validator decorated function signature. This is used when `mode='before'` and the function does not have info argument. r )rO r# c C s d S r= r/ )r- rO r/ r/ r0 rQ � s z,FreeModelBeforeValidatorWithoutInfo.__call__Nry r/ r/ r/ r0 r~ � s r~ c @ s" e Zd ZdZdddd�dd�ZdS )� ModelBeforeValidatorWithoutInfor r rM c C s d S r= r/ rP r/ r/ r0 rQ � s z(ModelBeforeValidatorWithoutInfo.__call__Nry r/ r/ r/ r0 r� � s r� c @ s" e Zd ZdZdddd�dd�ZdS )�FreeModelBeforeValidator�UA `@model_validator` decorated function signature. This is used when `mode='before'`.r rT )rO rV r# c C s d S r= r/ )r- rO rV r/ r/ r0 rQ � s z!FreeModelBeforeValidator.__call__Nry r/ r/ r/ r0 r� � s r� c @ s$ e Zd ZdZddddd�dd�ZdS )�ModelBeforeValidatorr� r rT rU c C s d S r= r/ rW r/ r/ r0 rQ � s z ModelBeforeValidator.__call__Nry r/ r/ r/ r0 r� � s r� z|Callable[[_AnyModelWrapValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]])r^ r# c C s d S r= r/ �r^ r/ r/ r0 �model_validator s r� zLiteral['before']zqCallable[[_AnyModeBeforeValidator], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]c C s d S r= r/ r� r/ r/ r0 r� s zLiteral['after']z}Callable[[_AnyModelAfterValidator[_ModelType]], _decorators.PydanticDescriptorProxy[_decorators.ModelValidatorDecoratorInfo]]c C s d S r= r/ r� r/ r/ r0 r� s z$Literal[('wrap', 'before', 'after')]r c s ddd�� fdd� }|S )a" Usage docs: https://docs.pydantic.dev/2.8/concepts/validators/#model-validators Decorate model methods for validation purposes. Example usage: ```py from typing_extensions import Self from pydantic import BaseModel, ValidationError, model_validator class Square(BaseModel): 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 s = Square(width=1, height=1) print(repr(s)) #> Square(width=1.0, height=1.0) try: Square(width=1, height=2) except ValidationError as e: 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] ''' ``` For more in depth examples, see [Model Validators](../concepts/validators.md#model-validators). Args: mode: A required string literal that specifies the validation mode. It can be one of the following: 'wrap', 'before', or 'after'. Returns: A decorator that can be used to decorate a function to be used as a model validator. r rk rl c s" t �| �} t j� d�}t �| |�S )Nr� )r rn ZModelValidatorDecoratorInforo rp r� r/ r0 rr K s z model_validator.<locals>.decr/ )r^ rr r/ r� r0 r� s 0�AnyTypec @ s@ e Zd ZdZeddd�dd��Zedddd �d d ��ZejZd S ) � InstanceOfu� Generic type for annotating a type that is an instance of a given class. Example: ```py from pydantic import BaseModel, InstanceOf class Foo: ... class Bar(BaseModel): foo: InstanceOf[Foo] Bar(foo=Foo()) try: Bar(foo=42) except ValidationError as e: print(e) """ [ │ { │ │ 'type': 'is_instance_of', │ │ 'loc': ('foo',), │ │ 'msg': 'Input should be an instance of Foo', │ │ 'input': 42, │ │ 'ctx': {'class': 'Foo'}, │ │ 'url': 'https://errors.pydantic.dev/0.38.0/v/is_instance_of' │ } ] """ ``` r� ��itemr# c C s t || � f S r= )r �rN r� r/ r/ r0 �__class_getitem__ s z InstanceOf.__class_getitem__r r r ��sourcer" r# c C sn ddl m} t�t�|�p |�}z ||�}W n |k rD | Y S X tjdd� |d�|d< tj||d�S d S )Nr r; c S s || �S r= r/ r> r/ r/ r0 rA � rB z9InstanceOf.__get_pydantic_core_schema__.<locals>.<lambda>rC rF )Z python_schemaZ json_schema)rG r< r Zis_instance_schemar � get_originrH Zjson_or_python_schema)rN r� r" r< Zinstance_of_schema�original_schemar/ r/ r0 r1 � s � z'InstanceOf.__get_pydantic_core_schema__N) r3 r4 r5 r6 � classmethodr� r1 �object�__hash__r/ r/ r/ r0 r� ] s r� c @ s< e Zd ZdZddd�dd�Zedddd�d d ��ZejZd S ) �SkipValidationa� If this is applied as an annotation (e.g., via `x: Annotated[int, SkipValidation]`), validation will be skipped. You can also use `SkipValidation[int]` as a shorthand for `Annotated[int, SkipValidation]`. This can be useful if you want to use a type annotation for documentation/IDE/type-checking purposes, and know that it is safe to skip validation for one or more of the fields. Because this converts the validation schema to `any_schema`, subsequent annotation-applied transformations may not have the expected effects. Therefore, when used, this annotation should generally be the final annotation applied to a type. r r� c C s t |t� f S r= )r r� r� r/ r/ r0 r� � s z SkipValidation.__class_getitem__r r r� c s: ||�� t j� fdd�gd�}tj|tjdd� � d�d�S )Nc s |� �S r= r/ )Z_cr@ �r� r/ r0 rA � rB z=SkipValidation.__get_pydantic_core_schema__.<locals>.<lambda>)Zjs_annotation_functionsc S s || �S r= r/ r> r/ r/ r0 rA � rB rC )�metadatarF )r Zbuild_metadata_dictr Z any_schemarH )rN r� r" r� r/ r� r0 r1 � s ��z+SkipValidation.__get_pydantic_core_schema__N) r3 r4 r5 r6 r� r� r1 r� r� r/ r/ r/ r0 r� � s r� )Rr6 � __future__r Z _annotations� dataclasses�sys� functoolsr �typesr �typingr r r r r r r Z pydantic_corer Z _core_schema�typing_extensionsr r r � r r � _internalr r r r Zannotated_handlers�errorsr � version_infor Zinspect_validatorr) � dataclassZ slots_truer r8 r: rI rL rS rX r* r+ Z _V2ValidatorrK Z_V2WrapValidatorr� � staticmethodr[ r7 r\ r] rd re rt ru Z ValidatorFunctionWrapHandlerrw rz r} r~ r� r� r� Z ModelAfterValidatorWithoutInfoZValidationInfoZModelAfterValidatorZ_AnyModelWrapValidatorZ_AnyModeBeforeValidatorZ_AnyModelAfterValidatorr� r� r� r� r/ r/ r/ r0 �<module> s� $ 7+32 ����,� � � �^ �9 <