a
    hM                     @   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&y   d dlm'Z% Y n0 zd dlm(Z) W n e&y   d	Z)Y n0 zd d
l*m+Z, W n e&y&   d	Z,Y n0 e j-dk rJeeeedddZ.n6e j-dk rleeeedddZ.neeeedddZ.e j-dk reZ/ndle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e58ej e j-dk r0ee eee  dddZ9n(d dlm9Z: ee eee  d d!dZ9e j-dk rd 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 re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 rTeee  eBd d/d0ZCe)fZDn8d dl*Z*d dlZeee  eBd d1d0ZCej;e*j(e*j+fZDeeEef ZFerXd d2lGmHZH 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  ZTd3ZUeUrJeVe ZWneVeeef ZWd4ZXdjYZZdeZed fZ[eeeef e6d5< e j-dk reeBd6d7d8Z\n6e j-dd9 dkreeBd6d:d8Z\neeBd6d;d8Z\ee eEd<d=d>Z]eeEee f eeE eeEee f d?d@dAZ^ee eBd6dBdCZ_ee eBd6dDdEZ`ee eedf d6dFdGZaee eedf d6dHdIZbee eBd6dJdKZcee eBd6dLdMZdeeBd6dNdOZeeeBd6dPdQZfedReEZgee eBd6dSdTZhee ee d6dUdVZieee  eBd<dWdXZjeee  eBd<dYdZZkee eBd[d\d]Zlee eBd[d^d_Zmd`eeddadbdcZndmee ed` eeee eEef e1f ddeeeo df ddedfdgZpee edeBee f d6dhdiZqeee d djdkZrdS )n    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!   N/var/www/html/assistant/venv/lib/python3.9/site-packages/pydantic/v1/typing.pyevaluate_forwardref:   s    r.   )r$         c                 C   s   t t| j||t dS )N)recursive_guardr   r   r+   setr,   r!   r!   r-   r.   ?   s    c                 C   s   t t| j||dt dS )Nr!   )type_paramsr1   r2   r,   r!   r!   r-   r.   H   s    )objr'   r(   r)   c                 C   s   t | ||ddS )NT)include_extras)r   )r5   r'   r(   r!   r!   r-   get_all_type_hintsV   s    r7   _T.ZAnnotatedMeta_AnnotatedAliasLITERAL_TYPESr   r$      )tr)   c                 C   s(   t | jtv rttt tS t| dd S )N
__origin__)type__name__AnnotatedTypeNamesr   r   r   r   getattr)r=   r!   r!   r-   
get_origino   s    rC   )rC   )tpr)   c                 C   s0   t | jtv 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@   rA   r   r   r   r   _typing_get_originrB   rD   r!   r!   r-   rC   x   s    )_GenericAliasc                 C   sl   t | jtv r| j| j S t| tr`| j}| jtu r\|r\|d t	ur\t
|dd |d f}|S t| ddS )zCompatibility 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@   rA   rI   __metadata__
isinstancerG   r>   r   EllipsislistrB   )r=   resr!   r!   r-   get_args   s    
rO   rO   c                 C   sZ   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yT   Y n0 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   rQ   r   sysversion_infotuple	TypeErrorrF   r!   r!   r-   _generic_get_args   s    
"
rW   c                 C   s6   t | jtv 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)
        rI   r!   )r?   r@   rA   rI   rJ   _typing_get_argsrB   rW   rF   r!   r!   r-   rO      s    c                 C   s   | S )zPython 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!   rF   r!   r!   r-   convert_generics   s    rY   )_UnionGenericAlias)r9   c                    s   t  }|rt ds S t }|tu rDtt|d |dd S t fdd|D }||krf S t trzt||S t t	rt
||S zt d| W n ty   Y n0  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
        rI   r      Nc                 3   s2   | ]*}t |tr"t  tr"t|nt|V  qd S r*   )rK   strTypingGenericAliasr	   rY   ).0argrF   r!   r-   	<genexpr>   s   z#convert_generics.<locals>.<genexpr>)rC   rR   rO   r   r9   rY   rU   rK   r]   TypesUnionTyperZ   setattrAttributeError)rD   originargsZ	convertedr!   rF   r-   rY      s(    




r$   
   c                 C   s   | t u S r*   )r   rF   r!   r!   r-   is_union   s    rh   c                 C   s   | t u p| tju S r*   )r   typesr"   rF   r!   r!   r-   rh     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   WithArgsTypesrO   rC   get_sub_typestyping_baser7   rh   StrPathMappingIntStrAny
NONE_TYPES)r&   r)   c                 C   s   | t v S r*   r   r&   r!   r!   r-   rn   Y  s    rn      c                 C   s0   t D ]}| |u r dS qt| r,t| dkS dS )NTr*   F)r   rr   rs   )r&   Z	none_typer!   r!   r-   rn   ^  s    c                 C   s   | t v S r*   r   r   r!   r!   r-   rn   k  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y   t| dd Y S 0 d S )NzUnion[z, ]ztyping. )rK   r   r   r?   	__class__rh   rC   joinmapro   rO   r\   replacer@   rc   r   r!   r!   r-   ro   o  s    
ro   )raw_annotationsmodule_namer)   c              	   C   s   d}|r0zt j| }W n ty(   Y n0 |j}i }|  D ]\}}t|trdt j  krddkspn t jdkrt|ddd}nt|dd}z,t jd	krt	||dd
d}nt	||d}W n t
y   Y n0 |||< q<|S )z
    Partially taken from typing.get_type_hints.

    Resolve string or ForwardRef annotations into type objects if possible.
    Nrf   )r$   r%   r<   )r$   rg   r[   FT)is_argumentZis_class)r   )r$      r!   )r4   )rS   modulesKeyError__dict__itemsrK   r\   rT   r	   r   	NameError)r   r   base_globalsmoduleannotationsnamevaluer!   r!   r-   rp     s*    
"

rp   c                 C   s   | t u pt| t u S r*   )r   rC   r   r!   r!   r-   rq     s    rq   c                 C   s   t d uot| tv S r*   )r   rC   r:   r   r!   r!   r-   rr     s    rr   c                 C   s   t | S r*   rP   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*   )rs   )r^   r   xr!   r!   r-   r`         z%all_literal_values.<locals>.<genexpr>)rr   r   rU   )r&   valuesr!   r!   r-   rs     s    rs   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   rU   rR   r&   r   r!   r!   r-   rt     s    rt   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   dictrR   r   r!   r!   r-   ru     s    ru   c                 C   s   | t u p| tu 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   rC   r   r!   r!   r-   rv     s    rv   	test_typec                 C   s   t | tjot| dS )z>
    Check whether type_ was created using typing.NewType
    __supertype__)rK   r   r   rR   r   r!   r!   r-   rw     s    rw   c                 C   s   t | dr| j} q | S )Nr   )rR   r   r   r!   r!   r-   rx     s    
rx   c                 C   s(   | d u rdS | j tj ko&t| dd dkS )NF_namer   )r   r   rB   r   r!   r!   r-   _check_classvar  s    r   c                 C   s2   | du 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.
    NFr;   r   r   )r   r   rS   rT   rB   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   rC   r   r	   __forward_arg__
startswithr   r!   r!   r-   ry     s
    ry   c                 C   s   t | pt t| S r*   )r   rC   r   r!   r!   r-   rz   	  s    rz   rj   )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u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_fieldsr{   Zdiscriminator_keyZ&prepare_discriminated_union_sub_fields)r   r'   r(   r   Zsub_fr!   r!   r-   r{     s    

r{   r~   )modelfieldsjson_encodersr(   exc_to_suppressr)   c           
   	   C   s   | j tjv r tj| j  j }ni }|| j|  |D ]*}zt|||d W q6 |y^   Y q60 q6t|	 D ]d}t
|trt|}nt
|trn|}nqnzt|||pd}	W n |y   Y qnY n0 ||||	< qndS )zL
    Try to update model fields ForwardRefs based on model and localns.
    r   N)
__module__rS   r   r   copy
setdefaultr@   r{   r3   keysrK   r\   r	   r.   pop)
r   r   r   r(   r   r'   fkeyfrZnew_keyr!   r!   r-   r|   #  s(    




r|   c                 C   sF   | t u rdS t| du 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?   rC   rO   rK   )r&   re   r!   r!   r-   	get_classJ  s    r   c                 C   sD   t | }|tu 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   )r^   r=   r   r!   r!   r-   
<listcomp>e  r   z!get_sub_types.<locals>.<listcomp>N)rC   r   r   rO   rh   )rD   rd   r!   r!   r-   r   \  s    r   )NN)r!   )srS   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   Ztyping_extensionsr   r   r   r   r   r   r   r   r   ImportErrorr   r    r]   ri   r"   ra   rT   r.   r7   r8   rk   rl   ZAnyArgTCallablerA   r:   __annotations__rR   addrC   rE   rG   rO   rX   rW   rY   rZ   r9   boolrh   r   r\   r   Zpydantic.v1.fieldsrj   r}   r~   r   r   r   intr   r   r   r   r   r   ZMYPYclassmethodr   __all__r   rm   r   rn   ro   rp   rq   rr   r   rs   rt   ru   r   rv   r   rw   rx   r   r   ry   rz   r{   BaseExceptionr|   r   r   r!   r!   r!   r-   <module>   s   
`

	
)
+ .#



 '"