gQ$ddlmZddlZddlmZddlmZddlZddl 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 mZddlmZ 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*lm1Z1ed+e ,Z2ed-Z3ed.d/Z4ed0d1Z5ed2Z6ed3d/Z7ejpre9e jNe'gZ:n e9e'gZ:ejvrdd4ldZ=ed5Z?eee e@eee0d6fZAGd7d8e*ZBGd9d:e*e2ZCGd;ddd? dld@ZF dmdAZG dndBZHdddC dodDZIddE dpdFZJdqdGZKdrdHZLdsdIZMdtdJZNdudKZOdvdLZPdwdMZQdxdNZRdydOZS dz d{dPZTed|dQZUed}dRZUe dmdSZU dmdTZUe d~dUZVe ddVZV ddWZVddXZWdtdYZXddZZY dd[ZZdd\ dd]Z[dd^Z\Gd_d`e*Z]edae],Z^Gdbdcee^Z_edde]deZ`Gdfdgee`Zaedhee die f,ZbGdjdkeebZcy)) 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_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__U/var/www/html/AdoubleTech/venv/lib/python3.12/site-packages/sqlalchemy/util/typing.pyr7r7Zs .-rAr7c&eZdZUdZded<ded<y)GenericProtocolzXprotocol for generic types. this since Python.typing _GenericAlias is private r8r9Type[_T] __origin__Nr:r@rArBrDrDds .-rArDceZdZddZddZy)SupportsKeysAndGetItemcyNr@)selfs rBkeyszSupportsKeysAndGetItem.keysyrAcyrJr@)rK_SupportsKeysAndGetItem__ks rB __getitem__z"SupportsKeysAndGetItem.__getitem__{rMrAN)returnz Iterable[_KT])rOr-rQr3)r;r<r=rLrPr@rArBrHrHxs(2rArH*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 rB z*de_stringify_annotation..s:   $"- /+    s) is_fwd_ref__forward_arg__ isinstancestreval_expression is_generic is_literalsetaddtupler9_copy_generic_annotation_with) r_ annotationr`rYrTrUrVoriginal_annotationelementss ` ````` rBr\r\s.%*// *c" ' 4FGJ$ *Gc  z ":&  EM  & ' &   j )   #++   -ZBB rAc 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 rBfixup_container_fwd_refsr}s 5 u      & &  * *  + +  # #  $ $   A4; % 22 !))34(=Jt$4G    L s8$C) cZt|dr|j|S|j|S)N copy_with)hasattrrrF)rmros rBrlrls2z;'##H--$$X..rArXc 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 rBrfrfs'*{{;'?'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 rBeval_name_onlyr!s  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 rBresolve_name_to_real_class_namerCs:.T;/sJ--  s  ))c0|duxrt|tuSrJ)rrr|s rB is_pep593rLs   ?E!2i!??rAcht|tjxrt|ttf SrJ)rdrsr rebytes)rs rBis_non_string_iterablerPs1 c?33 4 Z c5\>:rAc$t|tvSrJ)r LITERAL_TYPESrs rBrhrhVs e  --rAct|dS)N __supertype__rrs rB is_newtyperZs 5/ **rAc6t|dxr t|dS)Nr9rFrrs rBrgrgbs 5* % F'%*FFrAc"t|tSrJ)rdr)rs rB is_pep695rfs e] ++rAcd|j}t|r|j}t|r|SrJ)rr)r| super_types rBflatten_newtyperjs0$$J Z --  Z rAc: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}wrJ)rjr __value__is_unionr9)r|valuet_seenrecursive_values rBrz&pep695_values..recursive_valuezs\ E>L %LL,1NN;q";;;s AN) rirdrrrpopleftextendrjr4NoneFwd)r|restypesstackrrrs @@rB pep695_valuesrqs EE < % C#tc  A!T" Q !'':":$B   u rAcrt|tryt|try|r)t|rt fd|j DSy)NTc3:K|]}t|dyw)T)check_for_plain_stringN)rb)r]argrs rBrazis_fwd_ref..s-  T2H   sF)rdrer rganyr9)r| check_genericrs `rBrbrbsP *UC"8 E: & :e, ~~    rAcyrJr@rs rBde_optionalize_union_typesrs36rAcyrJr@rs rBrrs?BrAcyrJr@rs rBrrrAct|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_nonerpy39rir9rrappendrjdiscardr4rmake_union_type)r|typstack_of_unionsu_typr^s rBrrs%25%@@ %]51 ;;enn%C$UGnO%C!'//1!NN&D~'..t4 &" KK  H G$$ rAcyrJr@r|return_has_nones rBrrs rAcyrJr@rs rBrrrrAc|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*r5Fz\s*\|\s*|c3,K|] }|dk7s |yw)r5Nr@)r]ps rBraz6_de_optionalize_fwd_ref_union_types..sB!a6kABs ) rcrxrygroupsplitr rjoinstripclearlenrr*)r|rrmmmg1rocurrent ignore_commacharr^parts pipe_tokenshas_noneanno_strs rBrrs&&J $j 1B XXa[  s #B '  *4 G 288A;0G G 7]bhhqk!&(%' HHQK )Ds{$) $) %*ts{ (8(>(>(@A  NN4( )88GRXXa[92:M$dfnZ%MEM8}E 2227.BUB+5 6 6((; 3K$H88B{BB'/z(#:U: L!Ns ; G Gc,tj|S)zMake a Union type.)rrP)rs rBrr#s   U ##rAcjt|r t|dSt|rtdt |DSt |rt t |dSt|rtdt|DSt|rt |jS|ttdfvS)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|ywrJrr]rs rBraz includes_none..7s==#=rc32K|]}t|ywrJrrs rBraz includes_none..;sB=#BrN) rbrrrrrrrrrrrr4rs rBrr(s%25$??=Xe_===Xe_Q/00B]5-ABBB%U0011 Wh- --rAct|ddS)Nr UnionType) is_origin_ofrs rBrrAs w 44rAcZt|}|yt|txr t||S)z[return True if the given type has an __origin__ that shares a base with the given classF)rrdtype issubclass)r| class_objorigins rBis_origin_of_clsrEs/  F ~ fd # E 69(EErA)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 rBrrRsJ  F ~ & !U * $>&++66v>rAcvtjr |jSt|dd}| t|dd}|S)Nr;_name)rpy310r;r)r|typ_names rBrras: ||~~5*d3  ugt4HrAc$eZdZddZddZddZy)DescriptorProtocyrJr@rKinstanceowners rB__get__zDescriptorProto.__get__mrMrAcyrJr@rKr rs rB__set__zDescriptorProto.__set__orMrAcyrJr@rKr s rB __delete__zDescriptorProto.__delete__qrMrAN)r objectr rrQr)r rrrrQr5r rrQr5)r;r<r=rrrr@rArBr r ls ?=4rAr _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 cyrJr@r s rBrzDescriptorReference.__get__rMrAcyrJr@rs rBrzDescriptorReference.__set__rMrAcyrJr@rs rBrzDescriptorReference.__delete__rMrAN)r rr rrQr)r rrrrQr5rr;r<r=r>rrrrr@rArBrrwsEC8 rAr_DESC_co)r,r/c.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 cyrJr@r s rBrzRODescriptorReference.__get__rMrAcyrJr@rs rBrzRODescriptorReference.__set__rMrAcyrJr@rs rBrz RODescriptorReference.__delete__rMrAN)r rr rrQr)r rrrrQr)r rrQrrr@rArBr r sHE< rAr _FN.c.eZdZdZer ddZddZddZyy) CallableReferenceza descriptor that refers to a callable. works around mypy's limitation of not allowing callables assigned as instance variables cyrJr@r s rBrzCallableReference.__get__rMrAcyrJr@rs rBrzCallableReference.__set__rMrAcyrJr@rs rBrzCallableReference.__delete__rMrAN)r rr rrQr$)r rrr$rQr5rrr@rArBr&r&sCA8 rAr&)r_ Type[Any]rm_AnnotationScanTyper`rerYzMapping[str, Any]rTz#Optional[Callable[[str, str], str]]rUboolrVzOptional[Set[Any]]rQr*)r|r+rQr+)rmzGenericProtocol[_T]ror8rQrE) 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|rrrerz Optional[str]rQr,)r|r*rQre)d __future__rr collectionsrcollections.abcabcrsrxrtypingrrrrr r r r r rrrrrrrrrrrtyping_extensionsrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r-r.r0r2r3py38 frozensetrrrr4rrrer+r7rDrH _LiteralStarr\r}rlrfrrrrrhrrgrrrrbrrrrrrrrr rrrr r$r&r@rArBr7s#)  8<106:4<86@888.@0 T en T * \ 6  en T * ;;v~~w78Mwi(M <<+DzH V IsJ8NN .x.hrl(3Xc6k23s| ;?!(,D D#DD D 8 DD&DDN& &&R/#//N/ /,0$( !!!) ! " !  !P,0  )   D.@ .+G,"N #( ! ( 6 6 B B    & &&R  (5     (6  3 3(,3%3l$ .25 F  FB F  F6:    %2   5h5 /9'%.9( :_ E=GH-="e8HS#X$6789 9rA