hMZLddlmZddlZddlmZddlmZddlZddl Z ddl Z ddl m Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddlZddlmZ ddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddlm%Z%ddlm&Z&dd lm'Z'dd!lm(Z(dd"lm)Z)dd#lm*Z*dd$lm+Z+dd%lm,Z,dd&lm-Z-dd'lm.Z.dd(lm/Z/dd)lm0Z0dd*lm1Z1dd+lm2Z2ed,e -Z3ed.Z4ed/d0Z5ed1d2Z6ed3Z7ed4d0Z8ejrrdd5l:m;Z;neeee0d7fZ?Gd8d9e*Z@Gd:d;e*e3ZAGd<d=e*e4e8fZBe'd>ZCdd?dd@ dpdAZD dqdBZE drdCZFdddD dsdEZGddF dtdGZHdudHZIdvdIZJdwdJZKdxdKZLdydLZMdzdMZNd{dNZOd|dOZPd}dPZQ d~ ddQZReddRZSeddSZSe dqdTZS dqdUZSe ddVZTe ddWZT ddXZTddYZUdxdZZVdxd[ZWdd\ZX dd]ZYdd^ dd_ZZdd`Z[Gdadbe*Z\edce\-Z]Gdddeee]Z^edfe\dgZ_Gdhdiee_Z`edjee dke f-ZaGdldmeeaZbGdndoZcecZdereZeedjNZfyedZeedjNZfy)) annotationsN)deque)Any)Callable)cast)Dict) ForwardRef)Generic)Iterable)Mapping)NewType)NoReturn)Optional)overload)Set)Tuple)Type) TYPE_CHECKING)TypeVar)Union)compatT) 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_co) covariant _KT_contra) contravariant_VT_VT_co)NoneTypeNonezGenericProtocol[Any]ceZdZUdZded<y)ArgsTypeProtocolz_protocol for types that have ``__args__`` there's no public interface for this AFAIK Tuple[_AnnotationScanType, ...]__args__N__name__ __module__ __qualname____doc____annotations__?D:\EasyAligner\venv\Lib\site-packages\sqlalchemy/util/typing.pyr8r8Us .-rBr8c&eZdZUdZded<ded<y)GenericProtocolzXprotocol for generic types. this since Python.typing _GenericAlias is private r9r:Type[_T] __origin__Nr;rArBrCrErE_s .-rBrEceZdZddZddZy)SupportsKeysAndGetItemcyNrA)selfs rCkeyszSupportsKeysAndGetItem.keystsSrBcyrKrA)rL_SupportsKeysAndGetItem__ks rC __getitem__z"SupportsKeysAndGetItem.__getitem__vssrBN)returnz Iterable[_KT])rOr.rQr4)r<r=r>rMrPrArBrCrIrIss(2rBrI*Fstr_cleanup_fninclude_generic _already_seencl|}t|r |j}t|trr |}t |}rht |r]t |sR t|vr|Sj|tfd|jD}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. locals_in_classc 3BK|]}t|yw)rSN)de_stringify_annotation).0elemrVclsrUrYoriginating_modulerTs rC z*de_stringify_annotation..s<  , $"- /+  ,s) is_fwd_ref__forward_arg__ isinstancestreval_expression is_generic is_literalsetaddtupler:_copy_generic_annotation_with) r_ annotationr`rYrTrUrVoriginal_annotationelementss ` ````` rCr\r\}s.%*// *c" ' 4FGJ$ *Gc  z ":&  EM  & ' &   j )   #++   -ZBB rBc t|rt|tttt j t jt jt jt jfvrttjdt|sUt|jtt!|Dcgc]}t#|t$r t'|n|!c}S|Scc}w)zfCorrect dict['x', 'y'] into dict[ForwardRef('x'), ForwardRef('y')] and similar for list, set z3typing.(?:Dict|List|Set|.*Mapping|.*Sequence|.*Set))rgrdictrilistcollections_abc MutableSetMutableMappingMutableSequencer Sequencerematchrepr__class_getitem__rkrrdrer )type_r^s rCfixup_container_fwd_refsr}s 5 u      & &  * *  + +  # #  $ $   A4; % 22 !) /)34(=Jt$4G /    L s8$C) cZt|dr|j|S|j|S)N copy_with)hasattrrrG)rmros rCrlrls2z;'##H--$$X..rBrXc tj|j} |Qt |j}|j |j||j|t|||}|St|||} |S#t$r}t d|d||d}~wwxYw#t$r}t d||d}~wwxYw)NModule z9 isn't present in sys.modules; can't evaluate expression z"Could not de-stringify annotation ) sysmodules__dict__KeyError NameErrorrq setdefaultr<updateeval Exception) expression module_namerYrZ base_globalske cls_namespacermerrs rCrfrfs'*{{;'?'H'H    !2!23M  $ $X%6%6 A   .j-AJ j,@J 1 k]###-, 0  & 0 ?  s5BAB&3 B& B# BB#& C/B>>CrYcJd|vrt|||S tj|j} ||S#t$r}t d|d||d}~wwxYw#t$r?} t j|cYd}~S#t$rYnwxYwt d|d||d}~wwxYw)N.rrz2 isn't present in sys.modules; can't resolve name zCould not locate name z in module )rfrrrrrbuiltins)namerrYrrs rCeval_name_onlyrs  d{t['BB'*{{;'?'H'H  D!! k]# 6 #     $$T* *   $TF+k] C   sJ7A AAA B"$A<6B"< BBBBB"cX t||}t|d|S#t$r|cYSwxYw)Nr<)rgetattrr)rrobjs rCresolve_name_to_real_class_namer>s:.T;/sJ--  s  ))cD|duxrt|tjvSrK)r _type_tuplesrr|s rC is_pep593rGs"   LE!2l6L6L!LLrBcht|tjxrt|ttf SrK)rdrsr rebytes)rs rCis_non_string_iterablerKs1 c?33 4 Z c5\>:rBc8t|tjvSrK)rrr rs rCrhrhQs e  4 4 44rBct|dS)N __supertype__rrs rC is_newtyperUs 5/ **rBc6t|dxr t|dS)Nr:rGrrs rCrgrg]s 5* % F'%*FFrBcvt|rt|jSt|tj SrK)rg is_pep695rGrd_type_instancesr)rs rCrras0 %))** e_:: ;;rBcd|j}t|r|j}t|r|SrK)rr)r| super_types rCflatten_newtyperks0$$J Z --  Z rBc:tfd|}t|trot}t|}|rV|j }t|tr|j |n!|j |tthvrdn||rV|S|hS)zExtracts 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|vr|Sj|t|s|S|j}t|s|S|jDcgc] }| c}Scc}wrK)rjr __value__is_unionr:) inner_typevaluet_seenrecursive_values rCrz&pep695_values..recursive_value{se    *$ $$L,1NN;Nq"N;;;s AN) rirdrrrpopleftextendrjr5NoneFwd)r|restypesstackrrrs @@rC pep695_valuesrrs EE < % C#tc  A!T" Q !'':":$B   u rBcrt|tryt|tjry|r)t |rt fd|j DSy)NTc3:K|]}t|dyw)T)check_for_plain_stringN)rb)r]argrs rCrazis_fwd_ref..s/ & T2H  &sF)rdrerr rganyr:)r| check_genericrs `rCrbrbsV *UC"8 E?55 6 :e, ~~    rBcyrKrArs rCde_optionalize_union_typesrs36rBcyrKrArs rCrrs?BrBcyrKrArs rCrrrBct|r t|dSt|rt|rtj rt |j}n{t|g}t }|rR|j}|jD]0}t|r|j| |j|2|rR|jd|jt|jtt|S|S)zGiven 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) FN)rb#_de_optionalize_fwd_ref_union_typesr includes_nonerpy39rir:rrappendrjdiscardr5rmake_union_type)r|typstack_of_unionsu_typr^s rCrrs%25%@@ %]51 ;;enn%C$UGnO%C!'//1!NND~'..t4 +" KK  H G$$ rBcyrKrAr|return_has_nones rCrrs rBcyrKrArs rCrrrrBc|j}tjd|}|r^|jdj dd}|dk(r|rdSt |jdS|dk(r d |jdvrg}g}d }|jdD]r}|d k(r|dz }nT|d k(r|dz}nI|d k(rD|d k(r?|j d j|j|jb|j |tn%tjd|jd}|D cgc]} | dk7s t | } } |rt|t| k7S| rt| StS|rdS|Stjd|} d| v} |r| S| r+djd| D} | r t | StS|Scc} w)zreturn 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^(.+?)\[(.+)\]$rrrTr[r],z,\s*r6Fz\s*\|\s*|c3,K|] }|dk7s |yw)r6NrA)r]ps rCraz6_de_optionalize_fwd_ref_union_types..sB{!a6kA{s ) rcrxrygroupsplitr rjoinstripclearlenrr*)r|rrmmmg1rocurrent ignore_commacharr^parts pipe_tokenshas_noneanno_strs rCrrs&&J $j 1B XXa[  s #B '  *4 G 288A;0G G 7]bhhqk!&(%' HHQKDs{$) $) %*ts{ (8(>(>(@A  NN4((88GRXXa[92:M($dfnZ%(EM8}E 2227.BUB+5 6 6((; 3K$H88B{BB'/z(#:U: L!Ns ; G Gc,tj|S)zMake a Union type.)rrP)rs rCrr$s   U ##rBct|r t|dSt|rtdt |DSt |rt t |dSt|rtdt|DSt|rt |jS |ttdfvS#t$rYywxYw)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 Tc32K|]}t|ywrKrr]rs rCraz includes_none..8s=_=#_rc32K|]}t|ywrKrrs rCraz includes_none..<sB-A=#-ArNF)rbrrrrrrrrrrrr5 TypeErrorrs rCrr)s%25$??=Xe_===Xe_Q/00B]5-ABBB%U0011(D111  s'B66 CCct|txsBt|dxs4|jdvxs$t|jdjdvS)NrG)typingtyping_extensionsr)rdtyperr=__mro__rs rC is_a_typerHs\5$ P 5, ' P   > > P ;  q ! , ,0O O rBct|ddS)Nr UnionType) is_origin_ofrs rCrrQs w 44rBcZt|}|yt|txr t||S)z[return True if the given type has an __origin__ that shares a base with the given classF)rrdr issubclass)r| class_objorigins rCis_origin_of_clsrUs/  F ~ fd # E 69(EErB)modulec~t|}|yt||vxr!|duxs|jj|S)z\return True if the given type has an __origin__ with the given name and optional module.NF)r_get_type_namer= startswith)r|rnamesrs rCrrbsJ  F ~ & !U * $>&++66v>rBcvtjr |jSt|dd}| t|dd}|S)Nr<_name)rpy310r<r)r|typ_names rCr r qs: ||~~5*d3  ugt4HrBc$eZdZddZddZddZy)DescriptorProtocyrKrArLinstanceowners rC__get__zDescriptorProto.__get__}sCrBcyrKrArLrrs rC__set__zDescriptorProto.__set__s#rBcyrKrArLrs rC __delete__zDescriptorProto.__delete__srBN)robjectrrrQr)rrrrrQr6rrrQr6)r<r=r>rrrrArBrCrr|s ?=4rBr_DESCc.eZdZdZer ddZddZddZyy) DescriptorReferenceaa 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 cyrKrArs rCrzDescriptorReference.__get__#rBcyrKrArs rCrzDescriptorReference.__set__rBcyrKrArs rCrzDescriptorReference.__delete__SrBN)rrrrrQr)rrrrrQr6rr<r=r>r?rrrrrArBrCr!r!sEC8 rBr!_DESC_co)r-r0c.eZdZdZer ddZddZddZyy) RODescriptorReferenceza 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 cyrKrArs rCrzRODescriptorReference.__get__sSrBcyrKrArs rCrzRODescriptorReference.__set__r#rBcyrKrArs rCrz RODescriptorReference.__delete__srBN)rrrrrQr))rrrrrQr)rrrQrr(rArBrCr+r+sHE< rBr+_FN.c.eZdZdZer ddZddZddZyy) CallableReferenceza descriptor that refers to a callable. works around mypy's limitation of not allowing callables assigned as instance variables cyrKrArs rCrzCallableReference.__get__r%rBcyrKrArs rCrzCallableReference.__set__scrBcyrKrArs rCrzCallableReference.__delete__r'rBN)rrrrrQr/)rrrr/rQr6rr(rArBrCr1r1sCA8 rBr1ceZdZddZy)_TypingInstancescttt|dtt|dfDchc]}||c}}|s t |||j |<|Scc}wrK)rkrrrAttributeErrorr)rLkeyrrs rC __getattr__z_TypingInstances.__getattr__swFC.-sD9 A=     % %" c  s AN)r9rerQztuple[type, ...])r<r=r>r:rArBrCr6r6srBr6)r_ Type[Any]rm_AnnotationScanTyper`rerYzMapping[str, Any]rTz#Optional[Callable[[str, str], str]]rUboolrVzOptional[Set[Any]]rQr;)r|r<rQr<)rmzGenericProtocol[_T]ror9rQrF) rrerrerYOptional[Mapping[str, Any]]rZzOptional[Type[Any]]rQr)rrerrerYr>rQr)rrerrerQre)r|z Optional[Any]rQr=)rrrQzTypeGuard[Iterable[Any]])r|rrQr=)r|zOptional[_AnnotationScanType]rQzTypeGuard[NewType])r|r<rQzTypeGuard[GenericProtocol[Any]])r|r<rQzTypeGuard[TypeAliasType])r|r rQr;)r|r<rQzSet[Any])FF)r|r<rr=rr=rQzTypeGuard[ForwardRef])r|rerQre)r|r;rQr;)r|r rz Literal[True]rQr=)r|r rzLiteral[False]rQr<)r|r rr=rQz Union[_AnnotationScanType, bool])rr<rQr;)r|rrQzTypeGuard[ArgsTypeProtocol])r|rrz'Union[Tuple[Type[Any], ...], Type[Any]]rQr=)r|rr rerz Optional[str]rQr=)r|r;rQre)g __future__rr collectionsrcollections.abcabcrsrxrrrrrrr r r r r rrrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r.r/r1r3r4rrr5rrrer<r8rErI _LiteralStarr\r}rlrfrrrrrhrrgrrrrbrrrrrrrrr rrr!r)r+r/r1r6rr LITERAL_TYPESrArBrCrEs#)  8<106:4<86@888.@0@ T en T * \ 6  en T * <<+DzH V IsJ8NN .x.hrl(3Xc6k23s| ;?!(,D D#DD D 8 DD&DDN& &&R/#//N/ /,0$( !!!) ! " !  !P,0  )   D.M 5+G<"N #( ! ( 6 6 B B    & &&R  (5     (6  3 3(,3%3l$ >5 F  FB F  F6:    %2   5h5 /9'%.9( :_ E=GH-="e8HS#X$6789 9$$ ! 'O$$ #O$$ rB