X-Ph=,dZddlmZddlmZddlmZmZddlm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZerddlmZddZddZGddZdS)zLUtilities for mapping between actual and formal arguments (and their types).) annotations)Sequence) TYPE_CHECKINGCallable)nodes)map_instance_to_supertype) AnyTypeInstance ParamSpecType TupleTypeType TypedDictType TypeOfAnyTypeVarTupleType UnpackTypeget_proper_type)ArgumentInferContext actual_kindslist[nodes.ArgKind] actual_namesSequence[str | None] | None formal_kinds formal_namesSequence[str | None]actual_arg_typeCallable[[int], Type]returnlist[list[int]]ct}dt|Dg}d}tD]J\}} | tjkrs||krl|s!|||dz }W|tjkr||| tjkr t||} t| tr{tt| j D]W} ||krO|tj kr||nn|tjkr|dz }XB||krZ| drn=|||tjkrn |dz }||kZ| r| Jd||} | vrY| tjkr0| |)tj vr8tj |q| tj ksJt||} t| tr| j D]{} | vr/| |5tj vr8tj ||5||L|rCfdt|D} |D]"}| D]}||#S) a3Calculate mapping between actual (caller) args and formals. The result contains a list of caller argument indexes mapping to each callee argument index, indexed by callee index. The caller_arg_type argument should evaluate to the type of the actual argument type with the given index. cg|]}gSr!).0is K/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/argmap.py z*map_actuals_to_formals..+s(E(E(E(E(E(ErT)starNz/Internal error: named kinds without names givencg|]b}|r@|r"|dtjkr|tjks|tjk`|cS)r)rARG_STAR ARG_STAR2)r"firrrformal_to_actuals r$r%z*map_actuals_to_formals..is    R  ),  $$4R$8$;<NN $66B5?22 322r&)lenrange enumeraterARG_POSis_starappendr*r isinstancer itemsr+is_namedindexr)rrrrrnformalsambiguous_actual_kwargsr,ai actual_kindactualt_nameunmatched_formalsr-s` `` @r$map_actuals_to_formalsr@s<  H(E(EU8__(E(E(E)+ B$\224343K %- ' 'H}}#B'//114$R(//333!GBB!"%77$R(//333 EN * *%oob&9&9::G'9-- s7=1122$$AH}}'+u>>,R077;;;;!E'+u~==!GB8mm#B'00d0;;8(,33B777#B'5>99!GB8mm ! ! # # 3++-^+++#D|## \5G5G5M5M(NRWR`(`(` !3!3D!9!9:AA"EEEEL00 !3!3EO!D!DELLRPPP%/1111%oob&9&9::G'=11 3#MYYD|++(););D)A)ABII"MMMML88(););EO)L)LMTTUWXXX Y(..r22220        Hoo    * 0 0B' 0 0 $++B//// 0 r&list[str | None]ct|||||}d|D}t|D]%\}}|D]} || |&|S)z8Calculate the reverse mapping of map_actuals_to_formals.cg|]}gSr!r!)r"r=s r$r%z*map_formals_to_actuals..s(B(B(B(B(B(Br&)r@r0r3) rrrrrr-actual_to_formalformalactualsactuals r$map_formals_to_actualsrH}s.lL,)C(B\(B(B(B$%56644 4 4F V $ + +F 3 3 3 3 4 r&c&eZdZdZddZ dddZdS)ArgTypeExpanderaUtility class for mapping actual argument types to formal arguments. One of the main responsibilities is to expand caller tuple *args and TypedDict **kwargs, and to keep track of which tuple/TypedDict items have already been consumed. Example: def f(x: int, *args: str) -> None: ... f(*(1, 'x', 1.1)) We'd call expand_actual_type three times: 1. The first call would provide 'int' as the actual type of 'x' (from '1'). 2. The second call would provide 'str' as one of the actual types for '*args'. 2. The third call would provide 'float' as one of the actual types for '*args'. A single instance can process all the arguments for a single call. Each call needs a separate instance since instances have per-call state. contextrrNonecHd|_t|_||_dS)Nr) tuple_indexset kwargs_usedrK)selfrKs r$__init__zArgTypeExpander.__init__s!%(UU r&F actual_typer r; nodes.ArgKind formal_name str | None formal_kind allow_unpackboolc6|}t|}|tjkrt|trt|j}t|t rf|jr_ddlm }|||j j r*t||j j j jdSttjSt|t"r|jt'|jkrd|_n|xjdz c_|j|jdz }t|t*rv|stt|j } t| trt| j} n| } t| t r| j jdksJ| jd}|St|t.r|SttjS|tjkr%ddlm }t|t2r|tjkr||jvr|Jn@t5|j|jz }|j||j|St|t r@|||j jr*t||j jj jdSt|t.r|SttjS|S)aReturn the actual (caller) type(s) of a formal argument with the given kinds. If the actual argument is a tuple *args, return the next individual tuple item that maps to the formal arg. If the actual argument is a TypedDict **kwargs, return the next matching typed dict value type based on formal argument name and kind. This is supposed to be called for each formal, in order. Call multiple times per formal if multiple actuals map to a formal. r) is_subtyper'zbuiltins.tuple) rrr*r4r upper_boundr args mypy.subtypesr[rK iterable_typertyper r from_errorr rNr.r5rfullnamer r+rrOkeysrPpopadd mapping_type) rQrSr;rUrWrXoriginal_actualr[itemunpackedfallbacks r$expand_actual_typez"ArgTypeExpander.expand_actual_types&&%k22 %. ( (+'788 G.k.EFF +x00& 5[5E& 5444444:k4<+EFF 94#T\%?%D1#9#7888K33 5#s;+<'='==='(D$$$$)$$"()9A)=>dJ// , ,.ty99H!(,<==,#283G#H#H#+"8X66$M26FFFFF#=+D K77 5""y3444 EO + + 0 0 0 0 0 0+}55 5%/11k[EV6V6V&2222$'{'8'='='?'?#@#@4CS#S"X"X"Z"ZK $$[111"(55K22 5zzT\688 5 1dl>W>\]]bK77 5""y3444# "r&N)rKrrrL)F) rSr r;rTrUrVrWrTrXrYrr )__name__ __module__ __qualname____doc__rRrkr!r&r$rJrJsW*# ]#]#]#]#]#]#]#r&rJN) rrrrrrrrrrrr) rrrrrrrrArrrr)ro __future__rcollections.abcrtypingrrmypyr mypy.maptyper mypy.typesr r r r r rrrrr mypy.inferrr@rHrJr!r&r$rwshRR""""""$$$$$$********222222                        0//////____D&{#{#{#{#{#{#{#{#{#{#r&