a
    •˜ëj+X  ã                
   @  s¬  d dl mZ d dlZd dlmZ d dlmZ d dlZd dl	Z	d dl
Z
d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d d	l
mZ d d
l
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dl
mZ d dlZddlmZ d dlmZ d dlm Z  d dlm!Z! d dlm"Z" d dlm#Z# d dlm$Z$ d dlm%Z% d dlm&Z& d dlm'Z' d d lm(Z( d d!lm)Z) d d"lm*Z* d d#lm+Z+ d d$lm,Z, d d%lm-Z- d d&lm.Z. d d'lm/Z/ d d(lm0Z0 d d)lm1Z1 ed*ed+�Z2ed,ƒZ3ed-d.d/�Z4ed0d.d1�Z5ed2ƒZ6ed3d.d/�Z7ej8�r^d d4l9m:Z: ne;dƒZ:d5d6d7œd8d9„Z<eee e=eee/d:f Z>G d;d<„ d<e)ƒZ?G d=d>„ d>e)e2 ƒZ@G d?d@„ d@e)e3e7f ƒZAe&dA ZBddBddCœdDdEdFdGdHd6dIdDdJœdKdL„ZCdEdEdMœdNdO„ZDdPdQdRdSœdTdU„ZEdddVœdFdFdWdXd5dYœdZd[„ZFdd\œdFdFdWd5d]œd^d_„ZGdFdFdFd`œdadb„ZHdcd6dMœddde„ZId5dfdgœdhdi„ZJd5d6dMœdjdk„ZKdldmdMœdndo„ZLdEdpdMœdqdr„ZMdEdsdMœdtdu„ZNdvdDdMœdwdx„ZOdEdydMœdzd{„ZPd²dEd6d6d|d}œd~d„ZQedFdFdMœd€d�„ƒZRedDdDdMœd‚d�„ƒZRedEdEdMœdƒd�„ƒZRdEdEdMœd„d�„ZRed…d†d6d‡œdˆd‰„ƒZSed…dŠdEd‡œd‹d‰„ƒZSd…d6dŒd‡œd�d‰„ZSdEdDdŽœd�d�„ZTd5d6dMœd‘d’„ZUd5d6dMœd“d”„ZVd5d•dMœd–d—„ZWd5d˜d6d™œdšd›„ZXddœœd5dFd�d6džœdŸd „ZYdDdFdMœd¡d¢„ZZG d£d¤„ d¤e)ƒZ[ed¥e[d+�Z\G d¦d§„ d§ee\ ƒZ]ed¨e[d.d©�Z^G dªd«„ d«ee^ ƒZ_ed¬eed­ef  d+�Z`G d®d¯„ d¯ee` ƒZaG d°d±„ d±ƒZbebƒ Zce�ržeZdnecZdecj&ZedS )³é    )ÚannotationsN)Údeque)ÚAny)ÚCallable)ÚDict©Ú
ForwardRef)ÚGeneric)ÚIterable)ÚMapping)ÚNewType)ÚNoReturn)ÚOptional)Úoverload)ÚSet)ÚTuple)ÚType)ÚTYPE_CHECKING)ÚTypeVar©ÚUnioné   )Úcompat)Ú	Annotated)ÚConcatenate)Údataclass_transform)ÚFinal)Úfinal)Úget_args)Ú
get_origin)ÚLiteral)ÚNotRequired)Ú	ParamSpec)ÚProtocol)ÚSupportsIndex)Ú	TypeAlias)Ú	TypedDict)Ú	TypeGuard)ÚSelf)ÚTypeAliasType)ÚNever)ÚLiteralStringÚ_T)ÚboundÚ_KTÚ_KT_coT)Ú	covariantÚ
_KT_contra)ÚcontravariantÚ_VTÚ_VT_co)ÚNoneTyper   Úbool)ÚtypÚreturnc                 C  s   t | tƒo| jdkS )NÚNone)Ú
isinstancer   Ú__forward_arg__)r7   © r<   úU/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/sqlalchemy/util/typing.pyÚis_fwd_noneM   s    r>   zGenericProtocol[Any]c                   @  s   e Zd ZU dZded< dS )ÚArgsTypeProtocolz_protocol for types that have ``__args__``

    there's no public interface for this AFAIK

    úTuple[_AnnotationScanType, ...]Ú__args__N©Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r<   r<   r<   r=   r?   V   s   
r?   c                   @  s"   e Zd ZU dZded< ded< dS )ÚGenericProtocolzXprotocol for generic types.

    this since Python.typing _GenericAlias is private

    r@   rA   úType[_T]Ú
__origin__NrB   r<   r<   r<   r=   rH   `   s   
rH   c                   @  s*   e Zd Zddœdd„Zdddœdd	„Zd
S )ÚSupportsKeysAndGetItemzIterable[_KT])r8   c                 C  s   d S ©Nr<   )Úselfr<   r<   r=   Úkeysu   ó    zSupportsKeysAndGetItem.keysr.   r4   )Ú_SupportsKeysAndGetItem__kr8   c                 C  s   d S rL   r<   )rM   rP   r<   r<   r=   Ú__getitem__w   rO   z"SupportsKeysAndGetItem.__getitem__N)rC   rD   rE   rN   rQ   r<   r<   r<   r=   rK   t   s   rK   Ú*F©Ústr_cleanup_fnÚinclude_genericÚ_already_seenz	Type[Any]Ú_AnnotationScanTypeÚstrzMapping[str, Any]z#Optional[Callable[[str, str], str]]zOptional[Set[Any]])ÚclsÚ
annotationÚoriginating_moduleÚlocals_rT   rU   rV   r8   c          	        s¢   |}t |ƒr|j}t|tƒr:ˆr*ˆ|ˆƒ}t|ˆˆˆd�}ˆržt|ƒržt|ƒsžˆ du r\tƒ ‰ |ˆ v rh|S ˆ  |¡ t	‡ ‡‡‡‡‡fdd„|j
D ƒƒ}t||ƒS |S )a;  Resolve annotations that may be string based into real objects.

    This is particularly important if a module defines "from __future__ import
    annotations", as everything inside of __annotations__ is a string. We want
    to at least have generic containers like ``Mapped``, ``Union``, ``List``,
    etc.

    ©r\   Úin_classNc              
   3  s$   | ]}t ˆ|ˆˆˆˆˆ d �V  qdS )rS   N)Úde_stringify_annotation©Ú.0Úelem©rV   rY   rU   r\   r[   rT   r<   r=   Ú	<genexpr>³   s   
÷ùz*de_stringify_annotation.<locals>.<genexpr>)Ú
is_fwd_refr;   r:   rX   Úeval_expressionÚ
is_genericÚ
is_literalÚsetÚaddÚtuplerA   Ú_copy_generic_annotation_with)	rY   rZ   r[   r\   rT   rU   rV   Zoriginal_annotationÚelementsr<   rc   r=   r_   ~   s2    

ÿÿþý

ö
r_   )Útype_r8   c              	   C  sb   t | ƒr^t| ƒttttjtjtjtj	tj
fv r^t dt| ƒ¡s^t| ƒ tdd„ t| ƒD ƒƒ¡S | S )zfCorrect dict['x', 'y'] into dict[ForwardRef('x'), ForwardRef('y')]
    and similar for list, set

    z3typing.(?:Dict|List|Set|.*Mapping|.*Sequence|.*Set)c                 S  s"   g | ]}t |tƒrt|ƒn|‘qS r<   )r:   rX   r   r`   r<   r<   r=   Ú
<listcomp>å   s   ÿz,fixup_container_fwd_refs.<locals>.<listcomp>)rg   r   Údictri   ÚlistÚcollections_abcÚ
MutableSetÚMutableMappingÚMutableSequencer   ÚSequenceÚreÚmatchÚreprÚ__class_getitem__rk   r   ©rn   r<   r<   r=   Úfixup_container_fwd_refsÅ   s4    	ÿøÿþÿïþÿÿr|   zGenericProtocol[_T]r@   rI   )rZ   rm   r8   c                 C  s"   t | dƒr|  |¡S | j| S d S )NÚ	copy_with)Úhasattrr}   rJ   )rZ   rm   r<   r<   r=   rl   î   s    

rl   r]   zOptional[Mapping[str, Any]]zOptional[Type[Any]])Ú
expressionÚmodule_namer\   r^   r8   c          	   
   C  sÒ   zt j| j}W n: tyJ } z"td|› d| › �ƒ|‚W Y d }~n
d }~0 0 zH|d ur†t|jƒ}| |j|¡ | |¡ t	| ||ƒ}nt	| ||ƒ}W n4 t
yÈ } ztd| ›�ƒ|‚W Y d }~nd }~0 0 |S d S )NúModule z9 isn't present in sys.modules; can't evaluate expression z"Could not de-stringify annotation )ÚsysÚmodulesÚ__dict__ÚKeyErrorÚ	NameErrorrp   Ú
setdefaultrC   ÚupdateÚevalÚ	Exception)	r   r€   r\   r^   Úbase_globalsÚkeZcls_namespacerZ   Úerrr<   r<   r=   rf   ù   s0    ÿÿý

ÿþrf   ©r\   )Únamer€   r\   r8   c                C  sØ   d| v rt | ||d�S ztj| j}W n: ty` } z"td|› d| › �ƒ|‚W Y d }~n
d }~0 0 z
||  W S  tyÒ } zNztj|  W W  Y d }~S  ty¦   Y n0 td| › d|› �ƒ|‚W Y d }~n
d }~0 0 d S )NÚ.rŽ   r�   z2 isn't present in sys.modules; can't resolve name zCould not locate name z in module )rf   r‚   rƒ   r„   r…   r†   Úbuiltins)r�   r€   r\   r‹   rŒ   r<   r<   r=   Úeval_name_only  s0    ÿÿý
ÿþr’   )r�   r€   r8   c                 C  s6   zt | |ƒ}W n ty$   |  Y S 0 t|d| ƒS d S )NrC   )r’   r†   Úgetattr)r�   r€   Úobjr<   r<   r=   Úresolve_name_to_real_class_name?  s
    
r•   zOptional[Any]c                 C  s   | d uot | ƒtjv S rL   )r   Ú_type_tuplesr   r{   r<   r<   r=   Ú	is_pep593H  s    r—   zTypeGuard[Iterable[Any]])r”   r8   c                 C  s   t | tjƒot | ttfƒ S rL   )r:   rr   r
   rX   Úbytes)r”   r<   r<   r=   Úis_non_string_iterableL  s    ÿr™   c                 C  s   t | ƒtjv S rL   )r   r–   r    r{   r<   r<   r=   rh   R  s    rh   zOptional[_AnnotationScanType]zTypeGuard[NewType]c                 C  s
   t | dƒS )NÚ__supertype__©r~   r{   r<   r<   r=   Ú
is_newtypeV  s    rœ   zTypeGuard[GenericProtocol[Any]]c                 C  s   t | dƒot | dƒS )NrA   rJ   r›   r{   r<   r<   r=   rg   ^  s    rg   zTypeGuard[TypeAliasType]c                 C  s*   t | ƒrt| ƒrdS t| jƒS t| tjƒS )NF)rg   r—   Ú	is_pep695rJ   r:   Ú_type_instancesr)   r{   r<   r<   r=   r�   b  s
    
r�   r   c                 C  s   | j }t|ƒr|j }q|S rL   )rš   rœ   )rn   Z
super_typer<   r<   r=   Úflatten_newtypen  s    rŸ   zSet[Any]c                   s„   t ƒ ‰ ‡ ‡fdd„‰ˆ| ƒ}t|tƒrzt ƒ }t|ƒ}|rv| ¡ }t|tƒrV| |¡ q4| |tu sjt|ƒrndn|¡ q4|S |hS dS )zçExtracts the value from a TypeAliasType, recursively exploring unions
    and inner TypeAliasType to flatten them into a single set.

    Forward references are not evaluated, so no recursive exploration happens
    into them.
    c                   sH   | ˆ v r| S ˆ   | ¡ t| ƒs"| S | j}t|ƒs4|S ‡fdd„|jD ƒS )Nc                   s   g | ]}ˆ |ƒ‘qS r<   r<   ©ra   Út)Úrecursive_valuer<   r=   ro   ‰  rO   z:pep695_values.<locals>.recursive_value.<locals>.<listcomp>)rj   r�   Z	__value__Úis_unionrA   )Z
inner_typeÚvalue©Ú_seenr¢   r<   r=   r¢   ~  s    
z&pep695_values.<locals>.recursive_valueN)	ri   r:   rq   r   ÚpopleftÚextendrj   r5   r>   )rn   ÚresÚtypesÚstackr¡   r<   r¥   r=   Úpep695_valuesu  s    

 r¬   zTypeGuard[ForwardRef])rn   Úcheck_genericÚcheck_for_plain_stringr8   c                   sN   ˆ rt | tƒrdS t | tjƒr"dS |rFt| ƒrFt‡ fdd„| jD ƒƒS dS d S )NTc                 3  s   | ]}t |d ˆ d�V  qdS )T©r®   N)re   )ra   Úargr¯   r<   r=   rd   ¤  s   ýÿzis_fwd_ref.<locals>.<genexpr>F)r:   rX   rž   r   rg   ÚanyrA   )rn   r­   r®   r<   r¯   r=   re   š  s    üre   c                 C  s   d S rL   r<   r{   r<   r<   r=   Úde_optionalize_union_types®  s    r²   c                 C  s   d S rL   r<   r{   r<   r<   r=   r²   ²  s    c                 C  s   d S rL   r<   r{   r<   r<   r=   r²   ¶  s    c                 C  s¤   t | ƒrt| dƒS t| ƒrœt| ƒrœtjr4t| jƒ}nRt| gƒ}tƒ }|r|| 	¡ }|jD ]"}t|ƒrn| 
|¡ qV| |¡ qVqD| d¡ dd„ |D ƒ}t|Ž S | S dS )zÜGiven a type, filter out ``Union`` types that include ``NoneType``
    to not include the ``NoneType``.

    Contains extra logic to work on non-flattened unions, unions that contain
    ``None`` (seen in py38, 37)

    FNc                 S  s    h | ]}|t urt|ƒs|’qS r<   )r5   r>   r    r<   r<   r=   Ú	<setcomp>Ü  rO   z-de_optionalize_union_types.<locals>.<setcomp>)re   Ú#_de_optionalize_fwd_ref_union_typesr£   Úincludes_noner   Zpy39ri   rA   r   r§   Úappendrj   ÚdiscardÚmake_union_type)rn   r7   Zstack_of_unionsZu_typrb   r<   r<   r=   r²   ¼  s"    



r   zLiteral[True])rn   Úreturn_has_noner8   c                 C  s   d S rL   r<   ©rn   r¹   r<   r<   r=   r´   ä  s    r´   zLiteral[False]c                 C  s   d S rL   r<   rº   r<   r<   r=   r´   ê  s    z Union[_AnnotationScanType, bool]c                 C  s‚  | j }t d|¡}|�r4| d¡ d¡d }|dkrJ|r<dS t| d¡ƒS |dk�r&d	| d¡v rÜg }g }d
}| d¡D ]`}|d	krŽ|d7 }n@|dkr |d8 }n.|d
krÎ|dkrÎ| d |¡ ¡ ¡ | 	¡  qx| |¡ qxnt d| d¡¡}dd„ |D ƒ}	|�rt
|ƒt
|	ƒkS |	�r t|	Ž S tS n|�r0dS | S t d|¡}
d|
v }|�rR|S |�r~d dd„ |
D ƒ¡}|�rzt|ƒS tS | S )zÁreturn the non-optional type for Optional[], Union[None, ...], x|None,
    etc. without de-stringifying forward refs.

    unfortunately this seems to require lots of hardcoded heuristics

    z^(.+?)\[(.+)\]$r   r�   éÿÿÿÿr   Té   r   ú[r   ú]ú,Ú z,\s*c                 S  s   g | ]}|d krt |ƒ‘qS )r9   r   r`   r<   r<   r=   ro     rO   z7_de_optionalize_fwd_ref_union_types.<locals>.<listcomp>Fz\s*\|\s*r9   ú|c                 s  s   | ]}|d kr|V  qdS )r9   Nr<   )ra   Úpr<   r<   r=   rd      rO   z6_de_optionalize_fwd_ref_union_types.<locals>.<genexpr>)r;   rw   rx   ÚgroupÚsplitr   r¶   ÚjoinÚstripÚclearÚlenr¸   r*   )rn   r¹   rZ   ÚmmZg1rm   ÚcurrentZignore_commaÚcharÚpartsZpipe_tokensZhas_noneZanno_strr<   r<   r=   r´   ð  sF    



)rª   r8   c                  G  s   t |  S )zMake a Union type.r   )rª   r<   r<   r=   r¸   &  s    r¸   c                 C  s¨   t | ƒrt| dƒS t| ƒr0tdd„ t| ƒD ƒƒS t| ƒrHtt| ƒd ƒS t| ƒrftdd„ t| ƒD ƒƒS t	| ƒrxt| j
ƒS z| tdfv pŒt| ƒW S  ty¢   Y dS 0 dS )a.  Returns if the type annotation ``type_`` allows ``None``.

    This function supports:
    * forward refs
    * unions
    * pep593 - Annotated
    * pep695 - TypeAliasType (does not support looking into
    fw reference of other pep695)
    * NewType
    * plain types like ``int``, ``None``, etc
    Tc                 s  s   | ]}t |ƒV  qd S rL   ©rµ   r    r<   r<   r=   rd   ;  rO   z includes_none.<locals>.<genexpr>r   c                 s  s   | ]}t |ƒV  qd S rL   rÍ   r    r<   r<   r=   rd   ?  rO   NF)re   r´   r£   r±   r   r—   rµ   r�   r¬   rœ   rš   r5   r>   Ú	TypeErrorr{   r<   r<   r=   rµ   ,  s    

rµ   c                 C  s:   t | tƒp8t| ƒd up8t| dd ƒdv p8t| ƒjd jdv S )NrD   )ÚtypingÚtyping_extensionsr   )r:   Útyper   r“   Ú__mro__rD   r{   r<   r<   r=   Ú	is_a_typeK  s    

ÿ
ÿþûrÓ   zTypeGuard[ArgsTypeProtocol]c                 C  s   t | ddƒS )Nr   Z	UnionType)Úis_origin_ofr{   r<   r<   r=   r£   U  s    r£   z'Union[Tuple[Type[Any], ...], Type[Any]])rn   Ú	class_objr8   c                 C  s(   t | ƒ}|du rdS t|tƒo&t||ƒS )z[return True if the given type has an __origin__ that shares a base
    with the given classNF)r   r:   rÑ   Ú
issubclass)rn   rÕ   Úoriginr<   r<   r=   Úis_origin_of_clsY  s    rØ   )ÚmodulezOptional[str])rn   ÚnamesrÙ   r8   c                G  s4   t | ƒ}|du rdS t|ƒ|v o2|du p2|j |¡S )z\return True if the given type has an __origin__ with the given name
    and optional module.NF)r   Ú_get_type_namerD   Ú
startswith)rn   rÙ   rÚ   r×   r<   r<   r=   rÔ   f  s    ÿrÔ   c                 C  s4   t jr| jS t| dd ƒ}|d u r,t| dd ƒ}|S d S )NrC   Ú_name)r   Úpy310rC   r“   )rn   Ztyp_namer<   r<   r=   rÛ   u  s    rÛ   c                   @  s@   e Zd Zddddœdd„Zddddœdd	„Zddd
œdd„ZdS )ÚDescriptorProtoÚobjectr   ©ÚinstanceÚownerr8   c                 C  s   d S rL   r<   ©rM   râ   rã   r<   r<   r=   Ú__get__�  rO   zDescriptorProto.__get__r9   ©râ   r¤   r8   c                 C  s   d S rL   r<   ©rM   râ   r¤   r<   r<   r=   Ú__set__ƒ  rO   zDescriptorProto.__set__©râ   r8   c                 C  s   d S rL   r<   ©rM   râ   r<   r<   r=   Ú
__delete__…  rO   zDescriptorProto.__delete__N)rC   rD   rE   rå   rè   rë   r<   r<   r<   r=   rß   €  s   rß   Ú_DESCc                   @  sH   e Zd ZdZerDddddœdd„Zdddd	œd
d„Zdddœdd„ZdS )ÚDescriptorReferenceaŠ  a descriptor that refers to a descriptor.

    used for cases where we need to have an instance variable referring to an
    object that is itself a descriptor, which typically confuses typing tools
    as they don't know when they should use ``__get__`` or not when referring
    to the descriptor assignment as an instance variable. See
    sqlalchemy.orm.interfaces.PropComparator.prop

    rà   r   rì   rá   c                 C  s   d S rL   r<   rä   r<   r<   r=   rå   ˜  rO   zDescriptorReference.__get__r9   ræ   c                 C  s   d S rL   r<   rç   r<   r<   r=   rè   š  rO   zDescriptorReference.__set__ré   c                 C  s   d S rL   r<   rê   r<   r<   r=   rë   œ  rO   zDescriptorReference.__delete__N©rC   rD   rE   rF   r   rå   rè   rë   r<   r<   r<   r=   rí   ‹  s
   
rí   Ú_DESC_co)r-   r0   c                   @  sH   e Zd ZdZerDddddœdd„Zdddd	œd
d„Zdddœdd„ZdS )ÚRODescriptorReferencez½a descriptor that refers to a descriptor.

    same as :class:`.DescriptorReference` but is read-only, so that subclasses
    can define a subtype as the generically contained element

    rà   r   rï   rá   c                 C  s   d S rL   r<   rä   r<   r<   r=   rå   ¬  rO   zRODescriptorReference.__get__r   ræ   c                 C  s   d S rL   r<   rç   r<   r<   r=   rè   ®  rO   zRODescriptorReference.__set__ré   c                 C  s   d S rL   r<   rê   r<   r<   r=   rë   °  rO   z RODescriptorReference.__delete__Nrî   r<   r<   r<   r=   rð   ¢  s
   rð   Ú_FN.c                   @  sH   e Zd ZdZerDddddœdd„Zdddd	œd
d„Zdddœdd„ZdS )ÚCallableReferencez�a descriptor that refers to a callable.

    works around mypy's limitation of not allowing callables assigned
    as instance variables


    rà   r   rñ   rá   c                 C  s   d S rL   r<   rä   r<   r<   r=   rå   Á  rO   zCallableReference.__get__r9   ræ   c                 C  s   d S rL   r<   rç   r<   r<   r=   rè   Ã  rO   zCallableReference.__set__ré   c                 C  s   d S rL   r<   rê   r<   r<   r=   rë   Å  rO   zCallableReference.__delete__Nrî   r<   r<   r<   r=   rò   ¶  s
   rò   c                   @  s   e Zd Zdddœdd„ZdS )Ú_TypingInstancesrX   ztuple[type, ...])Úkeyr8   c                 C  s@   t dd„ tt|d ƒtt|d ƒfD ƒƒ}|s2t|ƒ‚|| j|< |S )Nc                 S  s   h | ]}|d ur|’qS rL   r<   r    r<   r<   r=   r³   Ë  s   ûz/_TypingInstances.__getattr__.<locals>.<setcomp>)rk   r“   rÏ   rÐ   ÚAttributeErrorr„   )rM   rô   rª   r<   r<   r=   Ú__getattr__É  s    

þþÿ

z_TypingInstances.__getattr__N)rC   rD   rE   rö   r<   r<   r<   r=   ró   È  s   ró   )FF)fÚ
__future__r   r‘   Úcollectionsr   Úcollections.abcÚabcrr   rw   r‚   rÏ   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   rÐ   rÀ   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r.   r/   r1   r3   r4   rÞ   rª   r5   rÑ   r>   rX   rW   r?   rH   rK   Z_LiteralStarr_   r|   rl   rf   r’   r•   r—   r™   rh   rœ   rg   r�   rŸ   r¬   re   r²   r´   r¸   rµ   rÓ   r£   rØ   rÔ   rÛ   rß   rì   rí   rï   rð   rñ   rò   ró   r–   rž   ZLITERAL_TYPESr<   r<   r<   r=   Ú<module>	   sê   ÿ
	ø G)û(ü"	'  ý(6
ÿ