,hWPSSKJr 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 SSKrSSKJr 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(aSS4K9J:r: O\;"S5r:SoS5jr<\\\ \=\\\/S64r>"S7S8\)5r?"S9S:\)\25r@"S;S<\)\3\745rA\&S=rBSS>SS?.SpS@jjrCSqSAjrDSrSBjrESSSC.SsSDjjrFSSE.StSFjjrGSuSGjrHSvSHjrISwSIjrJSxSJjrKSySKjrLSzSLjrMS{SMjrNS|SNjrOS}SOjrPS~SSPjjrQ\SSQj5rR\SSRj5rR\SqSSj5rRSqSTjrR\SSUj5rS\SSVj5rSSSWjrSSSXjrTSxSYjrUSxSZjrVSS[jrWSS\jrXSS].SS^jjrYSS_jrZ"S`Sa\)5r[\"Sb\[S,9r\"ScSd\\\5r]\"Se\[SSf9r^"SgSh\\^5r_\"Si\\ Sj\ 4S,9r`"SkSl\\`5ra"SmSn5rb\b"5rc\(a\rdO\crd\cRLreg)) annotationsN)deque)Any)Callable)Dict) ForwardRef)Generic)Iterable)Mapping)NewType)NoReturn)Optional)overload)Set)Tuple)Type) TYPE_CHECKING)TypeVarUnion)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)NoneTypecN[U[5=(a URS:H$)NNone) isinstancer__forward_arg__)typs N/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/util/typing.py is_fwd_noner<Ms c: & H3+>+>&+HHzGenericProtocol[Any]c$\rSrSr%SrS\S'Srg)ArgsTypeProtocolVzWprotocol 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__rCr=r;r?r?Vs .-r=r?c.\rSrSr%SrS\S'S\S'Srg) GenericProtocol`zPprotocol for generic types. this since Python.typing _GenericAlias is private rArBType[_T] __origin__rCNrDrCr=r;rMrM`s .-r=rMc(\rSrSrSSjrSSjrSrg)SupportsKeysAndGetItemtcgNrC)selfs r;keysSupportsKeysAndGetItem.keysusSr=cgrUrC)rV_SupportsKeysAndGetItem__ks r; __getitem__"SupportsKeysAndGetItem.__getitem__wssr=rCN)returnz Iterable[_KT])rZr.r]r4)rErFrGrHrWr[rKrCr=r;rRrRts(2r=rR*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)r_N)de_stringify_annotation).0elemrbclsrareoriginating_moduler`s r; *de_stringify_annotation..s6  , $"- /+ ,s) is_fwd_refr9r8streval_expression is_generic is_literalsetaddtuplerB_copy_generic_annotation_with) rk annotationrlrer`rarboriginal_annotationelementss ` ````` r;rhrh~s.%*// *c"" ' 4FGJ$ *Gc  z " ":&&  EM  & ' &   j )   #++   -ZBB r=c [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))rrrdictrtlistcollections_abc MutableSetMutableMappingMutableSequencer Sequencerematchrepr__class_getitem__rvrr8rpr)type_rjs r;fixup_container_fwd_refsrs 5 u      & &  * *  + +  # #  $ $   A4;  % 22 !) /)34(=(=Jt$4G /    L s,C> cd[US5(aURU5$URU$)N copy_with)hasattrrrP)rxrzs r;rwrws5z;''##H--$$X..r=rdc[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 NameErrorr| setdefaultrEupdateeval Exception) expression module_namererf base_globalske cls_namespacerxerrs r;rqrqs'*{{;'?'H'H    !2!23M  $ $X%6%6 A   .jAJ j@J 1 k]###-, 0  & 0 ?  s5BAB&3 B& B# BB#& C0CCrecJSU;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 )rqrrrrrbuiltins)namerrerrs r;eval_name_onlyrs  d{t'BB'*{{;'?'H'H  !! k]# 6 #     $$T* *   $TF+k] C   sI4A AAA B"#A;5B"; BBBBB"cX[X5n[USU5$![a Us$f=f)NrE)rgetattrr)rrobjs r;resolve_name_to_real_class_namer?s8.T/sJ--  s  ))cPUSL=(a [U5[R;$rU)r _type_tuplesrrs r; is_pep593rHs"   LE!2l6L6L!LLr=cz[U[R5=(a [U[[45(+$rU)r8r~r rpbytes)rs r;is_non_string_iterablerLs1 c?33 4 Z c5\>:r=c:[U5[R;$rU)rrr rs r;rsrsRs e  4 4 44r=c[US5$)N __supertype__rrs r; is_newtyperVs 5/ **r=c@[US5=(a [US5$)NrBrPrrs r;rrrr^s 5* % F'%*FFr=c[U5(a[UR5$[U[R 5$rU)rr is_pep695rPr8_type_instancesr)rs r;rrbs3 %))** e_:: ;;r=czURn[U5(aURn[U5(aMU$rU)rr)r super_types r;flatten_newtyperls6$$J Z --  Z r=c|^^[5mUU4SjmT"U5n[U[5(a[5n[U5nU(alUR 5n[U[5(aUR U5 O,UR U[Ld[U5(aSOU5 U(aMlU$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 snfrU)rur __value__is_unionrB) inner_typevaluet_seenrecursive_values r;r&pep695_values..recursive_value|sj    *$$ $$L,1NN;Nq"N;;;sA.N) rtr8r}rpopleftextendrur5r<)rrestypesstackrrrs @@r; pep695_valuesrss EE < % C#tc  A!T"" Q !x-;q>>$qI e  u r=c^T(a[U[5(ag[U[R5(agU(a/[ U5(a[ U4SjUR 55$g)NTc3:># UHn[USTS9v M g7f)T)check_for_plain_stringN)ro)riargrs r;rmis_fwd_ref..s) & T2H &sF)r8rprrrranyrB)r check_genericrs `r;roros_ *UC"8"8 E?55 6 6 :e,, ~~    r=cgrUrCrs r;de_optionalize_union_typesrs36r=cgrUrCrs r;rrs?Br=cgrUrCrs r;rrr=cf[U5(a [US5$[U5(a[U5(a[R (a[ UR5nO[U/5n[ 5nU(a`UR5nURH7n[U5(aURU5 M&URU5 M9 U(aM`URS5 UVs1sH!oU[LdM [U5(aMUiM# nn[U6$U$s snf)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)ro#_de_optionalize_fwd_ref_union_typesr includes_nonerpy39rtrBrrappendrudiscardr5r<make_union_type)rr:stack_of_unionsu_typrjrs r;rrs%25%@@ %]511 ;;enn%C$UGnO%C!'//1!NND~~'..t4 +"/ KK J#Q(!2q;q>q#J$$ Ks: D. D.D.cgrUrCrreturn_has_nones r;rrs r=cgrUrCrs r;rrrr=c"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*r7Fz\s*\|\s*|c34# UHoS:wdM Uv M g7f)r7NrC)rips r;rm6_de_optionalize_fwd_ref_union_types..sB{!6kAA{s  ) r9rrgroupsplitrrjoinstripclearlenrr*)rrrxmmg1rzcurrent ignore_commacharrjparts pipe_tokenshas_noneanno_strs r;rrs&&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[U$)zMake a Union type.r)rs r;rr$s <r=c[U5(a [US5$[U5(a[S[ U555$[ U5(a[ [ U5S5$[U5(a[S[U555$[U5(a[ UR5$U[S4;=(d [U5$![a gf=f)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 g7frUrrirs r;rm includes_none..9s=_=##_rc38# UHn[U5v M g7frUrrs r;rmr=sB-A=##-ArNF)rorrrrrrrrrrr5r< TypeErrorrs r;rr*s%25$??=Xe_===Xe_Q/00B]5-ABBB%U00114((>K,>>  sC C*)C*c[U[5=(dN [US5=(d; URS;=(d% [U5RSRS;$)NrP)typingtyping_extensionsr)r8typerrF__mro__rs r; is_a_typer Is\5$ P 5, ' P   > > P ;  q ! , ,0O O r=c[USS5$)Nr UnionType) is_origin_ofrs r;rrRs w 44r=cd[U5nUcg[U[5=(a [X!5$)zWreturn True if the given type has an __origin__ that shares a base with the given classF)rr8r  issubclass)r class_objorigins r;is_origin_of_clsrVs-  F ~ fd # E 6(EEr=)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_namerF startswith)rrnamesrs r;rrcsJ  F ~ & !U * $>&++66v>r=c[R(a UR$[USS5nUc [USS5nU$)NrE_name)rpy310rEr)rtyp_names r;rrrs: ||~~5*d3  ugt4Hr=c2\rSrSrSSjrSSjrS SjrSrg) DescriptorProtoi}cgrUrCrVinstanceowners r;__get__DescriptorProto.__get__~sCr=cgrUrCrVr!rs r;__set__DescriptorProto.__set__s#r=cgrUrCrVr!s r; __delete__DescriptorProto.__delete__sr=rCN)r!objectr"rr]r)r!rrrr]r7r!rr]r7)rErFrGrHr#r'r+rKrCr=r;rr}s ?=4r=r_DESCcJ\rSrSrSr\(aSSjrS SjrS SjrSr gSr g) DescriptorReferenceiara 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 cgrUrCr s r;r#DescriptorReference.__get__#r=cgrUrCr&s r;r'DescriptorReference.__set__r=cgrUrCr*s r;r+DescriptorReference.__delete__Sr=rCN)r!r-r"rr]r/)r!rrr/r]r7r. rErFrGrHrIrr#r'r+rKrCr=r;r1r1sEC8 r=r1_DESC_co)r-r0cJ\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 cgrUrCr s r;r#RODescriptorReference.__get__sSr=cgrUrCr&s r;r'RODescriptorReference.__set__r4r=cgrUrCr*s r;r+ RODescriptorReference.__delete__sr=rCN)r!r-r"rr]r<)r!rrrr]r )r!rr]r r;rCr=r;r>r>sHE< r=r>_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 cgrUrCr s r;r#CallableReference.__get__r7r=cgrUrCr&s r;r'CallableReference.__set__scr=cgrUrCr*s r;r+CallableReference.__delete__r:r=rCN)r!r-r"rr]rE)r!rrrEr]r7r.r;rCr=r;rGrGsCA8 r=rGc\rSrSrSSjrSrg)_TypingInstancesic[[[US5[[US54Vs1sH nUcMUiM sn5nU(d [ U5eX0R U'U$s snfrU)rvrrrAttributeErrorr)rVkeyrrs r; __getattr___TypingInstances.__getattr__ssFC.-sD9 A     % %" c  s A$A$rCN)rRrpr]ztuple[type, ...])rErFrGrHrSrKrCr=r;rOrOsr=rO)r:rr]bool)rk Type[Any]rx_AnnotationScanTyperlrprezMapping[str, Any]r`z#Optional[Callable[[str, str], str]]rarUrbzOptional[Set[Any]]r]rV)rrWr]rW)rxzGenericProtocol[_T]rzrAr]rO) rrprrpreOptional[Mapping[str, Any]]rfzOptional[Type[Any]]r]r)rrprrprerXr]r)rrprrpr]rp)rz Optional[Any]r]rU)rrr]zTypeGuard[Iterable[Any]])rrr]rU)rzOptional[_AnnotationScanType]r]zTypeGuard[NewType])rrWr]zTypeGuard[GenericProtocol[Any]])rrWr]zTypeGuard[TypeAliasType])rr r]rV)rrWr]zSet[Any])FF)rrWrrUrrUr]zTypeGuard[ForwardRef])rrpr]rp)rrVr]rV)rrrz Literal[True]r]rU)rrrzLiteral[False]r]rW)rrrrUr]z Union[_AnnotationScanType, bool])rrWr]rV)rrr]zTypeGuard[ArgsTypeProtocol])rrrz'Union[Tuple[Type[Any], ...], Type[Any]]r]rU)rrrrprz Optional[str]r]rU)rrVr]rp)f __future__rr collectionsrcollections.abcabcr~rrrrrrrr r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r.r/r1r3r4rrr5r r<rprWr?rMrR _LiteralStarrhrrwrqrrrrrsrrrrrrrorrrrr rrrrrr/r1r<r>rErGrOrr LITERAL_TYPESrCr=r;r_s#)  8<106:4<86@888.@0@ T en T * \ 6  en T * <<+DzHIIsJ8NN .x.hrl(3Xc6k23s| ;?!(,D D#DD D 8 DD&DDN& &&R/#//N/ /,0$( !!!) ! " !  !P,0  )   D.M 5+G<"N #( ! ( 6 6 B B    % %%P  (5     (6  3 3(,3%3l >5 F  FB F  F6:    %2   5h5 /9'%.9( :_ E=GH-="e8HS#X$6789 9$$ ! 'O"O$$ r=