U
    ¶ÜŸj»K  ã                   @   sÆ  U d dl Z d dlZd dlmZ d dlmZ d dlmZmZmZmZ	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZmZmZm Z!m"Z# zd dlm$Z% W n  e&k
rÖ   d dlm'Z% Y nX zd dlm(Z) W n e&k
�r   d	Z)Y nX zd d
l*m+Z, W n e&k
�r.   d	Z,Y nX e j-dk �rReeeedœdd„Z.neeeedœdd„Z.e j-dk �rxeZ/ndjeeeedœdd„Z/edƒZ0e	def Z1e	g ef Z2e	de0f Z3ddhZ4ehZ5ee e6d< e7edƒ�rìe5 8ej¡ e j-dk �ree eee  dœdd„Z9n(d dlm9Z: ee eee  dœdd„Z9e j-dk �rtd d lm;Z; ee eedf dœd!d"„Z<nDd d#lm<Z= ee eedf dœd$d%„Z>ee eedf dœd&d"„Z<e j-dk �rÞee ee dœd'd(„Z?n0d d)lm@Z@ d d*lmAZA ee ee dœd+d(„Z?e j-d,k �r:eee  eBdœd-d.„ZCe)fZDn8d dl*Z*d dlZeee  eBdœd/d.„ZCej;e*j(e*j+fZDeeEef ZFe�r>d d0lGmHZH eeeEef ddf ZIeeEef ZJeeef ZKeeE ZLeeE ZMeeNeEf ZOeeO ZPeeOef ZQeeOef ZRee1ddf ZSeeeeE ef  ZTd1ZUeU�r0eVe ZWneVeeef ZWd2ZXdjYZZdeZed fZ[eeeef e6d3< e j-dk �r†eeBd4œd5d6„Z\n6e j-dd7… dk�r¬eeBd4œd8d6„Z\neeBd4œd9d6„Z\ee eEd:œd;d<„Z]eeEee f eeE eeEee f d=œd>d?„Z^ee eBd4œd@dA„Z_ee eBd4œdBdC„Z`ee eedf d4œdDdE„Zaee eedf d4œdFdG„Zbee eBd4œdHdI„Zcee eBd4œdJdK„ZdeeBd4œdLdM„ZeeeBd4œdNdO„ZfedPeEƒZgee eBd4œdQdR„Zhee ee d4œdSdT„Zieee  eBd:œdUdV„Zjeee  eBd:œdWdX„Zkee eBdYœdZd[„Zlee eBdYœd\d]„Zmd^eedd_œd`da„Zndkee ed^ eeee eEef e1f dbeeeo df ddcœddde„Zpee edeBee f d4œdfdg„Zqeee dœdhdi„ZrdS )lé    N)ÚCallable)ÚPathLike)ÚTYPE_CHECKINGÚAbstractSetÚAnyr   ÚClassVarÚDictÚ
ForwardRefÚ	GeneratorÚIterableÚListÚMappingÚNewTypeÚOptionalÚSequenceÚSetÚTupleÚTypeÚTypeVarÚUnionÚ
_eval_typeÚcastÚget_type_hints)Ú	AnnotatedÚFinalÚLiteralÚNotRequiredÚRequired)Ú_TypingBase)Ú_Final)ÚGenericAlias© )Ú	UnionType©é   é	   )Útype_ÚglobalnsÚlocalnsÚreturnc                 C   s   |   ||¡S ©N)Ú	_evaluate©r&   r'   r(   r!   r!   ú6/tmp/pip-unpacked-wheel-3sxb4rlg/pydantic/v1/typing.pyÚevaluate_forwardref:   s    r.   c                 C   s   t t| ƒj||tƒ d�S )N)Úrecursive_guard)r   r   r+   Úsetr,   r!   r!   r-   r.   ?   s    )Úobjr'   r(   r)   c                 C   s   t | ||dd�S )NT)Úinclude_extras)r   )r1   r'   r(   r!   r!   r-   Úget_all_type_hintsO   s    r3   Ú_T.ZAnnotatedMetaÚ_AnnotatedAliasÚLITERAL_TYPESr   ©r$   é   )Útr)   c                 C   s(   t | ƒjtkrttt tƒS t| dd ƒS )NÚ
__origin__)ÚtypeÚ__name__ÚAnnotatedTypeNamesr   r   r   r   Úgetattr)r9   r!   r!   r-   Ú
get_originh   s    r?   )r?   )Útpr)   c                 C   s0   t | ƒjtkrttt tƒS t| ƒp.t| ddƒS )a4  
        We can't directly use `typing.get_origin` since we need a fallback to support
        custom generic classes like `ConstrainedList`
        It should be useless once https://github.com/cython/cython/issues/3537 is
        solved and https://github.com/pydantic/pydantic/pull/1753 is merged.
        r:   N)	r;   r<   r=   r   r   r   r   Ú_typing_get_originr>   ©r@   r!   r!   r-   r?   q   s    )Ú_GenericAliasc                 C   sl   t | ƒjtkr| j| j S t| tƒr`| j}| jtkr\|r\|d t	k	r\t
|dd… ƒ|d f}|S t| ddƒS )z²Compatibility version of get_args for python 3.7.

        Mostly compatible with the python 3.8 `typing` module version
        and able to handle almost all use cases.
        r   NéÿÿÿÿÚ__args__r!   )r;   r<   r=   rE   Ú__metadata__Ú
isinstancerC   r:   r   ÚEllipsisÚlistr>   )r9   Úresr!   r!   r-   Úget_args€   s    
rK   ©rK   c                 C   s\   t | dƒrtf| j S z,| td ks:tjdkr@| td kr@W dS W n tk
rV   Y nX dS )aI  
        In python 3.9, `typing.Dict`, `typing.List`, ...
        do have an empty `__args__` by default (instead of the generic ~T for example).
        In order to still support `Dict` for example and consider it as `Dict[Any, Any]`,
        we retrieve the `_nparams` value that tells us how many parameters it needs.
        Ú_nparamsr!   r#   )r!   )Úhasattrr   rM   r   ÚsysÚversion_infoÚtupleÚ	TypeErrorrB   r!   r!   r-   Ú_generic_get_args’   s    
"
rS   c                 C   s6   t | ƒjtkr| j| j S t| ƒp4t| ddƒp4t| ƒS )aÆ  Get type arguments with all substitutions performed.

        For unions, basic simplifications used by Union constructor are performed.
        Examples::
            get_args(Dict[str, int]) == (str, int)
            get_args(int) == ()
            get_args(Union[int, Union[T, int], str][int]) == (int, str)
            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
            get_args(Callable[[], T][int]) == ([], int)
        rE   r!   )r;   r<   r=   rE   rF   Ú_typing_get_argsr>   rS   rB   r!   r!   r-   rK   ¦   s    c                 C   s   | S )zÛPython 3.9 and older only supports generics from `typing` module.
        They convert strings to ForwardRef automatically.

        Examples::
            typing.List['Hero'] == typing.List[ForwardRef('Hero')]
        r!   rB   r!   r!   r-   Úconvert_generics¹   s    rU   )Ú_UnionGenericAlias)r5   c                    s¼   t ˆ ƒ}|rtˆ dƒsˆ S tˆ ƒ}|tkrDtt|d ƒ|dd… ƒS t‡ fdd„|D ƒƒ}||krfˆ S tˆ tƒrzt||ƒS tˆ t	ƒrŽt
||ƒS ztˆ d|ƒ W n tk
r²   Y nX ˆ S dS )aì  
        Recursively searches for `str` type hints and replaces them with ForwardRef.

        Examples::
            convert_generics(list['Hero']) == list[ForwardRef('Hero')]
            convert_generics(dict['Hero', 'Team']) == dict[ForwardRef('Hero'), ForwardRef('Team')]
            convert_generics(typing.Dict['Hero', 'Team']) == typing.Dict[ForwardRef('Hero'), ForwardRef('Team')]
            convert_generics(list[str | 'Hero'] | int) == list[str | ForwardRef('Hero')] | int
        rE   r   é   Nc                 3   s2   | ]*}t |tƒr"t ˆ tƒr"t|ƒnt|ƒV  qd S r*   )rG   ÚstrÚTypingGenericAliasr	   rU   )Ú.0ÚargrB   r!   r-   Ú	<genexpr>Ü   s   ÿz#convert_generics.<locals>.<genexpr>)r?   rN   rK   r   r5   rU   rQ   rG   rY   ÚTypesUnionTyperV   ÚsetattrÚAttributeError)r@   ÚoriginÚargsZ	convertedr!   rB   r-   rU   Ç   s(    
þ



©r$   é
   c                 C   s   | t kS r*   )r   rB   r!   r!   r-   Úis_unionò   s    rd   c                 C   s   | t kp| tjkS r*   )r   Útypesr"   rB   r!   r!   r-   rd   û   s    )Ú
ModelFieldF)'ÚAnyCallableÚNoArgAnyCallableÚNoneTypeÚis_none_typeÚdisplay_as_typeÚresolve_annotationsÚis_callable_typeÚis_literal_typeÚall_literal_valuesÚis_namedtupleÚis_typeddictÚis_typeddict_specialÚis_new_typeÚnew_type_supertypeÚis_classvarÚis_finalvarÚupdate_field_forward_refsÚupdate_model_forward_refsÚTupleGeneratorÚ
DictStrAnyÚDictAnyÚSetStrÚListStrÚIntStrÚAbstractSetIntStrÚDictIntStrAnyÚCallableGeneratorÚReprArgsÚAnyClassMethodr�   ÚWithArgsTypesrK   r?   Úget_sub_typesÚtyping_baser3   rd   ÚStrPathÚMappingIntStrAnyÚ
NONE_TYPES)r&   r)   c                 C   s   | t kS r*   ©r‰   ©r&   r!   r!   r-   rj   R  s    rj   é   c                 C   s0   t D ]}| |kr dS qt| ƒr,t| ƒdkS dS )NTr*   F)r‰   rn   ro   )r&   Z	none_typer!   r!   r-   rj   W  s    c                 C   s   | t kS r*   rŠ   r‹   r!   r!   r-   rj   d  s    )Úvr)   c                 C   s˜   t | tƒs$t | tƒs$t | tƒs$| j} tt| ƒƒrLdd tt	t
| ƒƒ¡› d�S t | tƒrft| ƒ dd¡S z| jW S  tk
r’   t| ƒ dd¡ Y S X d S )NzUnion[z, ú]ztyping.Ú )rG   r†   r„   r;   Ú	__class__rd   r?   ÚjoinÚmaprk   rK   rX   Úreplacer<   r_   ©r�   r!   r!   r-   rk   h  s    
rk   )Úraw_annotationsÚmodule_namer)   c              	   C   sÞ   d}|r2zt j| }W n tk
r*   Y nX |j}i }|  ¡ D ]š\}}t|tƒrŽdt j  krfdksrn t jdkr‚t|ddd�}nt|dd�}z,t jd	kr¬t	||dd
d�}nt	||dƒ}W n t
k
rÎ   Y nX |||< q>|S )z‚
    Partially taken from typing.get_type_hints.

    Resolve string or ForwardRef annotations into type objects if possible.
    Nrb   )r$   r%   r8   )r$   rc   rW   FT)Úis_argumentÚis_class)r—   )r$   é   r!   )Útype_params)rO   ÚmodulesÚKeyErrorÚ__dict__ÚitemsrG   rX   rP   r	   r   Ú	NameError)r•   r–   Úbase_globalsÚmoduleÚannotationsÚnameÚvaluer!   r!   r-   rl   z  s*    
"

rl   c                 C   s   | t kpt| ƒt kS r*   )r   r?   r‹   r!   r!   r-   rm   �  s    rm   c                 C   s   t d k	ot| ƒtkS r*   )r   r?   r6   r‹   r!   r!   r-   rn   ¡  s    rn   c                 C   s   t | ƒS r*   rL   r‹   r!   r!   r-   Úliteral_values¥  s    r¥   c                 C   s(   t | ƒs| fS t| ƒ}tdd„ |D ƒƒS )zÐ
    This method is used to retrieve all Literal values as
    Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586)
    e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]`
    c                 s   s    | ]}t |ƒD ]
}|V  qqd S r*   )ro   )rZ   r¤   Úxr!   r!   r-   r\   ³  s     
  z%all_literal_values.<locals>.<genexpr>)rn   r¥   rQ   )r&   Úvaluesr!   r!   r-   ro   ©  s    ro   c                 C   s    ddl m} || tƒot| dƒS )zy
    Check if a given class is a named tuple.
    It can be either a `typing.NamedTuple` or `collections.namedtuple`
    r   ©Úlenient_issubclassÚ_fields)Úpydantic.v1.utilsr©   rQ   rN   ©r&   r©   r!   r!   r-   rp   ¶  s    rp   c                 C   s    ddl m} || tƒot| dƒS )zÉ
    Check if a given class is a typed dict (from `typing` or `typing_extensions`)
    In 3.10, there will be a public method (https://docs.python.org/3.10/library/typing.html#typing.is_typeddict)
    r   r¨   Ú	__total__)r«   r©   ÚdictrN   r¬   r!   r!   r-   rq   À  s    rq   c                 C   s   | t kp| tkS r*   )ÚTypedDictRequiredÚTypedDictNotRequiredr‹   r!   r!   r-   Ú_check_typeddict_specialÊ  s    r±   c                 C   s   t | ƒpt t| ƒƒS )zN
    Check if type is a TypedDict special form (Required or NotRequired).
    )r±   r?   r‹   r!   r!   r-   rr   Î  s    rr   Ú	test_typec                 C   s   t | tjƒot| dƒS )z>
    Check whether type_ was created using typing.NewType
    Ú__supertype__)rG   r²   r�   rN   r‹   r!   r!   r-   rs   Ø  s    rs   c                 C   s   t | dƒr| j} q | S )Nr³   )rN   r³   r‹   r!   r!   r-   rt   ß  s    
rt   c                 C   s(   | d krdS | j tj ko&t| dd ƒdkS )NFÚ_namer   )r�   r   r>   r”   r!   r!   r-   Ú_check_classvarå  s    rµ   c                 C   s2   | dkrdS | j tj ko0tjdk p0t| ddƒdkS )z9
    Check if a given type is a `typing.Final` type.
    NFr7   r´   r   )r�   r   rO   rP   r>   r”   r!   r!   r-   Ú_check_finalvarì  s    r¶   )Úann_typer)   c                 C   s6   t | ƒst t| ƒƒrdS | jtkr2| j d¡r2dS dS )NTz	ClassVar[F)rµ   r?   r�   r	   Ú__forward_arg__Ú
startswith©r·   r!   r!   r-   ru   ö  s
    ru   c                 C   s   t | ƒpt t| ƒƒS r*   )r¶   r?   rº   r!   r!   r-   rv     s    rv   rf   )Úfieldr'   r(   r)   c                 C   sŽ   d}| j jtkr(d}t| j ||p"dƒ| _ | jjtkrLd}t| j||pFdƒ| _|rX|  ¡  | jrx| jD ]}t|||d� qd| jdk	rŠ|  	¡  dS )z]
    Try to update ForwardRefs on fields based on this ModelField, globalns and localns.
    FTN©r'   r(   )
r&   r�   r	   r.   Zouter_type_ÚprepareZ
sub_fieldsrw   Zdiscriminator_keyZ&prepare_discriminated_union_sub_fields)r»   r'   r(   r½   Zsub_fr!   r!   r-   rw     s    

rw   rz   )ÚmodelÚfieldsÚjson_encodersr(   Úexc_to_suppressr)   c           
   	   C   sÜ   | j tjkr tj| j  j ¡ }ni }| | j| ¡ |D ],}zt|||d� W q6 |k
r`   Y q6X q6t| 	¡ ƒD ]f}t
|tƒrˆt|ƒ}nt
|tƒrp|}nqpzt|||p¨dƒ}	W n |k
rÆ   Y qpY nX | |¡||	< qpdS )zL
    Try to update model fields ForwardRefs based on model and localns.
    r¼   N)Ú
__module__rO   r›   r�   ÚcopyÚ
setdefaultr<   rw   r0   ÚkeysrG   rX   r	   r.   Úpop)
r¾   r¿   rÀ   r(   rÁ   r'   ÚfÚkeyÚfrZnew_keyr!   r!   r-   rx     s(    




rx   c                 C   sF   | t krdS t| ƒdkrdS t| ƒ}|r6t|d t ƒs:dS |d S dS )z„
    Tries to get the class of a Type[T] annotation. Returns True if Type is used
    without brackets. Otherwise returns None.
    TNr   )r;   r?   rK   rG   )r&   ra   r!   r!   r-   Ú	get_classC  s    rÊ   c                 C   sD   t | ƒ}|tkr tt| ƒd ƒS t|ƒr:dd„ t| ƒD ƒS | gS dS )z~
    Return all the types that are allowed by type `tp`
    `tp` can be a `Union` of allowed types or an `Annotated` type
    r   c                 S   s   g | ]}t |ƒD ]}|‘qqS r!   )r…   )rZ   r9   r¦   r!   r!   r-   Ú
<listcomp>^  s     
  z!get_sub_types.<locals>.<listcomp>N)r?   r   r…   rK   rd   )r@   r`   r!   r!   r-   r…   U  s    r…   )NN)r!   )srO   ÚtypingÚcollections.abcr   Úosr   r   r   r   ZTypingCallabler   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Útyping_extensionsr   r   r   r   r°   r   r¯   r   r†   ÚImportErrorr   r    rY   re   r"   r]   rP   r.   r3   r4   rg   rh   ZAnyArgTCallabler=   r6   Ú__annotations__rN   Úaddr?   rA   rC   rK   rT   rS   rU   rV   r5   Úboolrd   r„   rX   r‡   Zpydantic.v1.fieldsrf   ry   rz   r{   r|   r}   Úintr~   r   r€   rˆ   r�   r‚   ZMYPYÚclassmethodrƒ   Ú__all__r�   ri   r‰   rj   rk   rl   rm   rn   r¥   ro   rp   rq   r±   rr   r²   rs   rt   rµ   r¶   ru   rv   rw   ÚBaseExceptionrx   rÊ   r…   r!   r!   r!   r-   Ú<module>   sÚ    `


)
+ .#



 ûú'"