[hqWFddlmZddlZddlmZddlmZddlZddl 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/d0Z5ed1d2Z6ed3Z7ed4d0Z8ej9rdd5l:m;Z;n eeee0d7fZ?Gd8d9e*Z@Gd:d;e*e3ZAGd<d=e*e4e8fZBe'd>ZCdd?dd@ddPZDddRZEddWZFdddXdd_ZGdd`ddbZHddcZIddeZJddhZKddiZLddlZMddnZNddpZOddrZPddtZQ dddxZReddyZSeddzZSedd{ZSdd|ZSeddZTeddZTddZTddZUddZVddZWddZXddZYddddZZddZ[Gdde*Z\ede\-Z]Gddee]Z^ede\dZ_Gddee_Z`edee de f-ZaGddeeaZbGddZcecZdereZenedZeedj'ZfdS)) 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<dS)ArgsTypeProtocolz_protocol for types that have ``__args__`` there's no public interface for this AFAIK Tuple[_AnnotationScanType, ...]__args__N__name__ __module__ __qualname____doc____annotations__e/var/www/api.easyaligner.net/htdocs/venv_linux/lib/python3.11/site-packages/sqlalchemy/util/typing.pyr9r9Us* .-----rCr9c(eZdZUdZded<ded<dS)GenericProtocolzXprotocol for generic types. this since Python.typing _GenericAlias is private r:r;Type[_T] __origin__Nr<rBrCrDrFrF_s6 .---rCrFceZdZd dZd dZdS) SupportsKeysAndGetItemreturn Iterable[_KT]cdSNrB)selfs rDkeyszSupportsKeysAndGetItem.keystrC_SupportsKeysAndGetItem__kr/r5cdSrNrB)rOrRs rD __getitem__z"SupportsKeysAndGetItem.__getitem__vrQrCN)rKrL)rRr/rKr5)r=r>r?rPrTrBrCrDrJrJss(((((222222rCrJ*Fstr_cleanup_fninclude_generic _already_seencls Type[Any] annotation_AnnotationScanTypeoriginating_modulestrlocals_Mapping[str, Any]rW#Optional[Callable[[str, str], str]]rXboolrYOptional[Set[Any]]rKc|}t|r|j}t|tr!r |}t |}r~t |rot |s`t|vr|S|tfd|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 3DK|]}t|VdS)rVN)de_stringify_annotation).0elemrYrZrXr`r^rWs rD z*de_stringify_annotation..s]    $"- /+          rC) is_fwd_ref__forward_arg__ isinstancer_eval_expression is_generic is_literalsetaddtupler;_copy_generic_annotation_with) rZr\r^r`rWrXrYoriginal_annotationelementss ` ````` rDriri}sE.%*0/ *c""  H' 4FGGJ$ *Gc   C z " "C:&&C  EEM  & & ' &   j ) ) )          #+      -ZBBB rCtype_c t|rt|tttt jt jt jt j t j fvrhtj dt|sFt|tdt!|DS|S)zfCorrect dict['x', 'y'] into dict[ForwardRef('x'), ForwardRef('y')] and similar for list, set z3typing.(?:Dict|List|Set|.*Mapping|.*Sequence|.*Set)cZg|](}t|trt|n|)SrB)ror_r rjrks rD z,fixup_container_fwd_refs..sD)34(=(=GJt$$$4rC)rqr dictrslistcollections_abc MutableSetMutableMappingMutableSequencer Sequencerematchrepr__class_getitem__rurrys rDfixup_container_fwd_refsrs 5 u       &  *  +  #  $   A4;;   (%  22  (      LrCGenericProtocol[_T]rxr:rGcft|dr||S|j|S)N copy_with)hasattrrrH)r\rxs rDrvrvs:z;''/##H---$X..rCrf expression module_nameOptional[Mapping[str, Any]]rgOptional[Type[Any]]rc tj|j}n(#t$r}t d|d||d}~wwxYw |Vt |j}||j|||t|||}nt|||}|S#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 NameErrorr~ setdefaultr=updateeval Exception) rrr`rg base_globalske cls_namespacer\errs rDrprps#'*{;'?'H  0k 0 0#- 0 0       !233M  $ $X%6 A A A   . . .j-AAJJj,@@J   ? ? ?   s) ?:?A)B.. C8C  Cr`namecbd|vrt|||S tj|j}n(#t$r}t d|d||d}~wwxYw ||S#t$rC} 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 )rprrrrrbuiltins)rrr`rrs rDeval_name_onlyrs'  d{{t['BBBB'*{;'?'H  #k # #  # #    D!!     $T* * * * * * *    D  CT C Ck C C    sJ0 AAAA!! B.,B=B. B B)BB))B.cj t||}t|d|S#t$r|cYSwxYw)Nr=)rgetattrr)rrobjs rDresolve_name_to_real_class_namer>sP.T;//sJ---  s # 22 Optional[Any]c@|duot|tjvSrN)r _type_tuplesrrs rD is_pep593rGs"   LE!2!2l6L!LLrCrTypeGuard[Iterable[Any]]cpt|tjot|ttf SrN)rorr r_bytes)rs rDis_non_string_iterablerKs6 c?3 4 4 Z c5\>>:rCc8t|tjvSrN)r rr!rs rDrrrrQs e   4 44rCOptional[_AnnotationScanType]TypeGuard[NewType]c"t|dS)N __supertype__rrs rD is_newtyperUs 5/ * **rCTypeGuard[GenericProtocol[Any]]cBt|dot|dS)Nr;rHrrs rDrqrq]s! 5* % % F'%*F*FFrCTypeGuard[TypeAliasType]c|t|rt|jSt|tjSrN)rq is_pep695rHro_type_instancesr*rs rDrras8 %+)*** e_: ; ;;rCrc^|j}t|r|j}t||SrN)rr)ry super_types rDflatten_newtyperks:$J Z .-  Z . rCSet[Any]ctfd|}t|trt}t|}|rh|}t|tr||n'||tthvrdn||h|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|S|t|s|S|j}t|s|Sfd|jDS)Nc&g|] }|SrBrB)rjtrecursive_values rDr}z:pep695_values..recursive_value..s#;;;q"";;;rC)rtr __value__is_unionr;) inner_typevalue_seenrs rDrz&pep695_values..recursive_value{su     *$$  $ L;;;;EN;;;;rCN) rsrorrpopleftextendrtr6NoneFwd)ryrestypesstackrrrs @@rD pep695_valuesrrs EEE < < < < < < /% C#t c  C A!T"" C Q !'':":":$$BBB  C  u rC check_genericcheck_for_plain_stringTypeGuard[ForwardRef]crt|trdSt|tjrdS|r/t |r t fd|jDSdS)NTc3<K|]}t|dVdS)T)rN)rm)rjargrs rDrlzis_fwd_ref..sP   T2H         rCF)ror_rr rqanyr;)ryrrs `rDrmrms  *UC"8"8 t E?5 6 6 t :e,,    ~       urCcdSrNrBrs rDde_optionalize_union_typesrs363rCcdSrNrBrs rDrrs?BsrCcdSrNrBrs rDrr #rCcZt|rt|dSt|rt|rtjrt |j}nt|g}t }|rZ| }|jD]<}t|r| |'| |=|Z| d| t| tt|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)rm#_de_optionalize_fwd_ref_union_typesr includes_nonerpy39rsr;rrappendrtdiscardr6rmake_union_type)rytypstack_of_unionsu_typrks rDrrs(%25%@@@ %]511 ; en%%CC$UGnnO%%C! &'//11!N&&D~~&'..t4444 " & KK    H G$$ rCr return_has_none Literal[True]cdSrNrBryrs rDrrs  3rCLiteral[False]cdSrNrBrs rDrrrrC Union[_AnnotationScanType, bool]c |j}tjd|}|r|ddd}|dkr&|rdn!t |dS|dkr&d |dvrg}g}d }|dD]}|d kr|dz }ng|d kr|dz}n[|d krU|d krO|d || u||n(tjd|d}d|D} |r t|t| kS| r t| ntS|rdn|Stjd|} d| v} |r| S| r7dd| D} | rt | ntS|S)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*c8g|]}|dkt|S)r7r r|s rDr}z7_de_optionalize_fwd_ref_union_types..s%MMM$dfnnZ%%nnnrCFz\s*\|\s*r7|c3&K|] }|dk|V dS)r7NrB)rjps rDrlz6_de_optionalize_fwd_ref_union_types..s&BB!a6kkAkkkkBBrC) rnrrgroupsplitr rjoinstripclearlenrr+) ryrr\mmg1rxcurrent ignore_commacharparts pipe_tokenshas_noneanno_strs rDrrs,&J $j 1 1B 7 XXa[[  s # #B '   *G44 288A;;0G0G G 7]]bhhqkk!!&(%' HHQKK ) )Ds{{$) $) %**ts{{ (8(8(>(>(@(@AAA  NN4(((( )8GRXXa[[99MM(MMME C8}}E 2227B..UB+655 6(; 33K$H;88BB{BBBBB'/:z(###U: LrCrc*tj|S)zMake a Union type.)rrT)rs rDrr$s  U # ##rCct|rt|dSt|r&tdt |DSt |r"t t |dSt|r&tdt|DSt|rt |j S |ttdfvS#t$rYdSwxYw)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 Tc34K|]}t|VdSrNrrjrs rDrlz includes_none..8s*===##======rCrc34K|]}t|VdSrNrrs rDrlz includes_none..<s*BB=##BBBBBBrCNF)rmrrrrrrrrrrrr6 TypeErrorrs rDrr)s%@25$???>==Xe__======1Xe__Q/000CBB]5-A-ABBBBBB%2U0111(D111 uu sC00 C>=C>ct|tp9t|dp)|jdvp t|jdjdvS)NrH)typingtyping_extensionsr)rotyperr>__mro__rs rD is_a_typerHs[5$ P 5, ' ' P  > > P ;; q ! ,0O O rCTypeGuard[ArgsTypeProtocol]c$t|ddS)Nr UnionType) is_origin_ofrs rDrrQs w 4 44rC class_obj'Union[Tuple[Type[Any], ...], Type[Any]]crt|}|dSt|tot||S)z[return True if the given type has an __origin__ that shares a base with the given classNF)r ror issubclass)ryrorigins rDis_origin_of_clsr#Us:   F ~u fd # # E 69(E(EErC)modulenamesr$ Optional[str]ct|}|dSt||vo|dup|j|S)z\return True if the given type has an __origin__ with the given name and optional module.NF)r _get_type_namer> startswith)ryr$r%r"s rDrrbsR   F ~u & ! !U * $>&+66v>>rCcttjr|jSt|dd}|t|dd}|S)Nr=_name)rpy310r=r)rytyp_names rDr(r(qsA |~5*d33  ugt44HrCc&eZdZd dZd d Zdd Zd S)DescriptorProtoinstanceobjectownerrrKcdSrNrBrOr0r2s rD__get__zDescriptorProto.__get__}rQrCrr7cdSrNrBrOr0rs rD__set__zDescriptorProto.__set__rQrCcdSrNrBrOr0s rD __delete__zDescriptorProto.__delete__rQrCN)r0r1r2rrKr)r0rrrrKr7r0rrKr7)r=r>r?r5r8r;rBrCrDr/r/|s4????====444444rCr/_DESCc2eZdZdZerddZdd Zdd Zd Sd S)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 r0r1r2rrKr=cdSrNrBr4s rDr5zDescriptorReference.__get__rQrCrr7cdSrNrBr7s rDr8zDescriptorReference.__set__rQrCcdSrNrBr:s rDr;zDescriptorReference.__delete__rQrCN)r0r1r2rrKr=)r0rrr=rKr7r<r=r>r?r@rr5r8r;rBrCrDr?r?sR9EEEECCCC888888 99rCr?_DESC_co)r.r1c2eZdZdZerddZdd Zdd Zd Sd S)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 r0r1r2rrKrDcdSrNrBr4s rDr5zRODescriptorReference.__get__rQrCrrcdSrNrBr7s rDr8zRODescriptorReference.__set__rQrCcdSrNrBr:s rDr;z RODescriptorReference.__delete__rQrCN)r0r1r2rrKrD)r0rrrrKr)r0rrKrrCrBrCrDrFrFsR=HHHHEEEE<<<<<< ==rCrF_FN.c2eZdZdZerddZdd Zdd Zd Sd S)CallableReferenceza descriptor that refers to a callable. works around mypy's limitation of not allowing callables assigned as instance variables r0r1r2rrKrJcdSrNrBr4s rDr5zCallableReference.__get__rQrCrr7cdSrNrBr7s rDr8zCallableReference.__set__rQrCcdSrNrBr:s rDr;zCallableReference.__delete__rQrCN)r0r1r2rrKrJ)r0rrrJrKr7r<rCrBrCrDrLrLsR9CCCCAAAA888888 99rCrLceZdZddZdS)_TypingInstanceskeyr_rKtuple[type, ...]c tdtt|dtt|dfD}|st |||j|<|S)Nch|]}||SrNrBrs rD z/_TypingInstances.__getattr__..s)   =  !==rC)rurrrAttributeErrorr)rOrRrs rD __getattr__z_TypingInstances.__getattr__sy  FC..-sD99       & %% %" c rCN)rRr_rKrS)r=r>r?rXrBrCrDrQrQs(rCrQ)rZr[r\r]r^r_r`rarWrbrXrcrYrdrKr[)ryr]rKr])r\rrxr:rKrG) rr_rr_r`rrgrrKr)rr_rr_r`rrKr)rr_rr_rKr_)ryrrKrc)rrrKr)ryrrKrc)ryrrKr)ryr]rKr)ryr]rKr)ryrrKr[)ryr]rKr)FF)ryr]rrcrrcrKr)ryr_rKr_)ryr[rKr[)ryr rrrKrc)ryr rrrKr])ryr rrcrKr)rr]rKr[)ryrrKr)ryrrrrKrc)ryrr%r_r$r&rKrc)ryr[rKr_)g __future__rr collectionsrcollections.abcabcrrrrrrrrr r r r rrrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r/r0r2r4r5r,rr6rrr_r]r9rFrJ _LiteralStarrirrvrprrrrrrrrqrrrrmrrrrrrr#rr(r/r=r?rDrFrJrLrQrr LITERAL_TYPESrBrCrDr_s#"""""))))))  A888888<<<<<<100000000000666666::::::444444<<<<<<888888666666@@@@@@888888888888888888......@@@@@@000000@@@@@@ WT genn T * * * W\ 6 6 6  genn T * * * <+******tDzzH *V  IsJ8NN .....x...hrl(33333Xc6k2333s| ;?!(,DDDDDDN&&&&R////,0$( !!!!!!P,0 D....MMMM 5555++++GGGG<<<<""""N #(( 666 6 BBB B   &&&&R      3333l$$$$ >5555 F F F F6:      55555h555 ///99999'%.999( 7:_ E E E=====GH-==="ge8HS#X$6788899999 999$$ !! #'OO"O$ rC