lgQPSSKJr SSKrSSKJr SSKJr SSKrSSK r SSK r SSK J r SSK J r SSK J r SSK Jr SSK Jr SS K Jr SS K Jr SS K Jr SS K Jr SS K Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSKJr SSKJ r SSKJ!r! SSKJ"r" SSKJ#r# SSKJ$r$ SSKJ%r% SSKJ&r& SS KJ'r' SS!KJ(r( SS"KJ)r) SS#KJ*r* SS$KJ+r+ SS%KJ,r, SS&KJ-r- SS'KJ.r. SS(KJ/r/ SS)KJ0r0 SS*KJ1r1 \"S+\ S,9r2\"S-5r3\"S.SS/9r4\"S0SS19r5\"S25r6\"S3SS/9r7\Rp(a\9"\ RN\'/5r:O \9"\'/5r:\Rv(aSS4K"S5r=\"S55r?\\\ \@\\\0S64rA"S7S8\*5rB"S9S:\*\25rC"S;S<\*\3\745rD\'S=rESS>SS?.SlS@jjrFSmSAjrGSnSBjrHSSSC.SoSDjjrISSE.SpSFjjrJSqSGjrKSrSHjrLSsSIjrMStSJjrNSuSKjrOSvSLjrPSwSMjrQSxSNjrRSySOjrSSzS{SPjjrT\S|SQj5rU\S}SRj5rU\SmSSj5rUSmSTjrU\S~SUj5rV\SSVj5rVSSWjrVSSXjrWStSYjrXSSZjrYSS[jrZSS\.SS]jjr[SS^jr\"S_S`\*5r]\"Sa\]S,9r^"SbSc\\^5r_\"Sd\]SSe9r`"SfSg\\`5ra\"Sh\\ Si\ 4S,9rb"SjSk\\b5rcg)) 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]c$\rSrSr%SrS\S'Srg)ArgsTypeProtocolZzWprotocol for types that have ``__args__`` there's no public interface for this AFAIK Tuple[_AnnotationScanType, ...]__args__N__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__r;^/Users/Alptekin/Desktop/izin_takip/venv/lib/python3.13/site-packages/sqlalchemy/util/typing.pyr7r7Zs .-rDr7c.\rSrSr%SrS\S'S\S'Srg) GenericProtocoldzPprotocol for generic types. this since Python.typing _GenericAlias is private r9r:Type[_T] __origin__r;Nr<r;rDrErGrGds .-rDrGc(\rSrSrSSjrSSjrSrg)SupportsKeysAndGetItemxcgNr;)selfs rEkeysSupportsKeysAndGetItem.keysysSrDcgrOr;)rP_SupportsKeysAndGetItem__ks rE __getitem__"SupportsKeysAndGetItem.__getitem__{ssrDr;N)returnz Iterable[_KT])rTr-rWr3)r=r>r?r@rQrUrCr;rDrErLrLxs(2rDrL*Fstr_cleanup_fninclude_generic _already_seenc^^^^^^Un[U5(a URn[U[5(aT(a T"UT5n[ UTTTS9nT(au[ U5(ae[ U5(dUTc [5mUT;aU$TRU5 [UUUUUU4SjUR55n[X5$U$)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 3B># UHn[TUTTTTTS9v M g7f)rYN)de_stringify_annotation).0elemr\clsr[r_originating_modulerZs rE *de_stringify_annotation..s6  , $"- /+ ,s) is_fwd_ref__forward_arg__ isinstancestreval_expression is_generic is_literalsetaddtupler:_copy_generic_annotation_with) re annotationrfr_rZr[r\original_annotationelementss ` ````` rErbrbs.%*// *c"" ' 4FGJ$ *Gc  z " ":&&  EM  & ' &   j )   #++   -ZBB rDc [U5(a[U5[[[[ R [ R[ R[ R[ R4;a[R"S[U55(d][U5R[[!U5Vs/sH%n[#U[$5(a ['U5OUPM' sn55$U$s snf)z^Correct dict['x', 'y'] into dict[ForwardRef('x'), ForwardRef('y')] and similar for list, set z3typing.(?:Dict|List|Set|.*Mapping|.*Sequence|.*Set))rnrdictrplistcollections_abc MutableSetMutableMappingMutableSequencer Sequencerematchrepr__class_getitem__rrrrkrlr )type_rds rEfixup_container_fwd_refsrs 5 u      & &  * *  + +  # #  $ $   A4;  % 22 !) /)34(=(=Jt$4G /    L s,C> cd[US5(aURU5$URU$)N copy_with)hasattrrrJ)rtrvs rErsrss5z;''##H--$$X..rDr^c[RURnUbP[ UR5nUR URU5 URU5 [XU5nU$[XU5nU$![an[ SUSU35UeSnAff=f![an[ SU<35UeSnAff=f)NModule z9 isn't present in sys.modules; can't evaluate expression z"Could not de-stringify annotation ) sysmodules__dict__KeyError NameErrorrx setdefaultr=updateeval Exception) expression module_namer_r` base_globalske cls_namespacerterrs rErmrms'*{{;'?'H'H    !2!23M  $ $X%6%6 A   .jAJ j@J 1 k]###-, 0  & 0 ?  s5BAB&3 B& B# BB#& C0CCr_cJSU;a [XUS9$[RURnX0$![an[ SUSU35UeSnAff=f![a@n[ RUsSnA$![a Of=f[ SUSU35UeSnAff=f)N.rrz2 isn't present in sys.modules; can't resolve name zCould not locate name z in module )rmrrrrrbuiltins)namerr_rrs rEeval_name_onlyr!s  d{t'BB'*{{;'?'H'H  !! k]# 6 #     $$T* *   $TF+k] C   sI4A AAA B"#A;5B"; BBBBB"cX[X5n[USU5$![a Us$f=f)Nr=)rgetattrr)rrobjs rEresolve_name_to_real_class_namerCs8.T/sJ--  s  ))c:USL=(a [U5[L$rO)rrrs rE is_pep593rLs   ?E!2i!??rDcz[U[R5=(a [U[[45(+$rO)rkrzr rlbytes)rs rEis_non_string_iterablerPs1 c?33 4 Z c5\>:rDc&[U5[;$rO)r LITERAL_TYPESrs rEroroVs e  --rDc[US5$)N __supertype__rrs rE is_newtyperZs 5/ **rDc@[US5=(a [US5$)Nr:rJrrs rErnrnbs 5* % F'%*FFrDc"[U[5$rO)rkr)rs rE is_pep695rfs e] ++rDczURn[U5(aURn[U5(aMU$rO)rr)r super_types rEflatten_newtyperjs6$$J Z --  Z rDcj^^[5mUU4SjmT"U5n[U[5(a[5n[U5nU(acUR 5n[U[5(aUR U5 O#UR U[[1;aSOU5 U(aMcU$U1$)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>UT;aU$TRU5 [U5(dU$URn[U5(dU$URVs/sH nT"U5PM sn$s snfrO)rqr __value__is_unionr:)rvaluet_seenrecursive_values rEr&pep695_values..recursive_valuezse E>L %LL,1NN;Nq"N;;;sA.N) rprkryrpopleftextendrqr4NoneFwd)rrestypesstackrrrs @@rE pep695_valuesrqs EE < % C#tc  A!T"" Q !'':":$B e  u rDc^T(a[U[5(ag[U[5(agU(a/[U5(a[ U4SjUR 55$g)NTc3:># UHn[USTS9v M g7f)T)check_for_plain_stringN)ri)rcargrs rErgis_fwd_ref..s) & T2H &sF)rkrlr rnanyr:)r check_genericrs `rEririsY *UC"8"8 E: & & :e,, ~~    rDcgrOr;rs rEde_optionalize_union_typesrs36rDcgrOr;rs rErrs?BrDcgrOr;rs rErrrDcT[U5(a [US5$[U5(a[U5(a[R (a[ UR5nO[U/5n[ 5nU(a`UR5nURH7n[U5(aURU5 M&URU5 M9 U(aM`URS5 UR[5 UR[5 [U6$U$)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)ri#_de_optionalize_fwd_ref_union_typesr includes_nonerpy39rpr:rrappendrqdiscardr4rmake_union_type)rtypstack_of_unionsu_typrds rErrs%25%@@ %]511 ;;enn%C$UGnO%C!'//1!NND~~'..t4 +"/ KK  H G$$ rDcgrOr;rreturn_has_nones rErrs rDcgrOr;rs rErrrrDc"URn[R"SU5nU(GaURS5R S5SnUS:Xa#U(aS$[ URS55$US:XGa$S URS5;a/n/nS nURS5HxnUS :XaUS- nOXUS :XaUS-nOLUS :XaFUS :Xa@UR S RU5R55 UR5 MgUR U5 Mz O&[R"SURS55nUV s/sHoS:wdM [ U 5PM n n U(a[U5[U 5:g$U (a[U 6$[$U(aS$U$[R"SU5n SU ;n U(aU $U (a0SRSU 55n U (a [ U 5$[$U$s sn f)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*|c34# UHoS:wdM Uv M g7f)r5Nr;)rcps rErg6_de_optionalize_fwd_ref_union_types..sB{!6kAA{s  ) rjrrgroupsplitr rjoinstripclearlenrr*)rrrtmmg1rvcurrent ignore_commacharrdparts pipe_tokenshas_noneanno_strs rErrs&&J $j 1B XXa[  s #B '  *4 G 288A;0G G 7]bhhqk!&(%' HHQKDs{$) $) %*ts{ (8(>(>(@A  NN4((88GRXXa[92:M($fn%Z%(EM8}E 2227.BUB+5 6 6((; 3K$H88B{BB'/z(#:U: L!Ns  H H c.[R"U5$)zMake a Union type.)rrU)rs rErr#s   U ##rDc[U5(a [US5$[U5(a[S[ U555$[ U5(a[ [ U5S5$[U5(a[S[U555$[U5(a[ UR5$U[[S4;$)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 Tc38# UHn[U5v M g7frOrrcrs rErg includes_none..7s=_=##_rc38# UHn[U5v M g7frOrrs rErgr;sB-A=##-ArN) rirrrrrrrrrrrr4rs rErr(s%25$??=Xe_===Xe_Q/00B]5-ABBB%U0011 Wh- --rDc[USS5$)Nr UnionType) is_origin_ofrs rErrAs w 44rDcd[U5nUcg[U[5=(a [X!5$)zWreturn True if the given type has an __origin__ that shares a base with the given classF)rrktype issubclass)r class_objorigins rEis_origin_of_clsr Es-  F ~ fd # E 6(EErD)modulec[U5nUcg[U5U;=(a& USL=(d URRU5$)zXreturn True if the given type has an __origin__ with the given name and optional module.NF)r_get_type_namer> startswith)rr namesrs rErrRsJ  F ~ & !U * $>&++66v>rDc[R(a UR$[USS5nUc [USS5nU$)Nr=_name)rpy310r=r)rtyp_names rEr r as: ||~~5*d3  ugt4HrDc2\rSrSrSSjrSSjrS SjrSrg) DescriptorProtoilcgrOr;rPinstanceowners rE__get__DescriptorProto.__get__msCrDcgrOr;rPrrs rE__set__DescriptorProto.__set__os#rDcgrOr;rPrs rE __delete__DescriptorProto.__delete__qsrDr;N)robjectrrrWr)rrrrrWr5rrrWr5)r=r>r?r@rrr!rCr;rDrErrls ?=4rDr_DESCcJ\rSrSrSr\(aSSjrS SjrS SjrSr gSr g) DescriptorReferenceiwara 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 cgrOr;rs rErDescriptorReference.__get__#rDcgrOr;rs rErDescriptorReference.__set__rDcgrOr;r s rEr!DescriptorReference.__delete__SrDr;N)rr#rrrWr%)rrrr%rWr5r$ r=r>r?r@rArrrr!rCr;rDrEr'r'wsEC8 rDr'_DESC_co)r,r/cJ\rSrSrSr\(aSSjrS SjrS SjrSr gSr g) RODescriptorReferenceiza 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 cgrOr;rs rErRODescriptorReference.__get__sSrDcgrOr;rs rErRODescriptorReference.__set__r*rDcgrOr;r s rEr! RODescriptorReference.__delete__srDr;N)rr#rrrWr2)rrrrrWr)rrrWrr1r;rDrEr4r4sHE< rDr4_FN.cJ\rSrSrSr\(aSSjrS SjrS SjrSr gSr g) CallableReferenceiza descriptor that refers to a callable. works around mypy's limitation of not allowing callables assigned as instance variables cgrOr;rs rErCallableReference.__get__r-rDcgrOr;rs rErCallableReference.__set__scrDcgrOr;r s rEr!CallableReference.__delete__r0rDr;N)rr#rrrWr;)rrrr;rWr5r$r1r;rDrEr=r=sCA8 rDr=)re Type[Any]rt_AnnotationScanTyperfrlr_zMapping[str, Any]rZz#Optional[Callable[[str, str], str]]r[boolr\zOptional[Set[Any]]rWrD)rrErWrE)rtzGenericProtocol[_T]rvr9rWrI) rrlrrlr_Optional[Mapping[str, Any]]r`zOptional[Type[Any]]rWr)rrlrrlr_rGrWr)rrlrrlrWrl)rz Optional[Any]rWrF)rrrWzTypeGuard[Iterable[Any]])rrrWrF)rzOptional[_AnnotationScanType]rWzTypeGuard[NewType])rrErWzTypeGuard[GenericProtocol[Any]])rrErWzTypeGuard[TypeAliasType])rr rWrD)rrErWzSet[Any])FF)rrErrFrrFrWzTypeGuard[ForwardRef])rrlrWrl)rrDrWrD)rr rz Literal[True]rWrF)rr rzLiteral[False]rWrE)rr rrFrWz Union[_AnnotationScanType, bool])rrErWrD)rrrWzTypeGuard[ArgsTypeProtocol])rrrz'Union[Tuple[Type[Any], ...], Type[Any]]rWrF)rrrrlr z Optional[str]rWrF)rrDrWrl)d __future__rr collectionsrcollections.abcabcrzrrtypingrrrrr r r r r rrrrrrrrrrrtyping_extensionsrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r-r.r0r2r3py38 frozensetrrrr4rrrlrEr7rGrL _LiteralStarrbrrsrmrrrrrorrnrrrrirrrrrr rr rr%r'r2r4r;r=r;rDrErQs#)  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 9rD