관리-도구
편집 파일: fields.cpython-38.pyc
U /?�f�� � @ s U d dl Z d dlZd dlmZmZmZ d dlmZm Z m Z d dl mZmZmZmZmZmZmZmZmZm Z mZmZmZmZmZmZm Z m Z m Z m Z m Z d dl!m"Z"m#Z# d dl$m%Z& d dl'm(Z(m)Z)m*Z* d dl+m,Z, d d l-m.Z.m/Z/m0Z0m1Z1 d d l2m3Z3m4Z4 d d l5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZB d d lCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZL d d lMmNZNmOZOmPZPmQZQ eRZSeeTd< e d�ZUG dd� d�ZVeV� ZWe�r(d dl'mXZX d dlYmZZZ d dl+m[Z[ d dl2m\Z\ d dl5m]Z]m^Z^m_Z_ e ee ee[ f Z`e e e eaebf df ebf Zce edeVf ZeG dd� deE�ZfeWfddddddddddddddddddddddddd�eee6 eeb eeb eeb ee d d ef ee d d ef eed eeg eeg eeg eeg eeg eed eea eea eea eea eed eea eea edeeb eeb edeed �d d �Zhd!Zid"Zjd#Zkd$Zld%Zmd&Znd'Zod(Zpd)Zqd*Zrd+Zsd,Ztd-Zud.Zvejd/ekd0end1eod2epd3eqd4esd5etd6eud7evd8i ZweuetelevhZxe ea eTd9< G d:d;� d;eE�ZyG d<d=� d=eE�ZzeWfdd>�eee6 ed?�d@dA�Z{G dBdC� dC�Z|e e eeddD�dEdF�Z}dS )G� N)�Counter� defaultdict�deque)�Callable�Hashable�Iterable)� TYPE_CHECKING�Anyr � DefaultDict�Deque�Dict� ForwardRef� FrozenSet� Generatorr �Iterator�List�Mapping�Optional�Pattern�Sequence�Set�Tuple�Type�TypeVar�Union)� Annotated�Final)�errors)� Validator�make_generic_validator�prep_validators)� ErrorWrapper)� ConfigError�InvalidDiscriminator�MissingDiscriminator�NoneIsNotAllowedError)�Json� JsonWrapper) �NoArgAnyCallable�convert_generics�display_as_type�get_args� get_origin� is_finalvar�is_literal_type� is_new_type� is_none_type� is_typeddict�is_typeddict_special�is_union�new_type_supertype) � PyObjectStr�Representation� ValueItems�"get_discriminator_alias_and_values� get_unique_discriminator_alias�lenient_isinstance�lenient_issubclass� sequence_like�smart_deepcopy)�constant_validator�dict_validator�find_validators� validate_json�Required�Tc @ sJ e Zd Zed�dd�Zeed�dd�Zed�dd�Zeeed �d d �Z d S ) � UndefinedType��returnc C s dS )NZPydanticUndefined� ��selfrG rG �@/opt/hc_python/lib/python3.8/site-packages/pydantic/v1/fields.py�__repr__F s zUndefinedType.__repr__)rI rF c C s | S �NrG rH rG rG rJ �__copy__I s zUndefinedType.__copy__c C s dS )N� UndefinedrG rH rG rG rJ � __reduce__L s zUndefinedType.__reduce__)rI �_rF c C s | S rL rG )rI rP rG rG rJ � __deepcopy__O s zUndefinedType.__deepcopy__N) �__name__� __module__� __qualname__�strrK rC rM rO r rQ rG rG rG rJ rD E s rD )�ValidatorsList)� BaseConfig)� ErrorList)� ModelOrDc)�AbstractSetIntStr�MappingIntStrAny�ReprArgs.c @ s� e Zd ZdZdZdddddddddddddddd�Zefeedd�dd�Zd d �d d �Z e e d �d d�Z e e ef dd�dd�Zdd �dd�ZdS )� FieldInfoz3 Captures extra information about a field. )�default�default_factory�alias�alias_priority�title� description�exclude�include�const�gt�ge�lt�le� multiple_of� allow_inf_nan� max_digits�decimal_places� min_items� max_items� unique_items� min_length� max_length�allow_mutation�repr�regex� discriminator�extraNT)rr rs rv rg ri rh rj rk rl rm rn ro rp rq rt )r^ �kwargsrF c K s| || _ |�dd �| _|�dd �| _|�d| jd k r6dnd �| _|�dd �| _|�dd �| _|�dd �| _|�dd �| _|�d d �| _ |�d d �| _ |�d d �| _ |�d d �| _ |�d d �| _ |�dd �| _|�dd �| _|�dd �| _|�dd �| _|�dd �| _|�dd �| _|�dd �| _|�dd �| _|�dd �| _|�dd�| _|�dd �| _|�dd �| _|�dd�| _|| _d S ) Nr_ r` ra � rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt Trv rw ru ) r^ �popr_ r` ra rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt rv rw ru rx )rI r^ ry rG rG rJ �__init__� s6 zFieldInfo.__init__r\ rE c s4 ddi�j �� �fdd��jD �}� fdd�|D �S )Nru Tc 3 s | ]}|t � |�fV qd S rL ��getattr)�.0�srH rG rJ � <genexpr>� s z*FieldInfo.__repr_args__.<locals>.<genexpr>c s( g | ] \}}|� � |d �kr||f�qS rL )�get)r �a�v)�field_defaults_to_hiderG rJ � <listcomp>� s z+FieldInfo.__repr_args__.<locals>.<listcomp>)�__field_constraints__� __slots__)rI �attrsrG )r� rI rJ � __repr_args__� s ��zFieldInfo.__repr_args__c s � fdd�� j �� D �S )z� Gets the constraints set on the field by comparing the constraint value with its default value :return: the constraints set on field_info c s" h | ]\}}t � |�|kr|�qS rG r} )r �attrr^ rH rG rJ � <setcomp>� s z,FieldInfo.get_constraints.<locals>.<setcomp>)r� �itemsrH rG rH rJ �get_constraints� s zFieldInfo.get_constraints)� from_configrF c C s� |� � D ]�\}}zt| |�}W n" tk r@ | j�||� Y qX || j�|d�krbt| ||� q|dkrzt� ||�| _ q|dkrtj ||dd�| _ qdS )z{ Update this FieldInfo based on a dict from get_field_info, only fields which have not been set are dated. Nrd re T�Z intersect) r� r~ �AttributeErrorrx � setdefaultr� r� �setattrr7 �mergerd re )rI r� � attr_name�value� current_valuerG rG rJ �update_from_config� s z FieldInfo.update_from_configc C s | j tk r | jd k r td��d S )N�/cannot specify both default and default_factory)r^ rN r_ � ValueErrorrH rG rG rJ � _validate� s zFieldInfo._validate)rR rS rT �__doc__r� r� rN r r| r� r rU r� r r� r� rG rG rG rJ r] a s. � r] T�r_ r` rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt rv rw ru rZ r[ )r^ r_ r` rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt rv rw ru rx rF c K sN t | f||||||||| | | | | |||||||||||d�|��}|�� |S )u� Used to provide extra information about a field, either for the model schema or complex validation. Some arguments apply only to number fields (``int``, ``float``, ``Decimal``) and some apply only to ``str``. :param default: since this is replacing the field’s default, its first argument is used to set the default, use ellipsis (``...``) to indicate the field is required :param default_factory: callable that will be called when a default value is needed for this field If both `default` and `default_factory` are set, an error is raised. :param alias: the public name of the field :param title: can be any string, used in the schema :param description: can be any string, used in the schema :param exclude: exclude this field while dumping. Takes same values as the ``include`` and ``exclude`` arguments on the ``.dict`` method. :param include: include this field while dumping. Takes same values as the ``include`` and ``exclude`` arguments on the ``.dict`` method. :param const: this field is required and *must* take it's default value :param gt: only applies to numbers, requires the field to be "greater than". The schema will have an ``exclusiveMinimum`` validation keyword :param ge: only applies to numbers, requires the field to be "greater than or equal to". The schema will have a ``minimum`` validation keyword :param lt: only applies to numbers, requires the field to be "less than". The schema will have an ``exclusiveMaximum`` validation keyword :param le: only applies to numbers, requires the field to be "less than or equal to". The schema will have a ``maximum`` validation keyword :param multiple_of: only applies to numbers, requires the field to be "a multiple of". The schema will have a ``multipleOf`` validation keyword :param allow_inf_nan: only applies to numbers, allows the field to be NaN or infinity (+inf or -inf), which is a valid Python float. Default True, set to False for compatibility with JSON. :param max_digits: only applies to Decimals, requires the field to have a maximum number of digits within the decimal. It does not include a zero before the decimal point or trailing decimal zeroes. :param decimal_places: only applies to Decimals, requires the field to have at most a number of decimal places allowed. It does not include trailing decimal zeroes. :param min_items: only applies to lists, requires the field to have a minimum number of elements. The schema will have a ``minItems`` validation keyword :param max_items: only applies to lists, requires the field to have a maximum number of elements. The schema will have a ``maxItems`` validation keyword :param unique_items: only applies to lists, requires the field not to have duplicated elements. The schema will have a ``uniqueItems`` validation keyword :param min_length: only applies to strings, requires the field to have a minimum length. The schema will have a ``minLength`` validation keyword :param max_length: only applies to strings, requires the field to have a maximum length. The schema will have a ``maxLength`` validation keyword :param allow_mutation: a boolean which defaults to True. When False, the field raises a TypeError if the field is assigned on an instance. The BaseModel Config must set validate_assignment to True :param regex: only applies to strings, requires the field match against a regular expression pattern string. The schema will have a ``pattern`` validation keyword :param discriminator: only useful with a (discriminated a.k.a. tagged) `Union` of sub models with a common field. The `discriminator` is the name of this common field to shorten validation and improve generated schema :param repr: show this field in the representation :param **extra: any additional keyword arguments will be added as is to the schema r� )r] r� )r^ r_ r` rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt rv rw ru rx � field_inforG rG rJ �Field� s@ P��� r� � rz � � � � � � � � � � � � zList[{}]zSet[{}]zTuple[{}, ...]z Sequence[{}]z FrozenSet[{}]z Iterable[{}]z Deque[{}]zDict[{}]zDefaultDict[{}]z Counter[{}]�MAPPING_LIKE_SHAPESc @ s� e Zd ZdZddedddd�eee ee ee f ed eee de ee ee dd� dd �Zed �d d �Zeeeeed ee ef d �dd��Zeeeeee ee f ed d d�dd��Zed dd�dd�Zee d �dd��Zdd �dd�Zdd �dd�Zdd �d d �Zdd �d d �Zdd �ee ee d d!�d"d#�Z dd �d$d%�Z dd&�ee eef d'ed( d)d*�d+d,�Z ee eef d'ed( d)d*�d-d.�Z ee eef d'ed( d)d*�d/d0�Z ee eef d'ed( d)d*�d1d2�Z!ee eef d'ed( d)d*�d3d4�Z"e#e eef e$e#e eef f d5�d6d7�Z%ee eef d'ed( d)d*�d8d9�Z&ee eef d'ed( d)d*�d:d;�Z'ee eef d'ed( d<d)d=�d>d?�Z(e d �d@dA�Z)e*d �dBdC�Z+dDd �dEdF�Z,dS )G� ModelField)�type_� outer_type_� annotation� sub_fields�sub_fields_mapping� key_field� validators�pre_validators�post_validatorsr^ r_ �required�final� model_config�namer` � has_aliasr� �discriminator_key�discriminator_alias�validate_always� allow_none�shape�class_validators� parse_jsonNF)r^ r_ r� r� r` r� rW � BoolUndefined) r� r� r� r� r^ r_ r� r� r` r� rF c C s� || _ | d k | _| d k r | n|| _|| _t|�| _|| _|p>i | _|| _|| _ || _ || _ || _ | pjt |�| _| jj| _| j| _d| _d| _d | _d | _d | _g | _d | _d | _d| _t| _ | j � | � | � � d S )NF) r� r� r` r� r) r� r� r� r^ r_ r� r� r� r] r� rw r� r� r� r� r� r� r� r� r� r� r� �SHAPE_SINGLETONr� � prepare_field�prepare) rI r� r� r� r� r^ r_ r� r� r` r� rG rG rJ r| � s6 zModelField.__init__rE c C s | j d krt| j�S | � � S rL �r_ r= r^ rH rG rG rJ � get_default� s zModelField.get_default)� field_namer� r� �configrF c C s |� | �}d}t|�tkr�dd� t|�dd� D �}t|�dkrNtd| ����tt|�d�}|dk r�t�|�}|� |� |j t t fkr�td| ����|t k r�|t k r�||_ t |t�r�|dk r�td| ����|}|� |� n|dkr�t|f|�}|jdk r�dn|j }|�� ||fS )a~ Get a FieldInfo from a root typing.Annotated annotation, value, or config default. The FieldInfo may be set in typing.Annotated or the value, but not both. If neither contain a FieldInfo, a new one will be created using the config. :param field_name: name of the field for use in error messages :param annotation: a type hint such as `str` or `Annotated[str, Field(..., min_length=5)]` :param value: the field's assigned value :param config: the model's config object :return: the FieldInfo contained in the `annotation`, the value, or a new one from the config. Nc S s g | ]}t |t�r|�qS rG )� isinstancer] )r �argrG rG rJ r� � s z.ModelField._get_field_info.<locals>.<listcomp>r� z1cannot specify multiple `Annotated` `Field`s for z1`Field` default cannot be set in `Annotated` for z;cannot specify `Annotated` and value `Field`s together for )�get_field_infor, r r+ �lenr� �next�iter�copyr� r^ rN rB r� r] r_ r� )r� r� r� r� Zfield_info_from_configr� Z field_infosrG rG rJ �_get_field_info� s0 zModelField._get_field_info)r� r� r� r� r� rF c C sp ddl m} | �||||�\}}t}|tkr6d}d }n |tk rBd}|||||j�}| |||j|||j|||d� S )Nr )� get_annotation_from_field_infoTF) r� r� r` r� r^ r_ r� r� r� )Zpydantic.v1.schemar� r� rN rB Zvalidate_assignmentr` r_ ) �clsr� r� r� r� r� r� r� r� rG rG rJ �infer� s( �zModelField.infer)r� rF c C s� || _ |�| j�}|�| � |�d�}|�d�p2d}|r^|| jjpDdkr^|| j_|| j_|| _|�d�}|d k r�t� | jj |�| j_ |�d�}|d k r�tj | jj |dd�| j_ d S )Nr` ra r rd re Tr� ) r� r� r� r� r� r� ra r` r7 r� rd re )rI r� Zinfo_from_configZ new_aliasZnew_alias_priorityZ new_excludeZ new_includerG rG rJ � set_config s zModelField.set_configc C s | j | jkS rL )r� r` rH rG rG rJ � alt_alias s zModelField.alt_aliasc C sb | � � | jjtks | jjtkr$dS | �� | jtkr<d| _| jtkrV| j dkrVd| _| � � dS )a Prepare the field but inspecting self.default, self.type_ etc. Note: this method is **not** idempotent (because _type_analysis is not idempotent), e.g. calling it it multiple times may modify the field and configure it incorrectly. NT) �_set_default_and_typer� � __class__r � DeferredType�_type_analysisr� rN r^ r_ �populate_validatorsrH rG rG rJ r� s zModelField.preparec C s� | j dk r,| jtkr(t�d| j�d���dS | �� }|dk r^| jtkr^|j| _| j| _| j| _ | jtkr|t�d| j� d���| j dkr�|dkr�d| _ dS )ze Set the default value, infer the type if needed and check if `None` value is valid. Nz"you need to set the type of field z when using `default_factory`z$unable to infer type for attribute "�"FT) r_ r� rN �errors_r" r� r� r� r� r� r� r� )rI � default_valuerG rG rJ r� - s � z ModelField._set_default_and_typec st t � jt�r � jj� _d� _npt � jt�r8t� _d� _nVt� jt�rx� jj rX� jj � _q�� jj rpt � jj � _q�t� _nt � j�r�t � j�� _� jtks�� jtkr�� jtkr�d� _d� _d S � jtks҈ jtjkr�d S t� j�r�d S t� j�r�d S t� j��r4d� _� jtk�rt� _nt� j�d � _� �� d S t� j�}|t k�sRt |��rnt� j�d � _� �� d S � j d k �r�t |��s�t d��|d k�s�|t!k�r�t� jt"��r�td � j��r�d� _d S |t#k�r�d S t |��r�g }t� j�D ]T}t$|��s|tk�s|tk�r&� jtk�r d� _d� _t$|��r4�q�|�%|� �q�t&|�dk�rl|d � _� j� _'� �� n(� fdd�|D �� _(� j d k �r�� �)� d S t*|t+��rLt� j�}|�s�t� _t,� _-n�t&|�dk�r |d t.k�r |d � _t,� _-� �/|d � j0� d ��g� _(n<|d k�r*t1� _-t� _g � _(n t1� _-� fd d�t2|�D �� _(d S t*|t3��r�t4� jd d �}|�r�� j5�6d d� t2|� �D �� t� j�d � _t7� _-�n�t*|t8��r�t4� jd d �}|�rވ j5�6dd� t2|� �D �� t� j�d � _t9� _-�n`t*|t:��rNt4� jd d �}|�r4� j5�6dd� t2|� �D �� t� j�d � _t;� _-�n t*|t<��rtt� j�d � _t=� _-�n�t*|t>��r�t� j�d � _t?� _-�n�|t@k�s�|tAk�r� j/t� j�d d� j0 dd�� _Bt� j�d � _tC� _-�nnt*|tD��r2� j/t� j�d d� j0 dd�� _Bt� j�d � _tE� _-�n&t*|tF��rn� j/t� j�d d� j0 dd�� _BtG� _tH� _-n�t*|tI��r�� j/t� j�d d� j0 dd�� _Bt� j�d � _tJ� _-n�|tKtLhk�r�t� j�d � _tM� _-� �/� j� j0� d��g� _(ndt*|tN��rd S tO|d ��s� jPjQ�rHtR� _-� fdd�t2t� j��D �� _(|� _d S t d|� d���� �/� jd� j0 �g� _(d S )NTFr zM`discriminator` can only be used with `Union` type with more than one variantr� c s( g | ] }� � |� j� d t|�� ���qS �rP )�_create_sub_typer� r* )r �trH rG rJ r� � s z-ModelField._type_analysis.<locals>.<listcomp>rz Z_0)rG c s( g | ] \}}� � |� j� d |� ���qS r� �r� r� �r �ir� rH rG rJ r� � s �__get_validators__c S s$ i | ] \}}d |� �t |dd��qS )�list_T��pre�r �r r� � validatorrG rG rJ � <dictcomp>� s z-ModelField._type_analysis.<locals>.<dictcomp>c S s$ i | ] \}}d |� �t |dd��qS )�set_Tr� r� r� rG rG rJ r� � s c S s$ i | ] \}}d |� �t |dd��qS )Z frozenset_Tr� r� r� rG rG rJ r� � s �key_��for_keys�_typec s( g | ] \}}� � |� j� d |� ���qS r� r� r� rH rG rJ r� � s zFields of type "z" are not supported.rP )Sr; r� r' Z inner_typer� r& r r� r � __bound__�__constraints__r r/ r4 �objectr� rN r� r �rer. r1 r- r� r r+ r� r, r r2 r� r3 � TypeError�CollectionsHashable�typer r0 �appendr� r� r� �&prepare_discriminated_union_sub_fields� issubclassr �SHAPE_TUPLE_ELLIPSISr� �Ellipsisr� r� � SHAPE_TUPLE� enumerater r~ r� �update� SHAPE_LISTr � SHAPE_SETr �SHAPE_FROZENSETr � SHAPE_DEQUEr �SHAPE_SEQUENCE�dictr r� � SHAPE_DICTr �SHAPE_DEFAULTDICTr �int� SHAPE_COUNTERr � SHAPE_MAPPINGr �CollectionsIterable�SHAPE_ITERABLEr �hasattrr� Zarbitrary_types_allowed� SHAPE_GENERIC)rI �originZtypes_r� �args�get_validatorsrG rH rJ r� E s � � � " " " " zModelField._type_analysisc C s� | j dk st�| jjtkr dS | jdk s,t�i }t� }| jD ]F}|j}|jtkrV dS t|| j �\}}|� |� |D ] }|||< qtq<|| _ t || j �| _ dS )z� Prepare the mapping <discriminator key> -> <ModelField> and update `sub_fields` Note that this process can be aborted if a `ForwardRef` is encountered N) r� �AssertionErrorr� r� r� r� �setr r8 �addr� r9 r� )rI r� Z all_aliases� sub_fieldr� r` Zdiscriminator_values�discriminator_valuerG rG rJ r� � s z1ModelField.prepare_discriminated_union_sub_fieldsr� )r� r� r� rF c C sJ |r d }ndd� | j �� D �}| �||d | j�\}}| j|||| j|d�S )Nc S s6 i | ].\}}|j r|t|j|jd |j|j|jd��qS )F)�funcr� � each_item�always� check_fields�skip_on_failure)r r r r� r r r )r �kr� rG rG rJ r� s � �z/ModelField._create_sub_type.<locals>.<dictcomp>)r� r� r� r� r� )r� r� r� r� r� )rI r� r� r� r� r� rP rG rG rJ r� s � �zModelField._create_sub_typec C s. t | jdd�p$tdd� | j�� D ��| _| j�� }| jrB| jtkr�t | jdd�}dd� |D �|rf|� nt t | j| j ��d d� |D ��}t |�| _ g | _g | _| jr�| jjr�| j�tt�� |r�| jt d d� |D ��7 _| jt d d� |D ��7 _| j�r| j�tt�� | j�pd| _| j�p&d| _dS ) a Prepare self.pre_validators, self.validators, and self.post_validators based on self.type_'s __get_validators__ and class validators. This method should be idempotent, e.g. it should be safe to call multiple times without mis-configuring the field. r� Fc s s | ] }|j V qd S rL )r �r r� rG rG rJ r� 4 s z1ModelField.populate_validators.<locals>.<genexpr>r� Nc S s g | ]}|j r|jr|j�qS rG �r r� r r rG rG rJ r� < s z2ModelField.populate_validators.<locals>.<listcomp>c S s g | ]}|j r|js|j�qS rG r! r rG rG rJ r� > s c s s | ]}|j s|jr|jV qd S rL r! r rG rG rJ r� I s c s s | ]}|j s|js|jV qd S rL r! r rG rG rJ r� J s )r~ r� �anyr� �valuesr� r� r� r �listr@ r� r r� r� r� r� rf r� r r> r� rA )rI Zclass_validators_r Zv_funcsrG rG rJ r� . s, � � z ModelField.populate_validators)r� �LocStrrY �ValidateReturn)r� r# �locr� rF c C s� | j jtk st�| j jtkrB|d k s(t�td| j� d|j� d���| jrl| � ||||| j�\}}|rl||fS |d kr�t | j �r�n6| j r�| j r�| � ||||| j �S dS n|t t� |�fS | jtkr�| �||||�\}}n�| jtkr�| �||||�\}}n~| jtk�r| �||||�\}}n\| jtk�r:| �||||�\}}n:| jtk�r`| � ||||| j�\}}n| �||||�\}}|�s�| j �r�| � ||||| j �\}}||fS )N�field "�I" not yet prepared so type is still a ForwardRef, you might need to call �.update_forward_refs().)NN)r� r� r� r r r" r� rR r� �_apply_validatorsr0 r� r� r! r% r� r� �_validate_singletonr� �_validate_mapping_liker �_validate_tupler �_validate_iterabler r� �_validate_sequence_like)rI r� r# r' r� r rG rG rJ �validateR s@ � zModelField.validatec C s� t |�sr| jtkr t�� }nH| jttfkr4t�� }n0| jtkrHt� � }n | jt kr\t� � }nt� � }|t ||�fS t|t�r�|n|f}g }g }t|�D ]@\}} ||f�} | �| || |�\} } | r�|�| � q�|�| � q�|r�||fS |} | jtkr�t|�} n�| jt k�rt|�} n�| jtk�r(t|�} n�| jtk�rJt|t|dd�d�} nn| jtk�r�t|t��rlt|�} nLt|t��r�t|�} n6t|t��r�t|�} n t|t��r�t|t|dd�d�} | dfS )z� Validate sequence-like containers: lists, tuples, sets and generators Note that large if-else blocks are necessary to enable Cython optimization, which is why we disable the complexity check above. �maxlenN)r2 )r< r� r r� Z ListErrorr r� � TupleErrorr ZSetErrorr ZFrozenSetErrorZ SequenceErrorr! r� �tupler r, r� r � frozensetr r r~ r r r� )rI r� r# r' r� �e�resultr r� �v_�v_loc�r�ee� convertedrG rG rJ r0 � sR z"ModelField._validate_sequence_likec C s< z t |�}W n& tk r2 |tt�� |�f Y S X |dfS )zw Validate Iterables. This intentionally doesn't validate values to allow infinite generators. N)r� r� r! r� Z IterableError)rI r� r# r' r� �iterablerG rG rJ r/ � s z ModelField._validate_iterablec C s� d }t |�st�� }n*t|�t| j� }}||kr@tj||d�}|rR|t||�fS t|t�r`|n|f}g }g } t t || j��D ]F\} \} } || f�} | j | || |d�\}}|r�| � |� q~|� |� q~| r�|| fS t|�d fS d S )N)� actual_length�expected_length�r' r� ) r< r� r3 r� r� ZTupleLengthErrorr! r� r4 r �zipr1 r� )rI r� r# r' r� r6 r> r? r7 r r� r8 �fieldr9 r: r; rG rG rJ r. � s( zModelField._validate_tuplec C s@ z t |�}W n4 tk r@ } z|t||�f W Y �S d }~X Y nX t|t�rP|n|f}i g }}|�� D ]n\} } |d�} | jj| || |d�\} } | r�|�| � qh|| f�} | � | || |�\}}|r�|�|� qh||| < qh|r�||fS | j t k� r�|d fS | j t k�rt | j|�d fS | j tk�r,t|�d fS | �||�d fS d S )N�__key__r@ )rC )r? r� r! r� r4 r� r� r1 r� r, r� r r r r� r �CollectionCounter�_get_mapping_value)rI r� r# r' r� Zv_iter�excr7 r r r8 r9 Z key_resultZ key_errorsZ value_resultZ value_errorsrG rG rJ r- � s6 $ z!ModelField._validate_mapping_like)�originalr< rF c C sh |j }|tks|tkr|S |tthkr2t| j|�S z ||�W S tk rb td|j���d�Y nX dS )z� When type is `Mapping[KT, KV]` (or another unsupported mapping), we try to avoid coercing to `dict` unwillingly. z Could not convert dictionary to N) r� r r r r r� r� � RuntimeErrorrR )rI rG r< Z original_clsrG rG rJ rE s z ModelField._get_mapping_valuec C s: | j �r"| jd k r"| �||||�S g }| jjr�tt| j��r�| j D ] }|j|j krB|d f S qB| j D ]r}z t ||j �r�|d fW S W qf t k r� t |t|j ��r�|j ||||d�\}}|s�|d f Y S Y qfX qf| j D ]8}|j ||||d�\}}|�r |�|� q�|d f S q�||fS | �||||| j�S d S )Nr@ )r� r� � _validate_discriminated_unionr� Z smart_unionr3 r, r� r� r� r� r� r: r1 r� r+ r� ) rI r� r# r' r� r rB r� �errorrG rG rJ r, s0 z ModelField._validate_singletonc C s� | j d k st�| jd k s t�z>z|| j }W n* tk rV | jjrP|| j }n� Y nX W n� tk r� |tt| j d�|�f Y S tk r� zt || j �}W n2 t tfk r� |tt| j d�|�f Y Y S X Y nX | j d k�r|d k s�t�t d| j � d|j� d���z| j | }W nJ ttfk �rf | j d k �sBt�|tt| j |t| j �d�|�f Y S X t|t��sz|f}|j|||t|j�f�|d�S d S )N)r� r( r) r* )r� r Zallowed_valuesr@ )r� r r� �KeyErrorr� Z allow_population_by_field_namer! r$ r� r~ r� r� r" r� rR r# r$ r� r4 r1 r* r� )rI r� r# r' r� r r rG rG rJ rI L sH & ��� z(ModelField._validate_discriminated_unionrV )r� r# r' r� r� rF c C sh |D ]Z}z||||| | j �}W q tttfk r\ } z|t||�f W Y � S d }~X Y qX q|d fS rL )r� r� r� r r! )rI r� r# r' r� r� r� rF rG rG rJ r+ } s *z ModelField._apply_validatorsc C s8 ddl m} | jtkp6t| jd�p6t| j|ttt t f�S )z\ Whether the field is "complex" eg. env variables should be parsed as JSON. r )� BaseModelZ__pydantic_model__) Zpydantic.v1.mainrL r� r� r r� r; r$ r r5 r )rI rL rG rG rJ � is_complex� s ��zModelField.is_complexc C s� t | j�}| jtkr0dt | jj�� d|� d�}n|| jtkrXd�d�dd� | jD ���}nT| jt kr�| jslt �d�t | j�d�dd� | jD ���}n| jt kr�t | j �|�}| j r�| jt ks�| js�d |� d�}t|�S ) NzMapping[z, �]z Tuple[{}]c s s | ]}t |j�V qd S rL �r* r� �r �frG rG rJ r� � s z+ModelField._type_display.<locals>.<genexpr>z{}[{}]c s s | ]}t |j�V qd S rL rO rP rG rG rJ r� � s z Optional[)r* r� r� r� r� r �format�joinr� r r r� �SHAPE_NAME_LOOKUPr� r5 )rI r� rG rG rJ � _type_display� s � zModelField._type_displayr\ c C st d| j fd| �� fd| jfg}| jsZ| jd k rJ|�dd| jj� d�f� n|�d| jf� | jrp|�d| jf� |S ) Nr� r� r� r_ z <function �>r^ r` ) r� rU r� r_ r� rR r^ r� r` )rI r rG rG rJ r� � s zModelField.__repr_args__)-rR rS rT r� rN rU r r r r r r( �boolr] r| r� � staticmethodr r� � classmethodr� r� �propertyr� r� r� r� r� r� r� r1 r0 r/ r. r- rC r rE r, rI r+ rM r5 rU r� rG rG rG rJ r� l s� #�� + �+� 2 %� � 1 � : � � � #* � 0 � 2 � r� c @ sN e Zd ZdZefdd�eee dd�dd�Zed�dd �Z ee d �d d �Z dS ) �ModelPrivateAttr�r^ r_ N�r_ �r^ r_ rF c C s || _ || _d S rL r\ )rI r^ r_ rG rG rJ r| � s zModelPrivateAttr.__init__rE c C s | j d krt| j�S | � � S rL r� rH rG rG rJ r� � s z ModelPrivateAttr.get_default)�otherrF c C s$ t || j�o"| j| jf|j|jfkS rL )r� r� r^ r_ )rI r_ rG rG rJ �__eq__� s �zModelPrivateAttr.__eq__) rR rS rT r� rN r r r( r| r� rW r` rG rG rG rJ r[ � s r[ r] r^ c C s$ | t k r|dk rtd��t| |d�S )u� Indicates that attribute is only used internally and never mixed with regular fields. Types or values of private attrs are not checked by pydantic and it's up to you to keep them relevant. Private attrs are stored in model __slots__. :param default: the attribute’s default value :param default_factory: callable that will be called when a default value is needed for this attribute If both `default` and `default_factory` are set, an error is raised. Nr� r] )rN r� r[ r\ rG rG rJ � PrivateAttr� s �ra c @ s e Zd ZdZdS )r� zV Used to postpone field preparation, while creating recursive generic models. N)rR rS rT r� rG rG rG rJ r� � s r� )r� �valrF c C s t | �o|tk ot|t� S rL )r- rN r� r] )r� rb rG rG rJ � is_finalvar_with_default_val� s rc )~r� r� � collectionsr rD r r �collections.abcr r r� r r �typingr r r r r r r r r r r r r r r r r r r �typing_extensionsr r Z pydantic.v1r r� Z pydantic.v1.class_validatorsr r r Zpydantic.v1.error_wrappersr! Zpydantic.v1.errorsr" r# r$ r% Zpydantic.v1.typesr& r' Zpydantic.v1.typingr( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 Zpydantic.v1.utilsr5 r6 r7 r8 r9 r: r; r< r= Zpydantic.v1.validatorsr> r? r@ rA r� rB �__annotations__rC rD rN rV Zpydantic.v1.configrW rX rY rZ r[ r\ r& r rU r% rW r� r] �floatr� r� r r r r r� r r r r r r r r rT r� r� r[ ra r� rc rG rG rG rJ �<module> s \ <, }��� q � N���