jG<SSKJr SSKrSSKJr SSKrSSKrSSKrSSKJ r SSKJ r SSKJ r SSKJ r SSKJ r SSKJr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr 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. \"S)\ S*9r/\"S+5r0\"S,SS-9r1\"S.SS/9r2\"S05r3\"S1SS-9r4\Rj(a\6"\RJ\%/5r7O \6"\%/5r7\Rp(aSS2K9J:r: O\;"S5r:\ "S35r<\#r=\$r>\\\ \?\ \\.S44r@"S5S6\(5rA"S7S8\(\/5rB"S9S:\(\0\445rC\%S;rDSSjjrESlS?jrFSmS@jrGSSSA.SnSBjjrHSSC.SoSDjjrISpSEjrJSSF.SqSGjjrKSrSHjrLSsSIjrMStSJjrNSuSKjrOSvSLjrPSwSMjrQSxSNjrRSySzSOjjrS\S{SPj5rT\S|SQj5rT\SlSRj5rTSlSSjrTS}STjrUS~SUjrVSSSVjjrWSSWjrXSSXjrYSSYjrZSSZjr[SS[.SS\jjr\SS]jr]"S^S_\(5r^\"S`\^S*9r_"SaSb\\_5r`\"Sc\^SSd9ra"SeSf\\a5rb\"Sg\\ Sh\ 4S*9rc"SiSj\\c5rdg)) annotationsN)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_T)bound_KT_KT_co) covariant _KT_contra) contravariant_VT_VT_co)NoneTypeNonezGenericProtocol[Any]c$\rSrSr%SrS\S'Srg)ArgsTypeProcotol[zWprotocol 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__r9S/var/www/reloj-farallon/venv/lib/python3.13/site-packages/sqlalchemy/util/typing.pyr5r5[s .-rBr5c.\rSrSr%SrS\S'S\S'Srg) GenericProtocolezPprotocol for generic types. this since Python.typing _GenericAlias is private r7r8Type[_T] __origin__r9Nr:r9rBrCrErEes .-rBrEc(\rSrSrSSjrSSjrSrg)SupportsKeysAndGetItemycgNr9)selfs rCkeysSupportsKeysAndGetItem.keyszsSrBcgrMr9)rN_SupportsKeysAndGetItem__ks rC __getitem__"SupportsKeysAndGetItem.__getitem__|ssrBr9N)returnz Iterable[_KT])rRr+rUr1)r;r<r=r>rOrSrAr9rBrCrJrJys(2rBrJ*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)rWN)de_stringify_annotation).0elemrZclsrYr]originating_modulerXs rC *de_stringify_annotation..s6  , $"- /+ ,s) is_fwd_ref__forward_arg__ isinstancestreval_expression is_generic is_literalsetaddtupler8_copy_generic_annotation_with) rc annotationrdr]rXrYrZoriginal_annotationelementss ` ````` rCr`r`s.%*// *c"" ' 4FGJ$ *Gc  z " ":&&  EM  & ' &   j )   #++   -ZBB rBc [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))rltyping_get_origindictrnlistcollections_abc MutableSetMutableMappingMutableSequencer Sequencerematchrepr__class_getitem__rptyping_get_argsrirjr)type_rbs rCfixup_container_fwd_refsrs 5 e $     & &  * *  + +  # #  $ $   A4;  !'99 !0 6 6)34(=(=Jt$4G 6    L s,C> cd[US5(aURU5$URU$)N copy_with)hasattrrrH)rrrts rCrqrqs5z;''##H--$$X..rBr\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 NameErrorrw setdefaultr;updateeval Exception) expression module_namer]r^ base_globalske cls_namespacerrerrs rCrkrks'*{{;'?'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 )rkrrrrrbuiltins)namerr]rrs rCeval_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 rCresolve_name_to_real_class_namerDs8.T/sJ--  s  ))rXc h[URVs/sHn[UUU0US9PM sn6$s snf)Nr)make_union_typer8r`)rcrrrdr]rXannos rCde_stringify_union_elementsrMsQ #++ , $"-  ,    s/c:USL=(a [U5[L$rM)rvrrs rC is_pep593rcs   F!25!9Y!FFrBcz[U[R5=(a [U[[45(+$rM)riryr rjbytes)rs rCis_non_string_iterablergs1 c?33 4 Z c5\>:rBc&[U5[;$rM)r_LITERAL_TYPESrs rCrmrmms e  ..rBc[US5$)N __supertype__rrs rC is_newtyperqs 5/ **rBc@[US5=(a [US5$)Nr8rHrrs rCrlrlys 5* % F'%*FFrBc"[U[5$rM)rir(rs rC is_pep695r}s e] ++rBczURn[U5(aURn[U5(aMU$rM)rr)r super_types rCflatten_newtypers6$$J Z --  Z rBc[U[5(agU(a,[U5(a[SUR55$g)NTc3:# UHn[US5v M g7f)TN)rg)raargs rCreis_fwd_ref..sCNS:c4((NsF)rirrlanyr8)r check_generics rCrgrgs9%$$ :e,,CENNCCCrBcgrMr9rs rCde_optionalize_union_typesrs36rBcgrMr9rs rCrrs?BrBcgrMr9rs rCrrsrBc[U5(a [U5$[U5(aG[UR5nUR [ 5 UR [5 [U6$U$)zeGiven a type, filter out ``Union`` types that include ``NoneType`` to not include the ``NoneType``. ) rg"de_optionalize_fwd_ref_union_types is_optionalrnr8discardr2NoneFwdr)rtyps rCrrs]%1%88 U  %..! H G$$ rBc URn[R"SU5nU(aURS5S:Xa[ URS55$URS5S:XaO[R "SURS55n[ UVs/sHoDS:wdM [ U5PM sn6$U$[R "SU5nSU;a![ S RS U555$U$s snf) 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^(.+?)\[(.+)\]$rrrz,\s*r3z\s*\|\s*|c34# UHoS:wdM Uv M g7f)r3Nr9)raps rCre5de_optionalize_fwd_ref_union_types..s"Ik&[11ks  )rhr~rgrouprsplitrjoin)rrrmmrtrb pipe_tokenss rCrrs&&J $j 1B 88A;* $bhhqk* * XXa[G #xx!5H"/7Jxt6>"*T"xJ L((; 3K #(("Ik"IIJJ LKs  D+DcH[[[5RU5$)zxMake a Union type. This is needed by :func:`.de_optionalize_union_types` which removes ``NoneType`` from a ``Union``. )rrrrS)typess rCrrs U  ' ' ..rBc[U5(aR[UR5nU(aUR[5 U(aU4[ U5-$[ U5$U4$)zLReturn a type as a tuple of individual types, expanding for ``Union`` types.)is_unionrnr8rr2rp)r include_union discard_noners rC expand_unionsrsO %..!  KK ! 8eCj( (: xrBc[USSS5$)Nrr UnionType is_origin_ofrs rCrrs    rBcJ[U5=(a [[U5;$rM)rr2rrs rCis_optional_unionrs u  D(oe.D"DDrBc[US5$)Nrrrs rCrrs w ''rBcd[U5nUcg[U[5=(a [X!5$)zWreturn True if the given type has an __origin__ that shares a base with the given classF)rvritype issubclass)r class_objorigins rCis_origin_of_clsrs- u %F ~ fd # E 6(EErB)modulec[U5nUcg[U5U;=(a& USL=(d URRU5$)zXreturn True if the given type has an __origin__ with the given name and optional module.NF)rv_get_type_namer< startswith)rrnamesrs rCrrsJ u %F ~ & !U * $>&++66v>rBc[R(a UR$[USS5nUc [USS5nU$)Nr;_name)rpy310r;r)rtyp_names rCrr"s: ||~~5*d3  ugt4HrBc2\rSrSrSSjrSSjrS SjrSrg) DescriptorProtoi-cgrMr9rNinstanceowners rC__get__DescriptorProto.__get__.sCrBcgrMr9rNrvalues rC__set__DescriptorProto.__set__0s#rBcgrMr9rNrs rC __delete__DescriptorProto.__delete__2srBr9N)robjectrrrUr)rrrrrUr3rrrUr3)r;r<r=r>rrrrAr9rBrCrr-s ?=4rBr_DESCcJ\rSrSrSr\(aSSjrS SjrS SjrSr gSr g) DescriptorReferencei8ara 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 cgrMr9rs rCrDescriptorReference.__get__E#rBcgrMr9rs rCrDescriptorReference.__set__GrBcgrMr9rs rCrDescriptorReference.__delete__ISrBr9N)rrrrrUr)rrrrrUr3r r;r<r=r>r?rrrrrAr9rBrCrr8sEC8 rBr_DESC_co)r*r-cJ\rSrSrSr\(aSSjrS SjrS SjrSr gSr g) RODescriptorReferenceiOza 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 cgrMr9rs rCrRODescriptorReference.__get__YsSrBcgrMr9rs rCrRODescriptorReference.__set__[r rBcgrMr9rs rCr RODescriptorReference.__delete__]srBr9N)rrrrrUr)rrrrrUr )rrrUr rr9rBrCrrOsHE< rBr_FN.cJ\rSrSrSr\(aSSjrS SjrS SjrSr gSr g) CallableReferenceicza descriptor that refers to a callable. works around mypy's limitation of not allowing callables assigned as instance variables cgrMr9rs rCrCallableReference.__get__nr rBcgrMr9rs rCrCallableReference.__set__pscrBcgrMr9rs rCrCallableReference.__delete__rrrBr9N)rrrrrUr)rrrrrUr3rrr9rBrCrrcsCA8 rBr)rc Type[Any]rr_AnnotationScanTyperdrjr]Mapping[str, Any]rX#Optional[Callable[[str, str], str]]rYboolrZzOptional[Set[Any]]rUr$)rr%rUr%)rrzGenericProtocol[_T]rtr7rUrG) rrjrrjr]Optional[Mapping[str, Any]]r^zOptional[Type[Any]]rUr)rrjrrjr]r)rUr)rrjrrjrUrj) rcr$rrr5rdrjr]r&rXr'rUr$)rOptional[_AnnotationScanType]rUr()rrrUzTypeGuard[Iterable[Any]])rr%rUr()rr*rUzTypeGuard[NewType])rr%rUzTypeGuard[GenericProtocol[Any]])rr%rUzTypeGuard[TypeAliasType])rr rUr$)F)rr%rr(rUzTypeGuard[ForwardRef])rrjrUrj)rr$rUr$)rrrUr%)rr%rUr$)FF)rr$rr(rr(rUzTuple[Type[Any], ...])rrrUzTypeGuard[ArgsTypeProcotol])rrrUr()rrrz'Union[Tuple[Type[Any], ...], Type[Any]]rUr()rrrrjrz Optional[str]rUr()rr$rUrj)e __future__rrcollections.abcabcryr~rtypingrrrrrr r r r r rrrrrrrrrtyping_extensionsrrrrrrrrr r!r"r#r$r%r&r'r(r)r+r,r.r0r1py38 frozensetrrrr2rrrrvrjr%r5rErJ _LiteralStarr`rrqrkrrrrrrmrrlrrrgrrrrrrrrrrrrrrrrrr9rBrCr4s#)  8<106:4<86@888.@ T en T * \ 6  en T * ;;89Ny)N <<+DzH V IsJ8NN .x.hrl(3Xc6k23s| ;?!(,D D#DD D 8 DD&DDN& &&R/#//N/ /,0$( !!!) ! " !  !P,0  )   D.;?     8 ,G /+G,7< /3 6 6 B B     . >/IN %)AE(E( F  FB F  F6:    %2   5h5 /9'%.9( :_ E=GH-="e8HS#X$6789 9rB