o tBh^@sdZddlmZddlmZmZmZmZddlm Z m Z m Z ddl m Z ddlmZmZddlmZddlmZdd lmZmZmZmZmZmZmZmZmZmZm 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,dd l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4dd l5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLerddlMZddlmNZNGdddZOddddddd+d,ZP ddd.d/ZQ ddd0d1ZR ddd2d3ZSdd5d6ZTdd8d9ZUdd;d<ZVdd>d?ZWddAdBZXddFdGZYddJdKZZddMdNZ[ddSdTZ\ddWdXZ]ddYdd[d\Z^dd^d_Z_ddadbZ`ddfdgZa  dddjdkZbddodpZcddqdrZdddtduZe dddzd{Zfdd|d}ZgdddZhdddZidS)z!Type checking of attribute access) annotations) TYPE_CHECKINGCallableSequencecast)meetmessage_registrysubtypes)erase_typevars)expand_type_by_instancefreshen_function_type_vars)map_instance_to_supertype)MessageBuilder)ARG_POSARG_STAR ARG_STAR2SYMBOL_FUNCBASE_TYPESContext DecoratorFuncBaseFuncDef IndexExprMypyFileOverloadedFuncDef SymbolNode SymbolTableTempNode TypeAliasTypeInfo TypeVarExprVar is_final_node)AttributeContext) set_any_tvars) bind_selfclass_callableerase_to_bound function_typemake_simplified_uniontuple_fallbacktype_object_type_from_function)ENUM_REMOVED_PROPSAnyType CallableType DeletedType FunctionLikeInstance LiteralTypeNoneType Overloaded ParamSpecType PartialType ProperType TupleTypeType TypedDictType TypeOfAnyTypeTypeTypeVarLikeTypeTypeVarTupleType TypeVarType UnionTypeget_proper_type has_type_varsN)statec@sFeZdZdZ d$d%ddZd&ddZd'ddZddddd(d"d#ZdS)) MemberContextzInformation and objects needed to type check attribute access. Look at the docstring of analyze_member_access for more information. N is_lvalueboolis_super is_operator original_typer8contextrmsgrchkmypy.checker.TypeChecker self_type Type | Nonemodule_symbol_tableSymbolTable | NonereturnNonec Cs>||_||_||_||_|p||_||_||_||_| |_dSN) rDrFrGrHrMrIrJrKrO) selfrDrFrGrHrIrJrKrMrOrUg/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/mypy/checkmember.py__init__Rs   zMemberContext.__init__namestrr0cCs |j|SrS)rK named_type)rTrXrUrUrVrZhs zMemberContext.named_typecCs|j||dSrS)rKhandle_cannot_determine_type)rTrXrIrUrUrVnot_ready_callbackksz MemberContext.not_ready_callback)messagesrMrDr]MessageBuilder | None bool | Nonec CsXt|j|j|j|j|j|j|j|j|j }|dur||_|dur#||_|dur*||_|SrS) rCrDrFrGrHrIrJrKrMrO)rTr]rMrDmxrUrUrV copy_modifiedns$ zMemberContext.copy_modifiedrS)rDrErFrErGrErHr8rIrrJrrKrLrMrNrOrPrQrR)rXrYrQr0)rXrYrIrrQrR)r]r^rMrNrDr_rQrC)__name__ __module__ __qualname____doc__rWrZr\rarUrUrUrVrCLs  rCF) override_infoin_literal_contextrMrOrXrYtypr8rIrrDrErFrGrJrrHrKrLrfTypeInfo | NonergrMrNrOrPrQc CsRt|||||||| | d } t||| | }t|}| r't|tr'|jdur'|jS|S)aReturn the type of attribute 'name' of 'typ'. The actual implementation is in '_analyze_member_access' and this docstring also applies to it. This is a general operation that supports various different variations: 1. lvalue or non-lvalue access (setter or getter access) 2. supertype access when using super() (is_super == True and 'override_info' should refer to the supertype) 'original_type' is the most precise inferred or declared type of the base object that we have available. When looking for an attribute of 'typ', we may perform recursive calls targeting the fallback type, and 'typ' may become some supertype of 'original_type'. 'original_type' is always preserved as the 'typ' type used in the initial, non-recursive call. The 'self_type' is a component of 'original_type' to which generic self should be bound (a narrower type that has a fallback to instance). Currently this is used only for union types. 'module_symbol_table' is passed to this function if 'typ' is actually a module and we want to keep track of the available attributes of the module (since they are not available via the type object directly) )rKrMrON)rC_analyze_member_accessr@ isinstancer0last_known_value)rXrhrIrDrFrGrJrHrKrfrgrMrOr`resultpossible_literalrUrUrVanalyze_member_accesss('  ror`cCsvt|}t|trt||||St|trttj|dSt|tr't|||St|t r6| r6t |||St|t rBt ||||St|trPt|t|||St|tt fr_t||j||St|trkt||||St|trvt|||St|trt|tr|jrt|t|j||St||j||St|tr|j||jttj S|j!"|grttj St#|j$|||S)N) source_any)%r@rkr0analyze_instance_member_accessr,r:from_another_anyr?analyze_union_member_accessr/ is_type_obj#analyze_type_callable_member_accessr;analyze_type_type_member_accessr7rjr)r1fallbackr9analyze_typeddict_accessr2analyze_none_member_accessr<r>valuesr( upper_boundr.rJdeleted_as_rvaluerI from_errorrKshould_suppress_optional_errorreport_missing_attributerH)rXrhr`rfrUrUrVrjs>              rjc Cs|jjrdS|jK|j5}|j||}|dur, WdWddSt||||}| WdWdS1sIwYWddS1sYwYdS)z7Check if the given type has the attribute when awaited.FN)rKchecking_missing_awaitchecking_await_setrJ filter_errorsget_precise_awaitable_typerjhas_new_errors)rXrhr`rf local_errorsaw_type_rUrUrVmay_be_awaitable_attributesRrcCs8|j||||j|j}t||||r|j|j|SrS)rJ has_no_attrrIrOrpossible_missing_await)rHrhrXr`rfres_typerUrUrVrsrr0c Csr|dkr|js|jtj|jttjS|j }|r|}t j r:|j t j dkr:|t j dkr:|j djt j |j||}|rt|ts|jrat|tsPJtt|jd}t||j|||S|jrk|j|jt||d}t|}|dkr|n%t|tr|dkrt|j |}t!|||j"|j||j}t#||j$|j"d}t%||j&}t'||} t(| | St)||||S) NrWrzOccurrence of '{}.{}'builtins.function__new____call__is_classmethod)*rFrJfailrCANNOT_ACCESS_INITrIr,r:r}typerBfind_occurrencesrXnoteformat get_methodrkr is_propertyrritems analyze_varvarrDcant_assign_to_methodr'rZr r/r meet_typesrHcheck_self_argis_classr$rMr infor freeze_type_varsanalyze_member_var_access) rXrhr`rfrmethod first_item signaturedispatched_type member_typerUrUrVrqsD    rqr/cCs|jdj}t|ts Jt|trt|}t|tr|j}t|tr=|j s6t ||||jdj d}|r6|St ||j|SJd|)Nr original_varsFzUnexpected type ) rret_typerkr6r7r)r9rwr0rGanalyze_class_attribute_access variablesrj)rXrhr`rrmrUrUrVruGs    rur;c Csd}|d}t|jtr|j}nt|jtr4|jt||||WdS1s.wYnot|jtrtt |jj }t|trH|}n[t|t rRt |}nQt|trs|jt||||WdS1snwYn/t|jt rt |j}n#t|jt r|jr|jj}nt|jtrt|jjtr|jjjj}d}|r|jst||||}|rtt |tr|jjs|Sd}|dur|jjp|}|jj|dt||||WdS1swYdS)N builtins.typeFT)r)rZrkitemr0r,rJrrjr>r@r{r7r)r/rtrwr;rmetaclass_typerGrfallback_to_any) rXrhr`rfrrwr{ignore_messagesrmrUrUrVrvksL     "                 $rvr?cCsh|j#g}|D]}|j|d}|t|||q Wdt|S1s+wYt|S)N)rM)rJdisable_type_namesrelevant_itemsraappendrjr()rXrhr`resultssubtypeitem_mxrUrUrVrss    rsr2cCs\|dkrtd|dd}tggg||ddS|j|gr%ttjSt||d|S)N__bool__Fz builtins.boolrwr arg_types arg_kinds arg_namesrrwbuiltins.object) r1rZr-rKr~r,r:r}rj)rXrhr` literal_falserUrUrVrys ryityperrc Cst|||j}|}t|tr|j}t|tr#t|t||jd}||_ t|t r?tt |j t r?t||j}t||d}||_ t|trd||j}|jrZ|jsZt|||j|jt||||||dSt|trmJd|s|dvr|js|jdur|jsdD]V}||} | r| j jdkrt| |||j||d } t|| j }t t| |} t| tr| j } n| } | j jd |} |jj!"| }|r|t#t |j$| |j|j} | Sqn>|d }|r|j jdkrt||||j||j%dd d }t||j }t t||}t|trt&|j'd kr|j'dS|j(j)r$t*t+j,S|j-r5|j.||jt*t+j/S|jrF|j0|grFt*t+j/St1|j$|||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 )rimplicitFzDid not expect a function) __getattr__ __setattr____getattribute__N)rrrdefnrrrMrXr`.r)rDr)2lookup_member_var_or_accessorrDrkrrrr type_object_typerZrrr@targetr0instance_alias_typerrKget_final_contextcheck_final_memberrJrIrrrGrOrfullname$analyze_decorator_or_funcbase_accessrMr r r-rpluginget_attribute_hookr"rHralenrrrr,r: special_formrFundefined_in_superclassr}r~r)rXrrr`vvvrhr method_namer bound_method getattr_typermrhook setattr_meth bound_type setattr_typerUrUrVrs              !       rctxrRcCs:|jD]}|j|}|rt|jr|j|d|dqdS)z?Give an error if the name being assigned was declared as final.T) attr_assignrN)mronamesgetr!nodecant_assign_to_final)rXrrJrbasesymrUrUrVr's  rdescriptor_typec stj}|}t|}t|trtfdd|jDSt|ts#|S|jds+|S|j d}|durFj t j |jttjSt|||j|dd}t||j}t||}t|tro|ro|jdj}t}nt|tr{|j}t}n|}jj|d} jjj | |t!|jdt!t"|jdgt#t#gj|d }jjj$|t!|jdt!t"|jdgt#t#gj|| d \} } t| } t| tr| St| t%sj t j |jttjS| jS) 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. csg|]}t|qSrU)analyze_descriptor_access).0rhr`rUrV @sz-analyze_descriptor_access..__get__N__set__rr)rI) object_type)r callable_name)&r@rHrkr?r(rr0rhas_readable_memberrrJrrDESCRIPTOR_GET_NOT_CALLABLErrIr,r:r}rr rr r/rtrr2r;rrK expr_checkermethod_fullnametransform_callee_typermake_normalizedr check_callr-) rr` instance_typeorig_descriptor_type dunder_getrrhdunder_get_type owner_typerrinferred_dunder_get_typerUrrVr/s                raliasrrZCallable[[str], Instance]cCsXt|j}tt|tsJdtt||j|j}t|ts!Jt|j|}t ||S)zType of a type alias node targeting an instance, when appears in runtime context. As usual, we first erase any unbound type variables to Any. z+Must be called only with aliases to classes) r@rrkr0r#linecolumnrrr )rrZrtprUrUrVrs   rrr cCs.|j|jvo|j|jj|uo|j o|j S)z;Return if var is an instance variable according to PEP 526.)rXrr is_classvar is_inferred)rrrUrUrVis_instance_vars rrrcCst||j}|j}|rt|tr|j||j||jS|jr.|j r.|j s.|j ||j|j|jr<|j r<|j ||jtt||}|}t|}|jrt||rT|jrt|tr|s|jrx|j rq|j sp|j ||j|jn|j |j|js|} t|j|} t| } t| | |j|j||j } t| |j|j} tt| |} t | |j rt| t!sJ| j"}n| }n|j#s|$|j%|jt&t'j(}|jj)d|} |jj*+| }|r|js|st,||}|r|t-t|j||j|j}|S)aKAnalyze access to an attribute via a Var node. This is conceptually part of analyze_member_access and the arguments are similar. itype is the class object in which var is defined 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 r).r rrrkr5rKhandle_partial_var_typerDrIris_settable_propertyrJread_only_propertyrcant_assign_to_classvarr@r is_initialized_in_classrrGr/rtris_staticmethodrrrHr rrr$rMrr-ris_readyr\rXr,r:rrrrrr")rXrrrr`rrhtrmfunctyperrexpanded_signaturerrrUrUrVrsn     rrcCs^t|tsdSt|tr|jD]}d|j_qt|tr+|jD]}|jD]}d|j_q#qdSdS)Nr)rkr6r-rid meta_levelr3r)rritrUrUrVrs        rSymbolNode | NonecCs||}|r |jSdS)zCFind the attribute/accessor node that refers to a member of a type.N)rr)rrXrDrrUrUrVrs rrdispatched_arg_typerc Cs|j}|s|Sg}|rt|}|D]B}|jr |jdttfvr+|||||St|jd} t |t t | rB| |qt| trM| |qt| trTtq|sd||||d|||St|dkrn|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_selfr@r is_subtyper r&rrkr4r=NotImplementedErrorincompatible_self_argumentrr3) rrrrIrXrJr new_itemsrselfargrUrUrVrs4      rr Sequence[TypeVarLikeType] | Nonec Cs |j}|r|}|jd|}|jj|}||}|s+|jr)t||tt j SdSt |j t } | p8t |j t} |jrT| rE|j|jt |j trT|jtj|j|jrot |j tro|j jro|jtj|j j|j|jr|jst|||j|j|jr|js| s| st |||} | rt||| S|j} | rit | t!r|j } t | tsJt|||j"| |j| |jSt |j t r|j j#j$}nt |j tt%fr|j j$}nd}|sd}nt&||}t |j tr |dusJt | t'st(| rt t)|j*t+r|jr|j j,rtj-}ntj.}|j||jt/t0| |} | r,t1t |j j2j3p6t |j to6|j j3}t)| } t | t4rP|rPt5| |j6d|j||j} t7| |||j6|d}|jsct8||}t|||St |j tr||9||jtt j St |j t:r|jtj;|j||jtt j<St |j trt=|j |j>St |j t?r|>dSt |j t@rt t)|j jAtBrtC|j |j>S| rt |j t sJ|j jrt|||j jS|9||jtt j<St |j tsJtD|j |>d}|j j3r tE|dd}t|||S) 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). rNFrztypes.ModuleTyperTr)FrrrKrget_class_attribute_hookrrapply_class_attr_hookr,r:rrkrrrrDrJrrIrrrCANNOT_ASSIGN_TO_TYPErr is_final!CANNOT_ACCESS_FINAL_INSTANCE_ATTRrrXrris_enum#analyze_enum_class_attribute_accessr5rrrrr r>rAr@rHr;rGENERIC_CLASS_VAR_ACCESS!GENERIC_INSTANCE_VAR_CLASS_ACCESSr r rfuncrr/rrMadd_class_tvarsrr\r CANNOT_USE_TYPEVAR_AS_EXPRESSIONr}rrZrrrr0rr'r$)rrXr`rfrrrrr is_decorated is_methodenum_class_attribute_typersymnode super_infoisupermessagerrmrhrUrUrVrHs                         rr)Callable[[AttributeContext], Type] | NonermcCs$|r|tt|j||j|j}|SrS)r"r@rHrIrK)r`rrmrUrUrVrs rcCsX|tvr t|j|||S|dr |dr |dddkr dSt||d}|j|dS)N__rr)rl)r+rrH startswithendswithreplacer1ra)rrXr` enum_literalrUrUrVr$s $  r$r9cCs|dkr3t|jtr|jj||jj}nttj }t |j d|gt t gddgt |j d|dS|dkrMt |j dgt gdgt |j d|dSt||j||S)N __setitem__z builtins.strr)rrrrrwrX __delitem__)rkrIrrKrvisit_typeddict_index_exprindexr,r:implementation_artifactr-rZrr2rjrw)rXrhr`rf item_typerUrUrVrxs,     rxrr6r/Instance | Nonecst|tr9dur ng}r,t|}t|dd}dus Jttt|}t||jt|t|j dSt|t rMt fdd|j DSdurYtt t|}|S)alInstantiate 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 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). NTr)rc s$g|]}ttt|dqS)r)rr-r()rrrr/rHrrUrVrPs z#add_class_tvars..) rkr-r r$rr rralistrr3rr6)rr/rrHrtvarsrUr?rVr(s$ *   r(c Csp|d}|d}|rt|jsttjS|p|}t|js$ttjSt|jttfs.Jt|jttfs8J|j |jj }|j |jj }|j pN|d}||krY|j}d}n8||krc|j}d}n.|jj j dkr|jrttj} t| | gttgddg| |d d } t| ||d dd S|j}d}t|trt||} nt|jtsJt|jtsJ|j} t| ||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'. rWrrFTr_args_kwdsrrN)is_new)ris_valid_constructorrr,r:r}rkrrrr;rrrrrr-rrr%rr'rr6r/r*) rrZ init_method new_method init_index new_indexrwrrDany_typesigrrUrUrVr_sJ       rrDecorator | FuncBasecCs6t|trt||j|||Stt||jd|dS)zAnalyzes the type behind method access. The function itself can possibly be decorated. See: https://github.com/python/mypy/issues/10409 r)rH)rkrrrr$r'rKrZrrUrUrVrs rncCs,t|trdSt|trtt|jtSdS)zDoes this node represents a valid constructor method? This includes normal functions, overloaded functions, and decorators that return a callable type. TF)rkrrr@rr/)rMrUrUrVrEs  rE)rXrYrhr8rIrrDrErFrErGrErJrrHr8rKrLrfrirgrErMrNrOrPrQr8rS) rXrYrhr8r`rCrfrirQr8) rXrYrhr8r`rCrfrirQrE) rHr8rhr8rXrYr`rCrfrirQr8) rXrYrhr0r`rCrfrirQr8)rXrYrhr/r`rCrQr8) rXrYrhr;r`rCrfrirQr8)rXrYrhr?r`rCrQr8)rXrYrhr2r`rCrQr8) rXrYrr0rrr`rCrQr8) rXrYrrrJrrrrQrR)rr8r`rCrQr8)rrrZrrQr8)rr rrrQrE)rXrYrr rr0rrr`rCrrErQr8)rr8rQrR)rrrXrYrDrErQr)rr/rr8rrErIrrXrYrJrrQr/)NN) rr0rXrYr`rCrfrirrrQrN)r`rCrr1rmr8rQrN)rr0rXrYr`rCrQrN) rXrYrhr9r`rCrfrirQr8) rr6r/r>rrErHr8rrrQr8)rrrZrrQr6)rrLrr0rrrMrNrXrYr`rCrQr8)rMrrQrE)jre __future__rtypingrrrrmypyrrr mypy.erasetyper mypy.expandtyper r mypy.maptyper mypy.messagesr mypy.nodesrrrrrrrrrrrrrrrrrr r! mypy.pluginr" mypy.typeanalr# mypy.typeopsr$r%r&r'r(r)r* mypy.typesr+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rA mypy.checkerrBrCrorjrrrqrurvrsryrrrrrrrrrrrr$rxr(rrrErUrUrUrVsn    T  $d  H? *   7 $ -  u  \  U ;   ' D G