%^gXdZddlmZddlmZmZmZmZddlm Z m Z m Z ddl m Z ddlmZmZmZddlmZddlmZdd lmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-dd l.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7dd l8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMdd lNmOZOerddlPZddlmQZQGddZRddddddd d4dZS d5 d6dZT d5 d7dZU d5 d8dZV d9dZWd:dZXd;dZY ddZ\ d?dZ]d@dZ^dd  dAd!Z_dBd"Z`dd# dCd$Za dD dEd%ZbdFd&ZcGd'd(eOZddGd)Ze dHd*Zfddd+ dId,Zg dJd-Zh dKd.Zi dLd/Zj d5 dMd0ZkdNd1Zl dOd2ZmdPd3Zny)Qz!Type checking of attribute access) annotations) TYPE_CHECKINGCallableSequencecast)meetmessage_registrysubtypes)erase_typevars)expand_self_typeexpand_type_by_instancefreshen_all_functions_type_vars)map_instance_to_supertype)MessageBuilder)ARG_POSARG_STAR ARG_STAR2EXCLUDED_ENUM_ATTRIBUTESSYMBOL_FUNCBASE_TYPESContext DecoratorFuncBaseFuncDef IndexExprMypyFileNameExprOverloadedFuncDef SymbolNode SymbolTableTempNode TypeAliasTypeInfo TypeVarExprVar is_final_node)AttributeContext) bind_selfclass_callableerase_to_bound function_type get_type_varsmake_simplified_unionsupported_self_typetuple_fallbacktype_object_type_from_function)AnyType CallableType DeletedType FunctionLikeInstance LiteralTypeNoneType Overloaded ParamSpecType PartialType ProperType TupleTypeType TypedDictType TypeOfAnyTypeTypeTypeVarLikeTypeTypeVarTupleType TypeVarType UnionTypeget_proper_type)TypeTraverserVisitorN)stateceZdZdZdddd d dZd dZd dZddddd d d Zy) MemberContextzInformation and objects needed to type check attribute access. Look at the docstring of analyze_member_access for more information. NF)module_symbol_table no_deferralis_selfc ||_||_||_||_|xs||_||_||_||_| |_| |_ | |_ yN) is_lvalueis_super is_operator original_type self_typecontextmsgchkrIrJrK) selfrNrOrPrQrSrTrUrRrIrJrKs 0lib/python3.12/site-packages/mypy/checkmember.py__init__zMemberContext.__init__XsZ#  &*"3m #6 & c8|jj|SrM)rU named_type)rVnames rWr[zMemberContext.named_typessxx""4((rYc<|jj||yrM)rUhandle_cannot_determine_type)rVr\rSs rWnot_ready_callbackz MemberContext.not_ready_callbackvs --dGt t j@StC|jD|||S)N) source_any)#rDrtr4analyze_instance_member_accessr0r>from_another_anyrCanalyze_union_member_accessr3 is_type_obj#analyze_type_callable_member_accessr?analyze_type_type_member_accessr;rsr.r5fallbackr=analyze_typeddict_accessr6analyze_none_member_accessr@rBvaluesr, upper_boundr2rTdeleted_as_rvaluerS from_errorreport_missing_attributerQ)r\rvrbrps rWrsrss # C#x -dC]KK C !y11cBB C #*4b99 C &3??+<24bAA C ".tS"mLL C #%dN3,?]SS C+|4 5%dCLL"mLL C ''c2}EE C ")$R88 C ) c; 'CJJ)+CJJ7] &dCOOROO C %   bjj1y++,, #B$4$4c4 DDrYc|jjry|jj5|jj 5}|jj ||}| ddddddyt ||||}|j cdddcdddS#1swYnxYwdddy#1swYyxYw)z7Check if the given type has the attribute when awaited.FN)rUchecking_missing_awaitchecking_await_setrT filter_errorsget_precise_awaitable_typershas_new_errors)r\rvrbrp local_errorsaw_type_s rWmay_be_awaitable_attributers vv$$  " " $bff&:&:&< &&33CF ?'= $ $ #4"m D..00 '=&< $ $&<&< $ $ $s/C B/-C>B/ C/B8 4CC c6|jj||||j|j}|jj s4t ||||r&|jj |j|ttjSrM) rT has_no_attrrSrIprefer_simple_messagesrpossible_missing_awaitr0r>r)rQrvr\rbrp error_codes rWrrsq##M3bjj"J`J`aJ 66 ( ( * %dC] C FF ) )"**j A 9'' ((rYc |dk(rY|jsM|jjtj|j t tjS|j}|r|}tjrw|jtjdk(rW|tjdk(rA|jjdjtj|j |j|}|rnt!|t"s]|jr t%|||j&rt!|t(sJ|j*d}t!|t"sJ|j,rCt/|j*x}dkDr)|j0j3|d|j t5||j6|||S|j,r%|jj9|j t!|t(st;||j=d}n|jW|j>s2|j*r&|jA|j|j t tjBSt!|jtDsJ|j}tG|}|jHsptKjL|jN|} tQ|| |jR|j ||j}tU||jV|jR}tY||jZ}t]||} t_| | Sta||||S)NrXrzOccurrence of '{}.{}'builtins.functionis_classmethod)1rOrTfailr CANNOT_ACCESS_INITrSr0r>rtyperFfind_occurrencesr\noteformat get_methodrtrvalidate_super_call is_propertyritemsrNlenrUwarn_deprecated analyze_varvarcant_assign_to_methodr*r[rJr_ special_formr7r is_staticr meet_typesrQcheck_self_argis_classr'rRrinfor freeze_all_type_varsanalyze_member_var_access) r\rvrbrprmethodgetterr signaturedispatched_type member_types rWr|r|"s z"++  $77Dy++,, 88D  II//2 2 E**1- -  2+22E4J4JKRZZX__T "F j3 ;;  +   f&78 88\\!_Ffi0 00||fll%:U!;a!?&&uQx<tVZZdB? ? << FF ( ( 4&"34%fbmm #oob.>.>DO&?FOORZZrvvI")R\\&//ZI(V[[9-i= [))sD"==rYcd}t|tr|jrd}|}ndt|trT|jrHt|jtr |jn|jj }|j}|rF|j j|j|jj|jyy)NFT) rtris_trivial_bodyrimplfuncrT unsafe_superr\rrS)noderbrrs rWrrgsL$ T%9%9  D+ , 99 *499g >499DIINND//L DIItyy~~rzzBrYc|jdj}t|tsJt|tr t |}t|t r |j}t|trX|js5t||||jdj|j}|r|St||j|SJd|)Nr) original_vars mcs_fallbackzUnexpected type ) rret_typertr:r;r.r=rr4rPanalyze_class_attribute_access variablesrs)r\rvrbrrws rWrrtsyy|$$H h ++ +(I&!(+(M*$$(H%~~4$#))A,2H2HWZWcWcF %dCLL"==5( 55urYcRd}|jd}t|jtr|j}n$t|jtr2|j j 5t||||cdddSt|jtrt|jj}t|tr|}nt|tr8t|tj||j|j||St|t r t#|}n&t|tr|j j 5t||||cdddSt|jt rt#|j}nt|jt$r1|jj'r|jj(}nht|jtrNt|jjtr*|jjj*j,}d}||j*j,xs|}|rQ|j.sEt1|||||}|r3tt|tr|j*j2s|Sd}|j j |5t||||cdddS#1swYxYw#1swYxYw#1swYyxYw)N builtins.type)linecolumnF)rrpT)r)r[rtitemr4r0rTrrsrBrDrrCr?make_normalizedrrr;r.r3rrrmetaclass_typerPrfallback_to_any) r\rvrbrprrrignore_messagesrws rWrrsD D}}_-H#((H%xx CHHg & VV ! ! #)$"mL$ # CHHk *%chh&:&:; k8 ,D  Y /)((388CJJW    Y /!+.D  W -%%'-dHb-P(' CHHi (chh' CHHl +0D0D0Fxx   CHHh ' chhmmX .88==%%44DO 99++7x BNN/ $  v6@TYYE^E^ #'   O  <%dHb-H = |js'dD] }|jA|} | s| jj8dk7s2tC| |||jD|| } tG|| j}tItK| |} t | tLr | jN} n| } | jj8d |} |jjPjS| }|rF|tUtI|jV| |j|j|j} | cSn|jAd }|r|jj8dk7rtC||||jD||jYd  }tG||j}tItK||}t |tLr't[|j\d kDr|j\dS|j^j`rtctdjfS|jhrG||jhjjvr/|jhjls|jhjj|S|jr?|j,jo||jtctdjpSts|jV|||}|j>||j>vr|j>|jtsw|j>|jv}ty|}|j{|j||_;|jj"j}||jS|S)zAnalyse attribute access that does not target a method. This is logically part of analyze_member_access and the arguments are similar. original_type is the type of E in the expression E.var )rctxalias_definitionimplicitFzDid not expect a function) __getattr__ __setattr____getattribute__)rrrdefnityperrRr\rb.r)rNr)lvalue)?lookup_member_var_or_accessorrNrUrrSrtrrrOrrr"r$type_object_typer[rr! expr_checkeralias_type_in_runtime_contextrget_final_contextcheck_final_memberrTrrr module_refsaddfullname module_typerPrIr$analyze_decorator_or_funcbase_accessrRrrDr r1rpluginget_attribute_hookr&rQrcrrrrr0r>r extra_attrsattrsmod_nameundefined_in_superclassrr module_publicrrset_lineanalyze_ref_expr)r\rrrbvvvrvr method_namer bound_method getattr_typerwrhook setattr_meth bound_type setattr_typeretes rWrrs &dD",,?AFF1bjj) B"i FF ;;  ,"h +B > ?"i ff!!?? BJJ@  3 !S:&& << 8 8 : tT2662:: >4E4hGG Aw 111u Ax  qzz*vv""..q11 J J  " " * ||B 5 fkk226GG#G##!"$,,( $L4E6;;GC#23JO OA% ll''%'8  0|7H7HI./FzSV/WX lL9c,BXBX>Y\]>]'11"55 zz!!y--.. TU%6%6%<%<<  ))$$**40 0 {{ &&tRZZ8y++,,&r'7'7bI  " " ....**40>>&&t,11AA JJrzz "AF66&&77",,7O O rYc|jD]J}|jj|}|s!t|js7|j |d|Ly)z?Give an error if the name being assigned was declared as final.T) attr_assignrN)mronamesgetr%rcant_assign_to_final)r\rrTrbasesyms rWrrysEjjnnT" =*  $ $Tt $ ErY) assignmentc t|j}|}t|}t|tr-t |j Dcgc]}t ||c}St|ts|S|jjds|S|jjd}||jjtjj|j!|jj"|j$t't(j*St-|||j|d|}t/||j0}t3||}t|t4r4|j7r$|j dj8} t;}n)t|t<r|j>} t;}n|} |j@jBjE|d} |j@jBjG| |tI||j$tIt=jJ| |j$gtLtLg|j$|}|j@jBjO|tI||j$tIt=jJ| |j$gtLtLg|j$|| \} } |sO|j@jQ||j$|j@jS||j$| |t| } t| t&r| St| tTs|jjtjj|j!|jj"|j$t't(j*S| j8Scc}w)aUType check descriptor access. Arguments: descriptor_type: The type of the descriptor attribute being accessed (the type of ``f`` in ``a.f`` when ``f`` is a descriptor). mx: The current member access context. Return: The return type of the appropriate ``__get__`` overload for the descriptor. __get__rrrS) object_type)r callable_name)targetselftype)+rDrRrtrCr,ranalyze_descriptor_accessr4rhas_readable_memberrrTrr DESCRIPTOR_GET_NOT_CALLABLErstr_with_optionsoptionsrSr0r>rrrrr r3rrr6r?rrUrmethod_fullnametransform_callee_typer rr check_callcheck_deprecatedwarn_deprecated_overload_itemr1) descriptor_typerbr instance_typeorig_descriptor_typerv dunder_getrdunder_get_type owner_typerrinferred_dunder_get_types rWrrsQ$BLL1M*%o6O/9-$;J;P;P Q;PC &sB /;P Q   2##    3 3I >## %%00;J   8 8 ? ?00@  JJ  y++,,7   ! !!  L $OZ__ EC-lC@O-.=3L3L3N"((+44  M8 ,"''  " FF''77SMff))?? ]BJJ 7 X--j92:: N  ' #@ O#%&&"5"5"@"@ ]BJJ 7 X--j92:: N  ' ###A #A   BJJ7 ,,  +Co -  //GH*G4'' . =   8 8 ? ?00@  JJ  y++,, # , ,,i RsPc|j|jjvxrM|jj|jj|uxr|j xr |j S)z;Return if var is an instance variable according to PEP 526.)r\rrr is_classvar is_inferred)rs rWis_instance_varr1sa CHHNN" HHNN388 $ ) )S 0     rYrc |}t||j}|j}|rt|tr2|j j ||j||jS|jrI|jr=|js1|jj||j|j|jr2|jr&|jj||jt|}t!||||}t#||}t%||} t'|}d} |j(r_t+|r |j,rHt|t.r|j1s|} n%|jrt't3d||} n|} t| t.r| j1s|jro|jr>|jsW|jj||j|jn%|jj5|j|j6sL| } t9j:|j<|} t| } t't?|| |j<}t|t.sJ|} tA| | |jB|j||j} tE| |jF|jB} t#| |}t%||jrt|tHsJ|jJ} nZ|} nW|jLs2|jNs&|jQ|jR|jtUtVjX} |jjZd|}|j j\j_|}| r|js|s ta| |} |rF|tct'|j<| |j|j|j } | S)aZAnalyze access to an attribute via a Var node. This is conceptually part of analyze_member_access and the arguments are similar. itype is the instance type in which attribute should be looked up original_type is the type of E in the expression E.var if implicit is True, the original Var was created as an assignment to self N__call__r)2rrrrtr9rUhandle_partial_var_typerNrSris_settable_propertyrTread_only_propertyr/cant_assign_to_classvarrexpand_self_type_if_neededr rrDis_initialized_in_classr1rPr3rrsris_staticmethodrrrQr rrr'rRr1ris_readyrJr_r\r0r>rrrrrr&)r\rrrrbroriginal_itypervtrw call_typefunctyperrboundexpanded_signaturerrs rWrrs="N %eSXX 6E ((C c; '6611#r||S"**U U < B #Au -Qc"'+  & &0D#|,S__5F +,B:sTV,WX  i .y7L7L7N||??3311$ BJJOFF00<&&*3#'//"2B2BE"J;HE '(8iIYIY(Z[!%666! *0B0BBJJPTVXV\V\ &is?Q?QR %D yyrYc f|j}|s|Sg}|rtj|}|D]}|jr|jdt t fvr|j||||cSt|jd} tj|tt| r|j|t| tr|j|t| t st"|s|j%|||d|||St'|dk(r|dSt)|S)aCheck that an instance has a valid type for a method with annotated 'self'. For example if the method is defined as: class A: def f(self: S) -> T: ... then for 'x.f' we check that meet(type(x), A) <: S. If the method is overloaded, we select only overloads items that satisfy this requirement. If there are no matching overloads, an error is generated. Note: dispatched_arg_type uses a meet to select a relevant item in case if the original type of 'x' is a union. This is done because several special methods treat union types in ad-hoc manner, so we can't use MemberContext.self_type yet. rr)rr?rrrrrno_formal_selfrDr is_subtyper r)rrtr8rANotImplementedErrorincompatible_self_argumentrr7) r?dispatched_arg_typerrSr\rTr new_itemsrselfargs rWrrs!* NNE I&667JK~~!27H:M!M   tT7 3O%dnnQ&78G""#6~V]G^8_`  &G]3  &G%56))#$  && %uQx  9~| i  rY)rprc @|j}|r|}|jd|}|jjj |}|j |} | s|j rG||j jvr/|j js|j j|S|js |jr$t||ttjSyt| j t"r4| j j$s|s|jj |ry|jj'| j |j(t| j t*} | xst| j t,} |j.ru| r%|j0j3|j(t| j t4r4|j0j7t8j:|j(|j<rQ||j<vrC|j0j7t8j>jA||j(| jBrt| j t"rm| j jDrW|j0j7t8jFjA| j jH|j(|j.r<|jjKs"tM|||j0|j(|jNr,|j.s | s| stQ|||} | r t||| S| j} | rt| tRr[| j }t|t"sJt|||jjU| |j.||j(St| j t*r!| j jVjX}n9t| j t"tZfr| j jX}nd}|sd}n t]||}t| j t"r|Jt_| j jXj`jb}| j j$sO| j jXjdr/|jg| j jXjdt_ti| }||zrttk|jltnr | jBr]| j j$rt8jp}nt8jr}|j0j7||j(tu| || j |d} twty| ||Dchc]}|jzc}} | xr.t}t*| j j~jxs2t| j t,xr| j j}| xr.t}t*| j j~jxs2t| j t,xr| j j}tk| } t| tr0|r.t| |jdd|j(||j0} t| ||||jd|}|j.s t||}t|||St| j t"r5|j||j(ttjSt| j trg|j0j7t8jjA|jH||j(ttjSt| j t4r t| j |jSt| j tr|jdSt| j trF|jjj| j |j(|j.S| rt| j t*sJ| j jr!t||| j jS|j||j(ttjSt| j t,sJt| j |jd }| j jr t|d }t|||Scc}w) aAnalyze access to an attribute on a class object. itype is the return type of the class object callable, original_type is the type of E in the expression E.var, original_vars are type variables of the class callable (for generic classes). rNT)rFrztypes.ModuleTyperrr)RrrrUrget_class_attribute_hookrrrrrmeta_fallback_to_anyapply_class_attr_hookr0r>rrtrr$r/rrSrrrNrTrr"rr CANNOT_ASSIGN_TO_TYPEslotsCLASS_VAR_CONFLICTS_SLOTSrris_final!CANNOT_ACCESS_FINAL_INSTANCE_ATTRr\rris_enum#analyze_enum_class_attribute_accessr9r4rrrrsetr type_varsrRrr+rDrQr?GENERIC_CLASS_VAR_ACCESS!GENERIC_INSTANCE_VAR_CLASS_ACCESSr8r r rNrrrrr3radd_class_tvarsrr_r# CANNOT_USE_TYPEVAR_AS_EXPRESSIONrrr[rr!rrr*r')rr\rbrrprrrrr is_decorated is_methodenum_class_attribute_typer=symnode super_infoisuperdef_varstyp_varsmessagetvrr:rwrvs rWrrs1 ::D--$(H 66== 1 1( ;D 88D>D    ):):)@)@!@$$--((..t44   4#<#<(T79;Q;Q3RS S 499c" %%    ! !$ 'FF499bjj1dii3L? 499h ?I ||  FF ( ( 4 dii * FFKK(>> K zzddjj(  $>>EEdKRZZX }}DIIs3 8J8J   > > E Ediinn UWYWaWa  ||BFF4464rvvrzz: ||R\\\Y$GtUW$X! $(T3LM M A a %iiGgs+ ++(D"&&88BLL'SUS]S]^  dii +*.))--*<*#? @JJF.ujAF dii %% %%499>>..889H99((TYY^^-E-E TYY^^556=+,H("!/"2B2B"CXNRVR_R_yy,,"2"K"K"2"T"TFFKK4*1b$))UTRA 6q&AT\C]T\bBEET\C]^A&S4 499+E+J+J+S+S tyy( + B 0B0B (UDDII,F,K,K,U,U tyy( + C 0C0C  A  a &>q",,rzz4PA v~ Ta ||.vr:F$Rv66 DIIs # dBJJ/y--..$))[)   = = D DTYYPT UWYWaWa y++,,$))X& 2==99$))X&}}/00$))Y'vv""@@ II2:: A  $))Y/// 99>>(T499>>B B  ! !$ 39//0 0$))X...DIIr}}5H'IJ 99  C5C$Rs33oD^sh c |rF|tt|j||j|j|j }|SrM)r&rDrQrNrSrU)rbrrws rWrarasE   0 0162<<UWU[U[   MrYc|tvrt|j|||S|jdr|j dddk7ry|j j |}|re|j rYt|j }t|tr4|j jdk(r|jr|jdSt||}|j|S)N__rzenum.nonmemberrr)ru)rrrQ startswithreplacerrrDrtr4rargsr5rc)rr\rbrproper enum_literals rWrhrhs '''(8(8%rJJ tc2!6"!< ::>>$ D   + vx ( $$(88 ;;q> !te4L     ==rYc |dk(rt|jtrx|jjj ||jj d\}}|j|z}|rA|jj||jnttj}t|jjd|gttgddgt!|jjd|S|dk(rRt|jjdgtgdgt!|jjd|St#||j$||S) N __setitem__T)setitemrz builtins.strr)rrrrrr\ __delitem__)rtrSrrUrvisit_typeddict_index_exprindex readonly_keysrTreadonly_keys_mutatedr0r>implementation_artifactr1r[rr6rsr)r\rvrbrp item_type key_namesassigned_readonly_keyss rWrrsL } bjj) ,$&66#6#6#Q#QRZZ%%t$R$ Iy&)%6%6%B "%,,-CRZZ,X  A ABIvv((8)D(TlZVV&&':;     vv((89ifZVV&&':;    "$ b- HHrYct|trq||ng}t|}|rt||d}|s|r|Jt ||}t ||j t|t|jzSt|tr@t|jDcgc]!}ttt||||||#c}S| t ||}|Scc}w)aInstantiate type variables during analyze_class_attribute_access, e.g T and Q in the following: class A(Generic[T]): @classmethod def foo(cls: Type[Q]) -> Tuple[T, Q]: ... class B(A[str]): pass B.foo() Args: t: Declared type of the method (or property) isuper: Current instance mapped to the superclass where method was defined, this is usually done by map_instance_to_supertype() is_classmethod: True if this method is decorated with @classmethod is_staticmethod: True if this method is decorated with @staticmethod original_type: The value of the type B in the expression B.foo() or the corresponding component in case of a union (this is used to bind the self-types) original_vars: Type variables of the class callable on which the method was accessed Returns: Expanded method type with added type variables (when needed). Tr)rr^) rtr1rr'r rrclistrr7rrrm)r=rtrr:rQrtvarsrs rWrmrmsX!\"!.!:  +A . !]4@A _% %%'62AQetAKK7H)HII Az "GG $D #&'%&3  $    #Av . H# s%&C"c |jd}|jd}|rt|jsttj S|xs|}t|jsttj St |jttfsJt |jttfsJ|jj|jj}|jj|jj}|jxs|d}||kr|j}d}n||kDr|j}d}n|jjjdk(rY|jrMttj} t!| | gt"t$gddg| |d  } t'| ||d d S|j}d}t |t(r t+||} nDt |j,t.sJt |j,t0sJ|j,} t3| ||j||S) a9Return the type of a type object. For a generic type G with type variables T and S the type is generally of form Callable[..., G[T, S]] where ... are argument types for the __init__/__new__ method (without the self argument). Also, the fallback type will be 'type' instead of 'function'. rX__new__rFTr_args_kwdsrrN)is_new)ris_valid_constructorrr0r>rrtrrrrrrrrrr1rrr(rr*rr:r3r/) rr[ init_method new_method init_index new_indexrrrany_typesigr=s rWrr(s ((:&K)$J 2;3C3CDy++,,*{J   0y++,, joo(=y'I JJ J k&&)> (J KK K 0 0 5 56Jz334I""Aj&AHI'2'7'7 i     ) )-> >##"9#9#9:"'2'3&0%'(;< &c44NN !!&(# &( +&++z222&++|444 KK )!T6;;& QQrYct|trt||j|||St t ||j jd|S)zAnalyzes the type behind method access. The function itself can possibly be decorated. See: https://github.com/python/mypy/issues/10409 r)rQ)rtrrrr'r*rUr[rs rWrrosO$ "45$;; dBFF--.ABCS\ rYct|tryt|tr#tt|jt Sy)zDoes this node represents a valid constructor method? This includes normal functions, overloaded functions, and decorators that return a callable type. TF)rtrrrDrr3)ns rWrrs4 !X!Y/!&&1<@@ rY) r\rjrvr<rSrrNrdrOrdrPrdrTrrQr<rUrerpTypeInfo | NonerqrdrRrfrIrgrJrdrKrdrhr<rM) r\rjrvr<rbrHrprrhr<) r\rjrvr<rbrHrprrhrd) rQr<rvr<r\rjrbrHrprrhr<) r\rjrvr4rbrHrprrhr<)rrrbrHrhri)r\rjrvr3rbrHrhr<) r\rjrvr?rbrHrprrhr<)r\rjrvrCrbrHrhr<)r\rjrvr6rbrHrhr<) r\rjrr4rr"rbrHrhr<) r\rjrr"rTrrrrhri)r'r<rbrHrrdrhr<)rr$rhrd)r\rjrr$rr4rr"rbrHrrdrhr<)F) r=r<rbrHrr$rr4rrdrhr<)rr<rhri)rr"r\rjrNrdrhSymbolNode | None)r?r3rZr<rrdrSrr\rjrTrrhr3)rr4r\rjrbrHrr4rprr Sequence[TypeVarLikeType] | Nonerhrf)rbrHrz)Callable[[AttributeContext], Type] | Nonerwr<rhrf)rr4r\rjrbrHrhrf) r\rjrvr=rbrHrprrhr<)r=r:rtzInstance | Nonerrdr:rdrQr<rrrhr<)rr"r[zCallable[[str], Instance]rhr:)rzDecorator | FuncBaserr4rr"rRrfr\rjrbrHrhr<)rrrhrd)orn __future__rtypingrrrrmypyrr r mypy.erasetyper mypy.expandtyper r r mypy.maptyper mypy.messagesr mypy.nodesrrrrrrrrrrrrrrrr r!r"r#r$r% mypy.pluginr& mypy.typeopsr'r(r)r*r+r,r-r.r/ mypy.typesr0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDmypy.typetraverserrE mypy.checkerrFrHryrsrrr|rrrr~rrrrr1rr8rrKrrrrarhrrmrrrrorYrWrs^'"::11) 3(.)   .4CCb&*$!.2!? ? ??  ?  ?? ?? "?#???,?? !?" #?FOS$E $E$E+$E B>B>"/B>@OB> B>J C!6H5I 5I5I"/5I@O5I 5Ip* RN NN&.N4AN NbFEJg-g-,g-=Ag- g-T &_ _ _ _  _  __ _FMR) ))%()19)EI) )X0'0'6!6!6!6! 6!  6!  6!6!~&*6:z4 z4 z4 z4  z4 # z44z4z4z  F PT  > >>$1>>2$I $I!$I'4$IET$I $IZ7; I I I I  I  I 4 I  I XDRN         ( rY