U
|
¸ý°dQ? ã
|
@ s d dl mZ d dlZd dlZd dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlm Z d dlm
|
Z
|
d d lm Z d d
|
lm Z d d lm Z d d lmZ d d lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ ddlmZ d dlmZ d dlmZ d dlm Z d dlm Z d dlm Z d d lm Z d d lm Z d d lm!Z! d d lm"Z" d d lm#Z# d d!lm$Z$ d d"lm%Z% d d#lm&Z& d d$lm'Z' d d%lm(Z( d d&lm)Z) ed'ed(Z*ed)Z+ed*d+d,Z,ed-d+d.Z-ed/Z.ed0d+d,Z/ej0r d d1l1m2Z2 ne3dZ2e d2Z4e Z5e Z6eee e7e e d3f Z8G d4d5 d5e$Z9G d6d7 d7e$e* Z:G d8d9 d9e$e+e/f Z;e!d: Z<dd;dd<d=d>d?d@dAdBdCd=dDdEdFZ=dGdHdIdJdKdLZ>ddMd?d?dNdOdPdQdRZ?ddMd?d?dNdOdSdTdUZ@d?d?d?dVdWdXZAddYd=d5d?d@dAd=dZd[d\ZBd]dBd^d_d`ZCd>dBd^dadbZDd]dcd^dddeZEd>dfd^dgdhZFdid=d^djdkZGdd>dBdldmdndoZHed?d?d^dpdqZIed=d=d^drdqZIed>d>d^dsdqZId>d>d^dtdqZIdud>d^dvdwZJd>d=dxdydzZKdd=dBdBd{d|d}d~ZLdOdd^ddZMdOdBd^ddZNdOdd^dd
ZOdOddBdddZPdddOd?ddBdddZQd=d?d^ddZRG dd de$ZSedeSd(ZTG dd de
|
eT ZUedeSd+dZVG dd de
|
eV ZWedeedef d(ZXG dd de
|
eX ZYdS ) é )Ú annotationsN)ÚAny)ÚCallable)Úcast)Ú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Ú_T)ÚboundÚ_KTÚ_KT_coT)Ú covariantÚ
|
_KT_contra)Ú contravariantÚ_VTÚ_VT_co)ÚNoneTypeÚNonezGenericProtocol[Any]c @ s e Zd ZU dZded< dS )ÚArgsTypeProcotolz_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< úMd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/util/typing.pyr3 R s
|
r3 c @ s" e Zd ZU dZded< ded< dS )ÚGenericProtocolzXprotocol for generic types.
|
|
this since Python.typing _GenericAlias is private
|
|
r4 r5 úType[_T]Ú
|
__origin__Nr6 r< r< r< r= r> \ s
|
r> c @ s* e Zd ZddddZddddd Zd
|
S ) ÚSupportsKeysAndGetItemz Iterable[_KT])Úreturnc C s d S ©Nr< )Úselfr< r< r= Úkeysq s zSupportsKeysAndGetItem.keysr* r0 )Ú_SupportsKeysAndGetItem__krB c C s d S rC r< )rD rF r< r< r= Ú __getitem__t s z"SupportsKeysAndGetItem.__getitem__N)r7 r8 r9 rE rG r< r< r< r= rA p s rA Ú*F©Ústr_cleanup_fnÚinclude_genericÚ _already_seenz Type[Any]Ú_AnnotationScanTypeÚstrzMapping[str, Any]z#Optional[Callable[[str, str], str]]ÚboolzOptional[Set[Any]])ÚclsÚ
|
annotationÚoriginating_moduleÚlocals_rJ rK rL rB c s |}t |r|j}t|tr8r*|}t|d}rt|rt|s dkrZt | krf|S |¡ t fdd|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.
|
|
©rS Nc
|
3 s$ | ] }t | d V qdS )rI N©Úde_stringify_annotation©Ú.0Úelem©rL rP rK rS rR rJ r< r= Ú <genexpr>² s
|
÷ùz*de_stringify_annotation.<locals>.<genexpr>) Ú
|
is_fwd_refÚ__forward_arg__Ú
|
isinstancerN Úeval_expressionÚ
|
is_genericÚ
|
is_literalÚsetÚaddÚtupler5 Ú _copy_generic_annotation_with) rP rQ rR rS rJ rK rL Zoriginal_annotationÚelementsr< rZ r= rV | s6
|
|
ÿÿþý
|
|
ö
|
rV zGenericProtocol[_T]r4 r? )rQ rf rB c C s" t | dr| |¡S | j| S d S )NÚ copy_with)Úhasattrrg r@ )rQ rf r< r< r= re à s
|
|
re rT zOptional[Mapping[str, Any]]r )Ú
|
expressionÚ module_namerS rB c
|
C s zt j| j}W n8 tk
|
rH } ztd| d| |W 5 d }~X Y nX zt| ||}W n2 tk
|
r } ztd| |W 5 d }~X Y nX |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Ú NameErrorÚevalÚ Exception)ri rj rS Ú base_globalsÚkerQ Úerrr< r< r= r_ Î s" ÿýÿþr_ )Únamerj rS rB c
|
C s¨ d| krt | ||dS ztj| j}W n8 tk
|
r^ } ztd| d| |W 5 d }~X Y nX z
|
|| W S tk
|
r¢ } ztd| d| |W 5 d }~X Y nX d S )NÚ.rT rk z2 isn't present in sys.modules; can't resolve name zCould not locate name z in module )r_ rl rm rn ro rp )rv rj rS rs rt r< r< r= Úeval_name_onlyæ s$ ÿý
|
ÿþrx )rv rj rB c C s8 zt | |}W n tk
|
r& | Y S X t|d| S d S )Nr7 )rx rp Úgetattr)rv rj Úobjr< r< r= Ú resolve_name_to_real_class_name s
|
|
r{ ©rJ )rP rQ rR rS rJ rB c s t fdd|jD S )Nc s g | ]}t |i d qS )r| rU )rX Úanno©rP rR rJ r< r= Ú
|
<listcomp> s ùûz/de_stringify_union_elements.<locals>.<listcomp>)Úmake_union_typer5 )rP rQ rR rS rJ r< r~ r= Úde_stringify_union_elements s
|
øÿr z Optional[_AnnotationScanType])Útype_rB c C s | d k ot | tkS rC )Útyping_get_originr ©r r< r< r= Ú is_pep593! s r
c C s t | tkS rC )r r r r< r< r= ra % s ra zTypeGuard[NewType]c C s
|
t | dS )NÚ __supertype__©rh r r< r< r= Ú
|
is_newtype) s r z TypeGuard[GenericProtocol[Any]]c C s t | dot | dS )Nr5 r@ r r r< r< r= r` 1 s r` r c C s | j }t|r|j }q|S rC )r r )r Z
|
super_typer< r< r= Úflatten_newtype5 s r zTypeGuard[ForwardRef])r Ú check_genericrB c C s6 t | trdS |r.t| r.tdd | jD S dS d S )NTc s s | ]}t |d V qdS )TN)r\ )rX Úargr< r< r= r[ B s z is_fwd_ref.<locals>.<genexpr>F)r^ r r` Úanyr5 )r r r< r< r= r\ < s
|
|
r\ c C s d S rC r< r r< r< r= Úde_optionalize_union_typesG s r c C s d S rC r< r r< r< r= r L s c C s d S rC r< r r< r< r= r Q s c C sF t | rt| S t| r>t| j}| t¡ | t¡ t| S | S dS )zmGiven a type, filter out ``Union`` types that include ``NoneType``
|
to not include the ``NoneType``.
|
|
N) r\ Ú"de_optionalize_fwd_ref_union_typesÚ is_optionalrb r5 Údiscardr1 ÚNoneFwdr )r Útypr< r< r= r X s
|
|
|
r c C s | j }t d|¡}|rh| d¡dkr2t| d¡S | d¡dkrdt d| d¡¡}tdd |D S | S t d |¡}d
|
|krtd d d |D ¡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 z,\s*c S s g | ]}|d krt |qS )r2 r rW r< r< r= r s z6de_optionalize_fwd_ref_union_types.<locals>.<listcomp>z\s*\|\s*r2 ú|c s s | ]}|d kr|V qdS )r2 Nr< )rX Úpr< r< r= r[ s z5de_optionalize_fwd_ref_union_types.<locals>.<genexpr>)r] ÚreÚmatchÚgroupr Úsplitr Újoin)r rQ Úmmrf Z pipe_tokensr< r< r= r o s
|
ÿ r )ÚtypesrB c G s t tt | ¡S )zMake a Union type.
|
|
This is needed by :func:`.de_optionalize_union_types` which removes
|
``NoneType`` from a ``Union``.
|
|
)r r r rG )r r< r< r= r s r zTuple[Type[Any], ...])r Ú include_unionÚ discard_nonerB c C sF t | r<t| j}|r | t¡ |r2| ft| S t|S n| fS dS )zPReturn a type as a tuple of individual types, expanding for
|
``Union`` types.N)Úis_unionrb r5 r r1 rd )r r r r r< r< r= Ú expand_unions s
|
|
|
r zTypeGuard[ArgsTypeProcotol]c C s t | dddS )Nr r Z UnionType©Ú is_origin_ofr r< r< r= r ¬ s ür c C s t | ott| kS rC )r r1 Útyping_get_argsr r< r< r= Úis_optional_unionµ s r¤ c C s
|
t | dS )Nr r¡ r r< r< r= r ¹ s r z'Union[Tuple[Type[Any], ...], Type[Any]])r Ú class_objrB c C s( t | }|dkrdS t|to&t||S )z[return True if the given type has an __origin__ that shares a base
|
with the given classNF)r r^ ÚtypeÚ
|
issubclass)r r¥ Úoriginr< r< r= Úis_origin_of_cls½ s r© )Úmodulez Optional[str])r Únamesrª rB c G s4 t | }|dkrdS t||ko2|dkp2|j |¡S )z\return True if the given type has an __origin__ with the given name
|
and optional module.NF)r Ú_get_type_namer8 Ú
|
startswith)r rª r« r¨ r< r< r= r¢ Ê s ÿr¢ c C s4 t jr | jS t| dd }|d kr,t| dd }|S d S )Nr7 Ú_name)r Úpy310r7 ry )r Ztyp_namer< r< r= r¬ Ù s r¬ c @ s@ e Zd ZddddddZdddddd Zddd
|
d d Zd S )ÚDescriptorProtoÚobjectr ©ÚinstanceÚownerrB c C s d S rC r< ©rD r³ r´ r< r< r= Ú__get__å s zDescriptorProto.__get__r2 ©r³ ÚvaluerB c C s d S rC r< ©rD r³ r¸ r< r< r= Ú__set__è s zDescriptorProto.__set__©r³ rB c C s d S rC r< ©rD r³ r< r< r= Ú
|
__delete__ë s zDescriptorProto.__delete__N)r7 r8 r9 r¶ rº r½ r< r< r< r= r° ä s r° Ú_DESCc @ sH e Zd ZdZerDddddddZdddd d
|
d Zddd d dZdS )Ú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 rC r< rµ r< r< r= r¶ ÿ s zDescriptorReference.__get__r2 r· c C s d S rC r< r¹ r< r< r= rº s zDescriptorReference.__set__r» c C s d S rC r< r¼ r< r< r= r½ s z DescriptorReference.__delete__N©r7 r8 r9 r: r r¶ rº r½ r< r< r< r= r¿ ò s
|
|
r¿ Ú_DESC_co)r) r, c @ sH e Zd ZdZerDddddddZdddd d
|
d Zddd d dZdS )Ú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 rC r< rµ r< r< r= r¶ s z RODescriptorReference.__get__r r· c C s d S rC r< r¹ r< r< r= rº s z RODescriptorReference.__set__r» c C s d S rC r< r¼ r< r< r= r½ s z RODescriptorReference.__delete__NrÀ r< r< r< r= r s
|
r Ú_FN.c @ sH e Zd ZdZerDddddddZdddd d
|
d Zddd d dZdS )ÚCallableReferenceza 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 rC r< rµ r< r< r= r¶ . s zCallableReference.__get__r2 r· c C s d S rC r< r¹ r< r< r= rº 1 s zCallableReference.__set__r» c C s d S rC r< r¼ r< r< r= r½ 4 s z CallableReference.__delete__NrÀ r< r< r< r= rÄ # s
|
rÄ )F)FF)ZÚ
|
__future__r r rl Útypingr r r r r r r
|
r r r r r r r r r r r Ú r Ztyping_extensionsr r r r r r r r r r! r" r# r$ r% r& r' r( r* r+ r- r/ r0 r¯ r r1 r¦ r r£ r rN rM r3 r> rA Z _LiteralStarrV re r_ rx r{ r r
ra 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= Ú<module> sÌ ÿ
|
ø Gü ü ú ÿ ÿ ÿ
|
