HEX

File: //home/arjun/.local/lib/python3.10/site-packages/pydantic/v1/__pycache__/utils.cpython-310.pyc
o

=��gUe�@sxUddlZddlZddlZddlmZmZmZddlmZddl	m
Z
mZddlm
Z
mZmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'ddl(m)Z)dd	l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2dd
l3m4Z4er�ddl5m6Z6ddl7m8Z8dd
l9m:Z:ddl;m<Z<ddl=m>Z>ddl?m@Z@ddl*mAZAmBZBmCZCmDZDmEZEee%ee"ee"eFefe"eFeeffZGdZHdZIeJeKeLeFeMeNeOe+ee
eejPeeeQjReSjRhZTe!e#eeUd<eVeWeXeYeZeeehZ[e!e#eeUd<deFdefdd�Z\dd�de%eFdeJdeFfdd�Z]dedeMfd d!�Z^d"ee#d#d$eFddfd%d&�Z_d'ed(e%e#ee"e#ed)fdfdeMfd*d+�Z`d,ed(e%e#ee"e#ed)fdfdeMfd-d.�ZadeMfd/d0�Zbd1eFdeMfd2d3�Zce$d4�Zdd5eedefd6eedefdeedeffd7d8�Zed5eeefd9eddfd:d;�Zfd<d=�d>eKd?eKd@eKdeMfdAdB�ZgdCedDdEeeFdFfdGe#dHddIfdJdK�ZhdLe%e#d#e#dMfde#d#fdNdO�ZidPeFdeFfdQdR�ZjdPeFdeFfdSdT�Zke$dU�ZleFdV�dWe%eele"eld)ffdXeelgeFfdeelfdYdZ�ZmGd[d\�d\eF�ZnGd]d^�d^�ZoGd_d`�d`eo�ZpGdadb�dbeo�ZqGdcdd�dd�Zrdedfdgdhdidjdkdldm�ZsdndodeFfdpdq�Zte$dr�ZudLeudeufdsdt�ZvdueFdeMfdvdw�Zwhdx�ZxdueFdeMfdydz�Zyez�Z{d{eed|eedeMfd}d~�Z|dLedeFdefd�d��Z}d�eeFd�eFdeFfd�d��Z~d�ed�eFde"eFe"eFd)fffd�d��Zd�e#ed�eFde"eFe"e"eFd)fd)fffd�d��Z�dS)��N)�OrderedDict�defaultdict�deque)�deepcopy)�islice�zip_longest)�BuiltinFunctionType�CodeType�FunctionType�
GeneratorType�
LambdaType�
ModuleType)�
TYPE_CHECKING�AbstractSet�Any�Callable�
Collection�Dict�	Generator�Iterable�Iterator�List�Mapping�NoReturn�Optional�Set�Tuple�Type�TypeVar�Union)�	Annotated)�ConfigError)�NoneType�
WithArgsTypes�all_literal_values�display_as_type�get_args�
get_origin�is_literal_type�is_union)�version_info)�	Signature)�Path)�
BaseConfig)�	Dataclass)�
ModelField��	BaseModel)�AbstractSetIntStr�
DictIntStrAny�IntStr�MappingIntStrAny�ReprArgs)�
import_string�
sequence_like�validate_field_name�lenient_isinstance�lenient_issubclass�
in_ipython�is_valid_identifier�deep_update�update_not_none�almost_equal_floats�	get_model�to_camel�to_lower_camel�is_valid_field�smart_deepcopy�PyObjectStr�Representation�
GetterDict�
ValueItemsr*�ClassAttribute�	path_type�ROOT_KEY�get_unique_discriminator_alias�"get_discriminator_alias_and_values�DUNDER_ATTRIBUTES�__root__�IMMUTABLE_NON_COLLECTIONS_TYPES�BUILTIN_COLLECTIONS�dotted_path�returnc
Cs�ddlm}z
|�d��dd�\}}Wnty(}z	td|�d��|�d}~ww||�}zt||�WStyK}ztd	|�d
|�d��|�d}~ww)z�
    Stolen approximately from django. Import a dotted module path and return the attribute/class designated by the
    last name in the path. Raise ImportError if the import fails.
    r)�
import_module� �.��"z!" doesn't look like a module pathNzModule "z" does not define a "z" attribute)�	importlibrU�strip�rsplit�
ValueError�ImportError�getattr�AttributeError)rSrU�module_path�
class_name�e�module�re�D/home/arjun/.local/lib/python3.10/site-packages/pydantic/v1/utils.pyr7zs����r7�P)�max_len�vrhcCs�t�dt�t|t�rt|�|dkr|d|d�d��Sz|��}Wnty4|j�|�}Ynwt|�|krE|d|d�d}|S)z`
    Truncate a value and add a unicode ellipsis (three dots) to the end if it was too long
    z:`truncate` is no-longer used by pydantic and is deprecated�N�u…rX)	�warnings�warn�DeprecationWarning�
isinstance�str�len�__repr__�	TypeError�	__class__)rirhrererf�truncate�s�rucCst|ttttttf�S�N)ro�list�tuple�set�	frozensetrr�rirererfr8�sr8�basesr1�
field_namecCs0|D]}t||d�rtd|�d|�d���qdS)zZ
    Ensure that the field's name does not shadow an existing attribute of the model.
    NzField name "zI" shadows a BaseModel attribute; use a different field name with "alias='z'".)r_�	NameError)r|r}�baserererfr9�s����r9�o�class_or_tuple.cCs"zt||�WStyYdSw�NF)rors)r�r�rererfr:�s
�r:�clscCs8zt|t�o
t||�WStyt|t�rYdS�wr�)ro�type�
issubclassrsr#)r�r�rererfr;�s
�r;cCs$ztd�WdStyYdSw)zU
    Check whether we're in an ipython environment, including jupyter notebooks.
    �__IPYTHON__FT)�evalr~rerererfr<�s
��r<�
identifiercCs|��o	t�|�S)z�
    Checks that a string is a valid identifier and not a Python keyword.
    :param identifier: The identifier to test.
    :return: True if the identifier is valid.
    )�isidentifier�keyword�	iskeyword)r�rererfr=�sr=�KeyType�mapping�updating_mappingscGsd|��}|D])}|��D]"\}}||vr*t||t�r*t|t�r*t|||�||<q|||<qq|Srv)�copy�itemsro�dictr>)r�r��updated_mapping�updating_mapping�krirererfr>�s 
�r>�updatecKs|�dd�|��D��dS)NcSsi|]\}}|dur||�qSrvre)�.0r�rirererf�
<dictcomp>�sz#update_not_none.<locals>.<dictcomp>)r�r�)r�r�rererfr?�sr?g:�0�yE>)�delta�value_1�value_2r�cCst||�|kS)z4
    Return True if two floats are almost equal
    )�abs)r�r�r�rererfr@�sr@�init).N�fieldsr/�configr-r+cCstddlm}m}m}ddlm}||�j��}i}d}	d}
t|dd�D]}|j	|j
ur.|}	q#|||j<q#|	rw|j}|�
�D]9\}
}|j}|
|vsL||vrMq=t|�s]|rZt|
�rZ|
}nd}
q=|jsed|jini}|||jfd	|ji|��||<q=|j|jurd}
|	r�|
r�d
|jfd|j
fg}dd
�|D�|kr�d}n|	j}||vr�|d7}||vs�|	j|d�||<|t|���dd�S)z:
    Generate signature for model based on its fields
    r)�	Parameterr+�	signature)�ExtraNFrXT�default�
annotation�__pydantic_self__�datacSsg|]}|j|jf�qSre)�name�kind)r��prererf�
<listcomp>�z,generate_model_signature.<locals>.<listcomp>�
extra_data�_�r�)�
parameters�return_annotation)�inspectr�r+r��pydantic.v1.configr�r��valuesrr��VAR_KEYWORDr��allow_population_by_field_namer��aliasr=�requiredr��KEYWORD_ONLYr��extra�allow�POSITIONAL_OR_KEYWORD�replacerw)r�r�r�r�r+r�r��present_params�
merged_params�var_kw�
use_var_kw�param�allow_namesr}�field�
param_name�kwargs�default_model_signature�var_kw_namerererf�generate_model_signature�sX�����r��objr.cCsDddlm}z|j}Wnty|}Ynwt||�s td��|S)Nrr0z7Unsupported type, must be either BaseModel or dataclass)�pydantic.v1.mainr1�__pydantic_model__r`r�rs)r�r1�	model_clsrererfrA-s
�
rA�stringcCsd�dd�|�d�D��S)N�css�|]}|��VqdSrv)�
capitalize)r��wordrererf�	<genexpr>;s�zto_camel.<locals>.<genexpr>r�)�join�split)r�rererfrB:�rBcCs4t|�dkrt|�}|d��|dd�S|��S)NrXr)rqrB�lower)r��
pascal_stringrererfrC>srC�T)�name_factory�
input_listr�cCsJg}g}|D]}||�}||vr|�|�|�|�q|||�|�<q|S)z�
    Make a list unique while maintaining order.
    We update the list if another one with the same name is set
    (e.g. root validator overridden in subclass)
    )�append�index)r�r��result�result_namesri�v_namerererf�unique_listHs

r�c@seZdZdZdefdd�ZdS)rFz�
    String class where repr doesn't include quotes. Useful with Representation when you want to return a string
    representation of something that valid (or pseudo-valid) python.
    rTcC�t|�Srv)rp��selfrererfrreszPyObjectStr.__repr__N)�__name__�
__module__�__qualname__�__doc__rprrrerererfrF_srFc	@s�eZdZUdZe�Zeedfed<ddd�Z	defdd	�Z
d
edefdd�Zd
ee
ge
fde
dee
ddffdd�Zdefdd�Zdefdd�Zddd�ZdS)rGz�
    Mixin to provide __str__, __repr__, and __pretty__ methods. See #884 for more details.

    __pretty__ is used by [devtools](https://python-devtools.helpmanual.io/) to provide human readable representations
    of objects.
    .�	__slots__rTr6cs"�fdd��jD�}dd�|D�S)a6
        Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.

        Can either return:
        * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
        * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
        c3s�|]
}|t�|�fVqdSrv)r_)r��sr�rerfr�{��z/Representation.__repr_args__.<locals>.<genexpr>cSs g|]\}}|dur||f�qSrvre�r��arirererfr�|s z0Representation.__repr_args__.<locals>.<listcomp>)r�)r��attrsrer�rf�
__repr_args__sszRepresentation.__repr_args__cCs|jjS)zA
        Name of the instance's class, used in __repr__.
        )rtr�r�rererf�
__repr_name__~szRepresentation.__repr_name__�join_strcCs|�dd�|��D��S)Ncss2�|]\}}|durt|�n|�d|��VqdS)N�=)�reprr�rererfr��s�0z.Representation.__repr_str__.<locals>.<genexpr>)r�r�)r�r�rererf�__repr_str__�szRepresentation.__repr_str__�fmtr�Ncks`�|��dVdV|��D]\}}|dur|dV||�VdVdVqdVdVdS)	z�
        Used by devtools (https://python-devtools.helpmanual.io/) to provide a human readable representations of objects
        �(rXNr��,r����))r�r�)r�r�r�r��valuerererf�
__pretty__�s�


zRepresentation.__pretty__cCs
|�d�S)NrV)r�r�rererf�__str__��
zRepresentation.__str__cCs|���d|�d��d�S)Nr��, r�)r�r�r�rererfrr�r�zRepresentation.__repr__�RichReprResultccs2�|��D]\}}|dur|Vq||fVqdS)zGet fields for Rich libraryN)r�)r�r��
field_reprrererf�
__rich_repr__�s��zRepresentation.__rich_repr__�rTr6)rTr�)r�r�r�r�rxr�rrp�__annotations__r�r�r�rrrr�r�rrr�rerererfrGis

*rGc@s�eZdZdZdZdefdd�Zdedefdd	�Zd%dededefdd
�Z	de
efdd�Zdeefdd�Z
deefdd�Zdeeeeffdd�Zdeefdd�Zdefdd�Zdedefdd�Zdedefdd�Zd&d!d"�Zdefd#d$�Zd
S)'rHz�
    Hack to make object's smell just enough like dicts for validate_model.

    We can't inherit from Mapping[str, Any] because it upsets cython so we have to implement all methods ourselves.
    ��_objr�cCs
||_dSrvr)r�r�rererf�__init__�r�zGetterDict.__init__�keyrTc
Cs2zt|j|�WSty}zt|�|�d}~wwrv)r_rr`�KeyError)r�rrcrererf�__getitem__�s
��zGetterDict.__getitem__Nr�cCst|j||�Srv)r_r)r�rr�rererf�get��zGetterDict.getcCst�S)zn
        We don't want to get any other attributes of obj if the model didn't explicitly ask for them
        )ryr�rererf�
extra_keys�szGetterDict.extra_keyscCr�)z�
        Keys of the pseudo dictionary, uses a list not set so order information can be maintained like python
        dictionaries.
        )rwr�rererf�keys�szGetterDict.keyscs�fdd��D�S)Ncsg|]}�|�qSrere�r�r�r�rerfr��sz%GetterDict.values.<locals>.<listcomp>rer�rer�rfr���zGetterDict.valuesccs �|D]
}||�|�fVqdSrv)r)r�r�rererfr��s��zGetterDict.itemsccs&�t|j�D]
}|�d�s|VqdS)Nr�)�dirr�
startswith)r�r�rererf�__iter__�s�
��zGetterDict.__iter__cCstdd�|D��S)Ncss�|]}dVqdS)rXNre)r�r�rererfr��s�z%GetterDict.__len__.<locals>.<genexpr>)�sumr�rererf�__len__�rzGetterDict.__len__�itemcCs||��vSrv)r
�r�rrererf�__contains__��zGetterDict.__contains__�othercCst|�t|���kSrv)r�r�)r�rrererf�__eq__�szGetterDict.__eq__r6cCsdt|�fgSrv)r�r�rererfr��rzGetterDict.__repr_args__cCsdt|j��d�S)NzGetterDict[�])r%rr�rererfr��rzGetterDict.__repr_name__rvr�)r�r�r�r�r�rrrprrrr	rr
r�rrr�r�intr�boolrrr�r�rerererfrH�s 
rHc
@s�eZdZdZdZdededddfdd	�Zd
edefdd�Z	d
edefd
d�Z
dddeedfdd�Zddde
ddfdd�Zed(dedededefdd��Zededddfdd��Zededefd d!��Zed"edefd#d$��Zd)d&d'�ZdS)*rIzY
    Class for more convenient calculation of excluded or included fields on values.
    )�_items�_typer�r�)r2r5rTNcCs2|�|�}t|ttf�r|�|t|��}||_dSrv)�
_coerce_itemsrorwrx�_normalize_indexesrqr)r�r�r�rererfr�s

zValueItems.__init__rcCs|�|j�|��S)z`
        Check if item is fully excluded.

        :param item: key or index of a value
        )�is_truerrrrererf�is_excluded�szValueItems.is_excludedcCs
||jvS)zh
        Check if value is contained in self._items

        :param item: key or index of value
        �rrrererf�is_included�s
zValueItems.is_includedrcr4cCs|j�|�}|�|�s
|SdS)z�
        :param e: key or index of element on value
        :return: raw values for element if self._items is dict and contain needed element
        N)rrr)r�rcrrererf�for_elementszValueItems.for_elementr5�v_lengthr3c	Csi}d}|��D]F\}}t|t�s&t|t�s&|�|�s&td|�d|j����|dkr0|�|�}qt|t�s9td��|dkrA||n|}|�	||�
|��||<q|sS|S|�|�rgt|�D]}|�|d�q\|St|�D]}|�|i�}|�|�s�|�	||�||<qk|S)af
        :param items: dict or set of indexes which will be normalized
        :param v_length: length of sequence indexes of which will be

        >>> self._normalize_indexes({0: True, -2: True, -1: True}, 4)
        {0: True, 2: True, 3: True}
        >>> self._normalize_indexes({'__all__': True}, 4)
        {0: True, 1: True, 2: True, 3: True}
        Nz,Unexpected type of exclude value for index "z" �__all__z�Excluding fields from a sequence of sub-models or dicts must be performed index-wise: expected integer keys or keyword "__all__"r.)
r�rorrrrsrt�
_coerce_valuer�merger�range�
setdefault)	r�r�r$�normalized_items�	all_items�iri�normalized_i�normalized_itemrererfrs4

�

�zValueItems._normalize_indexesFr�override�	intersectcs�|����|�����dur�S|���s�dur�S|���r&|r$�S�S|r;�fdd��D��fdd��D�}n
t���fdd��D�}i}|D]}|j��|���|�|d�}|durd|||<qL|S)ae
        Merge a ``base`` item with an ``override`` item.

        Both ``base`` and ``override`` are converted to dictionaries if possible.
        Sets are converted to dictionaries with the sets entries as keys and
        Ellipsis as values.

        Each key-value pair existing in ``base`` is merged with ``override``,
        while the rest of the key-value pairs are updated recursively with this function.

        Merging takes place based on the "union" of keys if ``intersect`` is
        set to ``False`` (default) and on the intersection of keys if
        ``intersect`` is set to ``True``.
        Nc�g|]}|�vr|�qSrerer)r/rerfr�Mr�z$ValueItems.merge.<locals>.<listcomp>cr1rerer�rrerfr�Mr�csg|]}|�vr|�qSrererr2rerfr�Or�)r0)r&rrwr'r)r�rr/r0�
merge_keys�mergedr��merged_itemre)rr/rfr'2s$


&�zValueItems.mergecCsJt|t�r	|St|t�rt�|d�}|St|dd�}t|d|���|S)N.rtz???z!Unexpected type of exclude value )rorrr��fromkeysr_�assert_never)r�rbrererfrYs
	
���zValueItems._coerce_itemscCs |dus	|�|�r|S|�|�Srv)rr)r�r�rererfr&gs
zValueItems._coerce_valuericCs|dup|duS)NT.rer{rererfrmszValueItems.is_truer6cCsd|jfgSrvr!r�rererfr�qrzValueItems.__repr_args__)Fr�)r�r�r�r�r�rrrrr r"rr#rr�classmethodr'�staticmethodrr&rr�rerererfrI�s"	'&
rIc@sDeZdZdZdZdededdfdd�Zd	ed
eeddfdd�Z	dS)
rJz1
    Hide class attribute from its instances
    �r�r�r�r�rTNcCs||_||_dSrvr:)r�r�r�rererfrs
zClassAttribute.__init__�instance�ownercCs&|dur|jSt|j�d|j�d���)Nz attribute of z is class-only)r�r`r�r�)r�r;r<rererf�__get__�szClassAttribute.__get__)
r�r�r�r�r�rprrrr=rerererfrJus
rJ�	directory�filezmount point�symlinkzblock devicezchar device�FIFO�socket)�is_dir�is_file�is_mount�
is_symlink�is_block_device�is_char_device�is_fifo�	is_socketr�r,cCs:|��sJd��t��D]\}}t||��r|SqdS)z0
    Find out what sort of thing a path is.
    zpath does not exist�unknown)�exists�
path_typesr�r_)r��methodr�rererfrK�s�rK�Objc
Csj|j}|tvr	|Sz|s|tvr!|tur|WS|��WSWt|�SWt|�Stttfy4Yt|�Sw)z�
    Return type as is for immutable built-in types
    Use obj.copy() for built-in empty collections
    Use copy.deepcopy() for non-empty collections and unknown objects
    )	rtrQrRrxr�rsr]�RuntimeErrorr)r��obj_typerererfrE�s����rEr�cCs|�d�sdSt|kS)Nr�T)rrLr�rererfrD�s
rD>r�r�r��
__classcell__�__orig_bases__�__orig_class__rcCst|�o|tvSrv)rDrOr�rererf�is_valid_private_name�rrU�left�rightcCs*t||td�D]\}}||urdSqdS)a
    Check that the items of `left` are the same objects as those in `right`.

    >>> a, b = object(), object()
    >>> all_identical([a, b, a], [a, b, a])
    True
    >>> all_identical([a, b, [a]], [a, b, [a]])  # new list object, while "equal" is not "identical"
    False
    )�	fillvalueFT)r�_EMPTY)rVrW�	left_item�
right_itemrererf�
all_identical�s

�r\�msgcCst|��)z�
    Helper to make sure that we have covered all possible types.

    This is mostly useful for ``mypy``, docs:
    https://mypy.readthedocs.io/en/latest/literal_types.html#exhaustive-checks
    )rs)r�r]rererfr7�sr7�all_aliases�discriminator_keycCs<t|�}t|�dkrtd|�dd�t|���d���|��S)zNValidate that all aliases are the same and if that's the case return the aliasrXzAliases for discriminator z must be the same (got r�r�)ryrqr!r��sorted�pop)r^r_�unique_aliasesrererfrM�s�rM�tpc
CsVt|dd�}t|�turt|�d}t|d�r|j}tt|��r2t||�\}}|tdd�|D��fS|r[|j	t
j}t||�\}}tt
|��dkrUtd|�d	t|�����||dfSz|j	|j}Wn-tyy}z
td
|j�d��|�d}~wty�}ztd
|j�d|���|�d}~wwt|�s�td|�d|j�d���|j	|jt|�fS)z�
    Get alias and all valid values in the `Literal` type of the discriminator field
    `tp` can be a `BaseModel` class or directly an `Annotated` `Union` of many.
    �__custom_root_type__Frr�css�|]
}|D]}|VqqdSrvre)r�r�rirererfr�r�z5get_discriminator_alias_and_values.<locals>.<genexpr>rXzField z& is not the same for all submodels of zType z* is not a valid `BaseModel` or `dataclass`NzModel z% needs a discriminator field for key z
 of model z needs to be a `Literal`)r_r'r r&�hasattrr�r)�_get_union_alias_and_all_valuesrx�
__fields__rL�type_rqryr!r%r`rsr�rr(r�r$)rcr_�
is_root_modelr��
all_values�
union_type�t_discriminator_typercrererfrN�s8
����rNrkcs0�fdd�t|�D�}t|�\}}t|��|fS)Ncsg|]}t|���qSre)rN)r��t�r_rerfr�!sz3_get_union_alias_and_all_values.<locals>.<listcomp>)r&�ziprM)rkr_�zipped_aliases_valuesr^rjrernrfrfsrf)�r�rl�weakref�collectionsrrrr�r�	itertoolsrr�typesrr	r
rrr
�typingrrrrrrrrrrrrrrrrrr�typing_extensionsr �pydantic.v1.errorsr!�pydantic.v1.typingr"r#r$r%r&r'r(r)�pydantic.v1.versionr*r�r+�pathlibr,r�r-�pydantic.v1.dataclassesr.�pydantic.v1.fieldsr/r�r1r2r3r4r5r6rpr�r%rLr�float�complexr�bytesr��ref�NotImplementedrt�EllipsisrQrrwryrxrzr�rRr7rur8r9r:r;r<r=r�r>r?r@r�rArBrCr�r�rFrGrHrIrJrMrKrOrErDrOrU�objectrYr\r7rMrNrfrerererf�<module>s�
 P(
*�� 00		. �
��
�&A
���
�
<>�
&
)���