X-Ph]UdZddlmZddlmZddlmZmZddlm Z ddl m Z m Z mZmZmZddlmZddlmZmZmZdd lmZdd lmZmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2dZ3de4d<dZ5de4d<dZ6de4d< dTdUd"Z7dVd(Z8dWd-Z9dXd0Z:dYd4Z;dZd[d8Zd^dFZ?d_dHZ@d`dJZAdadKZBdbdMZCdcdPZDdddRZEdSS)ez!Type inference constraint solving) annotations) defaultdict)IterableSequence) TypeAlias) SUBTYPE_OF SUPERTYPE_OF Constraintinfer_constraintsneg_op expand_type) prepare_sccsstrongly_connected_componentstopsort) join_types)meet_type_list meet_types) is_subtype)get_all_type_vars)AnyTypeInstanceNoneType ParamSpecType ProperType TupleTypeType TypeOfAny TypeVarIdTypeVarLikeTypeTypeVarTupleType TypeVarTypeUninhabitedType UnionType UnpackTypeget_proper_type) type_statezdict[TypeVarId, set[Type]] _TypeAliasBoundsz set[tuple[TypeVarId, TypeVarId]]Graphzdict[TypeVarId, Type | None] SolutionsTF original_varsSequence[TypeVarLikeType] constraintslist[Constraint]strictboolallow_polymorphicskip_unsatisfiedreturn/tuple[list[Type | None], list[TypeVarLikeType]]cd|DsggfSd|Dg|D]O}fd|jDfd|jDP|rt|}dzD}|D].}|jzvr ||j|/|r |rt z|\}} nqi}g} nli}g} |D]S\} } | sd| D} d| D} t| | }|t|fd Ds||| <Tg}D]h}||vr|||"|rt}d |_ nttj}||i| s|st|||}|| fS) aSolve type constraints. Return the best type(s) for type variables; each type can be None if the value of the variable could not be solved. If a variable has no constraints, if strict=True then arbitrarily pick UninhabitedType as the value of the type variable. If strict=False, pick AnyType. If allow_polymorphic=True, then use the full algorithm that can potentially return free type variables in solutions (these require special care when applying). Otherwise, use a simplified algorithm that just solves each type variable individually if possible. The skip_unsatisfied flag matches the same one in applytype.apply_generic_arguments(). cg|] }|j Sid.0tvs J/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/solve.py z%solve_constraints..=s * * *bBE * * *ci|] }|j| Sr8r9r;s r> z%solve_constraints..As333r333r@c6g|]}|jzv|jSr8r9)r<v extra_varsvarss r>r?z%solve_constraints..Es,XXXA!$dZFW:W:W14:W:W:Wr@c2i|]}|jv |j|Sr8r9)r<rD originalss r>rBz%solve_constraints..Fs)RRRaAD rBz%solve_constraints..Ms.R.R.R"r2.R.R.Rr@c<g|]}|jtk|jSr8)opr targetr<cs r>r?z%solve_constraints..`s&CCC1adl.B.Bah.B.B.Br@c<g|]}|jtk|jSr8)rKrrLrMs r>r?z%solve_constraints..as&AAA1adj.@.@ah.@.@.@r@Ncg|]}|v| Sr8r8)r<r=rFs r>r?z%solve_constraints..fsEEE"bnn2nnnr@T)extend extra_tvarsupdateskip_reverse_union_constraintstype_varappendsolve_with_dependentitems solve_oneget_varsr# ambiguousrr special_formpre_validate_solutions)r,r.r0r2r3rNcmapcon solutions free_varsr=cslowersupperssolutionresrD candidaterErHrFs @@@r>solve_constraintsrh)s( + *M * * *D 2v 33]333I"$J TTXXXXXXXXYYYRRRR1=RRRSSSSB4[AA /S.Rz@Q.R.R.RD++ <4*, , ,   % %c * * *)  #7z!;i$$ IyyIII  jjll ) )FB CCCCCFAAAAAF 00HxEEEE EEE((!) " C  " " >> JJy| $ $ $ $ <+-- &* ###I$:;; JJy ! ! ! ! F-F%S-EE  >r@rFlist[TypeVarId]rH dict[TypeVarId, TypeVarLikeType]'tuple[Solutions, list[TypeVarLikeType]]ct||\}t||}ttt ||}t fd|DsigfStt t||}g}i|dD]`} t fd| DrBtfd| D|} | r$| | j | | j <a|D]O\} } | |vr!|  | | |vr!|  | Pg} |D]@}g}|D]$} | t| %| |Ai}| D])}t||}||*|fd|DfS)aSSolve set of constraints that may depend on each other, like T <: List[S]. The whole algorithm consists of five steps: * Propagate via linear constraints and use secondary constraints to get transitive closure * Find dependencies between type variables, group them in SCCs, and sort topologically * Check that all SCC are intrinsically linear, we can't solve (express) T <: List[T] * Variables in leaf SCCs that don't have constant bounds are free (choose one per SCC) * Solve constraints iteratively starting from leaves, updating bounds after each step. c3:K|]}t|VdSN) check_linear)r<sccrcrds r> z'solve_with_dependent..s/AAS|C00AAAAAAr@rc3<K|]}| o| VdSrnr8)r<r=rcrds r>rqz'solve_with_dependent..s4??R6":~0fRj.??????r@c g|] }| Sr8r8)r<r=rHs r>r?z(solve_with_dependent..s$A$A$ArYr]$A$A$Ar@c g|] }| Sr8r8)r<r=free_solutionss r>r?z(solve_with_dependent..s>>>b~b)>>>r@)transitive_closurecompute_dependencieslistrsetallrr choose_freerVr:addrQsolve_iterativelyrS)rFr.r,rHgraphdmapsccs raw_batchesrarp best_freelubatchesbatchnext_bcr` flat_batchrfrurcrds ` @@@r>rWrWsM/t[AAE66 eVV < > ? ?D AAAAADAAA A A2v w|D$778899KIN1~ 9 9 ?????3??? ? ? 9#$A$A$A$AS$A$A$A=QQI 9  .../8y|,--1 >> 1IMM.+ , , , >> 1IMM.+ , , ,G   & &C NN499 % % % %w.0I  E66BB >>>>I>>> >>r@rr~rcrdc i}t|}|rt|dD]}||s||r|}nn||t||||}|||<|e|D]|\} } | | kr | |kr2|| ||| | f| |kr2|| ||| | f}|d|D |D]} fd||D||<|D]} fd||D||<|S)aSolve transitive closure sequentially, updating upper/lower bounds after each step. Transitive closure is represented as a linear graph plus lower/upper bounds for each type variable, see transitive_closure() docstring for details. We solve for type variables that appear in `batch`. If a bound is not constant (i.e. it looks like T :> F[S, ...]), we substitute solutions found so far in the target F[S, ...] after solving the batch. Importantly, after solving each variable in a batch, we move it from linear graph to upper/lower bounds, this way we can guarantee consistency of solutions (see comment below for an example when this is important). c|jSrn)raw_id)xs r>z#solve_iteratively..sr@keyNci|] \}}||| Srnr8)r<r=ss r>rBz%solve_iteratively..s D D Dgr1amBmmmr@c0h|]}t|Sr8r )r<ltsubss r> z$solve_iteratively..#AAAk"d++AAAr@c0h|]}t|Sr8r )r<utrs r>rz$solve_iteratively..rr@)rysortedremoverYcopyr|rX) rr~rcrdr`s_batchr= solvable_tvresultrrrs @r>r}r}s I%jjG %&8&8999  Bbz VBZ    {###6+.{0CDD!' + > JJLL % %DAqAvvKq f%%% aV$$$Kq f%%% aV$$$; %D E D!2!2 D D DDBBAAAAfRjAAAr BBAAAAfRjAAAr r@Iterable[Type] Type | Nonecd}d}d}g}|D]B}t|}t|tr|js||C|}|s|st}d|_|S|D]:}||}t jrtj||g}*t||};|D]}||}t||}t|} t|} t| tst| tr`t| tr|n|} t| trt| tsJttj| S||r|}ndS||}nt||r|}nd}|S)zWSolve constraints by finding by using meets of upper bounds, and joins of lower bounds.NT) source_any)r& isinstancer#r[rVr' infer_unionsr$ make_unionrrrrrfrom_another_anyr) rcrdbottomtoprg new_uppersrpurLp_topp_bottomrs r>rYrYsFC!IJ !! Q  "o.. !bl !   a F &#%% "   4 4 >FF& 4#-vv.>??#FF33** ;CCS&))CC C Ev&&H%!!Z'%B%B&ug66BSSF *j11UjW6U6UUUUy1jIIII   II4  FC   r@rplist[TypeVarLikeType]TypeVarLikeType | Nonect|dkr|dStd|D}t|}t|tt frdSg}|D]<}t|t r%|jr|rdS|j}=|rt|sdSt|fd}t|t r| ||St|d r|SdS) aChoose the best solution for an SCC containing only type variables. This is needed to preserve e.g. the upper bound in a situation like this: def dec(f: Callable[[T], S]) -> Callable[[T], S]: ... @dec def test(x: U) -> U: ... where U <: A. rcg|] }|j Sr8) upper_bound)r<ts r>r?zchoose_free..Is(D(D(D1(D(D(Dr@Nc.|jv|jjfSrn)r:r)rr,s r>rzchoose_free..as14}#r{r{7sE 3xx1}}1v '(D(D(D(D(DEE*+=>>&((CDDtF&& b+ & & &29 & ttY^^%%F &';<<t sJJJJ K K KD$ $$Q!!=O!PPP,$??? 4r@tprrct|tr9|jjdkr)|o&t t |jdSt|to|jjdkS)Nzbuiltins.tuplerzbuiltins.object)rrtypefullnamerr&args)rrs r>rrjsg"hMBG$48H$H$HL/ 0K0KLLL b( # # M(8 find_linearrps!#[11% ah , , %$ $!#]33% ah . . %qx7P %$ $!#%566* ** fi ( ( *S->->!-C-C<?D$ ++ * 49FV0W0W *TY\)) ;r@tvarstuple[Graph, Bounds, Bounds]cP tt}tt}dD t|}|r|}t|\}}|r|vr|J|jt kr |j|c n ||jc  f vr_ fdDz D]}|f vr||xx| zcc<D]} | f vr|| xx|zcc<| D]} |D]} t|| | n|jt krm|j||jvrD]-} | |jf vr ||  |j.||jD]} t|| |jn~|jtksJ|j||jvrD]-}|j|f vr || |j.||jD]} t||j| |؉ ||fS)awFind transitive closure for given constraints on type variables. Transitive closure gives maximal set of lower/upper bounds for each type variable, such that we cannot deduce any further bounds by chaining other existing bounds. The transitive closure is represented by: * A set of lower and upper bounds for each type variable, where only constant and non-linear terms are included in the bounds. * A graph of linear constraints between type variables (represented as a set of pairs) Such separation simplifies reasoning, and allows an efficient and simple incremental transitive closure algorithm that we use here. For example if we have initial constraints [T <: S, S <: U, U <: int], the transitive closure is given by: * {} <: T <: {int} * {} <: S <: {int} * {} <: U <: {int} * {T <: S, S <: U, T <: U} ch|]}||fSr8r8r;s r>rz%transitive_closure..s---RH---r@Nc:h|]}D]}|fv|fv||fSr8r8)r<rrr~lowerruppers r>rz%transitive_closure..sVu*+E e8K8KQVXYPZ^cPcPcAPcPcPcPcr@) rrypoprrKrrUadd_secondary_constraintsrLr|r )rr.rdrc remainingrN is_linear target_idrrrrr~rrs` @@@r>rvrvs,!%%F %%F--u---EK  I +C MMOO +1~~ 9 $ Ce++(((tz!! z9 uu(!* uu~&&  % E / /1:&&1III.III / /u:&&1III.IIIUm A A -AAB-iR@@@@A ATZ  x6!*--- , ,qz?e++1IMM!(+++QZ( C C))RBBBB C4<''''x6!*--- , ,J?e++1IMM!(+++QZ( C C))QXrBBBBW +CX &&  r@rbset[Constraint]rrrNonec jtt|tr$tt|trdS|t t ||t |t t ||tdS)zFAdd secondary constraints inferred between lower and upper (in place).N)rr&r$rSryr rr )rbrrs r>rrs/%(()44 :: IIc#E5*==>>???IIc#E5,??@@AAAAAr@ dict[TypeVarId, list[TypeVarId]]c&i}|D]}t}||D]}|t||z}||D]}|t||z}|D]*} | |kr || f|vs| |f|vr|| +t|||<|S)zCompute dependencies between type variables induced by constraints. If we have a constraint like T <: List[S], we say that T depends on S, since we will need to solve for S first before we can solve for T. )ryrZr|rx) rr~rcrdrfr=depsrrothers r>rwrws C  uu* ( (B HR'' 'DD* ( (B HR'' 'DD  E{{E{e##r{e';';t**B Jr@set[TypeVarId]cD]J}tfd||DrdStfd||DrdSKdS)zCheck there are only linear constraints between type variables in SCC. Linear are constraints like T <: S (while T <: F[S] are non-linear). c3RK|]!}t|tV"dSrnrZrx)r<rrps r>rqzcheck_linear..3<<2xDII&&<<<<<rqzcheck_linear..rr@T)any)rprcrdr=s` r>roros~  <<<<<<< < < 55 <<<<<<< < < 55  4r@c  t|D]}t|j}t|tr|jD]}t|t r||jkr&|jtkr |H t|t|j|j t|j|j|fd|DS)a?Avoid ambiguities for constraints inferred from unions during polymorphic inference. Polymorphic inference implicitly relies on assumption that a reverse of a linear constraint is a linear constraint. This is however not true in presence of union types, for example T :> Union[S, int] vs S <: T. Trying to solve such constraints would be detected ambiguous as (T, S) form a non-linear SCC. However, simply removing the linear part results in a valid solution T = Union[S, int], S = . A similar scenario is when we get T <: Union[T, int], such constraints carry no information, and will equally confuse linearity check. TODO: a cleaner solution may be to avoid inferring such constraints in first place, but this would require passing around a flag through all infer_constraints() calls. cg|]}|v| Sr8r8)r<rNreverse_union_css r>r?z2skip_reverse_union_constraints..s$ 7 7 7!Q&666A666r@) ryr&rLrr$rXr"rrKrr|r r )rbrNp_targetrrs @r>rTrTsuu  T T"18,, h * * T  T TdK00Tq000QTZ5G5G(,,Q/// %((D&,,HY)Z)Z[[[$((A4EqtT)R)RSSS 7 7 7 7r 7 7 77r@rLcTdt|Dt|zS)z>Find type variables for which we are solving in a target type.ch|] }|j Sr8r9r;s r>rzget_vars..s 6 6 6bBE 6 6 6r@)rry)rLrFs r>rZrZs* 6 6-f55 6 6 6T BBr@r`list[Type | None]cg}t||D]\}}t|jr||/|t ||jsd}|D]^}|jt krt |j|jsd}n/|jtkrt |j|jsd}n_|r||j|||S)zCheck is each solution satisfies the upper bound of the corresponding type variable. If it doesn't satisfy the bound, check if bound itself satisfies all constraints, and if yes, use it instead as a fallback solution. NTF) zipis_callable_protocolrrVrrKrrLr )r`r,r. new_solutionsrrbound_satisfies_allrNs r>r]r] s(*MM9--  1  . .    # # #  =Aq}!=!=="&    4:%%j.Q.Q%*/'E4<'' 18Q]0S0S'*/'E" $$Q]333Q r@rct|}t|tr|jjrd|jjvSdS)N__call__F)r&rrr is_protocolprotocol_members)rproper_ts r>rrAsBq!!H(H%%<(-*C<X];;; 5r@N)TFF) r,r-r.r/r0r1r2r1r3r1r4r5) rFrir.r/r,rirHrjr4rk) rrir~r*rcr)rdr)r4r+)rcrrdrr4r)rprr,rir4r)F)rrrr1r4r1)rNr r4r)rrir.r/r4r)rbrrrrrr4r) rrir~r*rcr)rdr)r4r)rprrcr)rdr)r4r1)rbr/r4r/)rLrrFrir4r)r`rr,r-r.r/r4r)rrr4r1)F__doc__ __future__r collectionsrcollections.abcrrtyping_extensionsrr(mypy.constraintsrr r r r mypy.expandtypermypy.graph_utilsrrr mypy.joinr mypy.meetrr mypy.subtypesr mypy.typeopsr mypy.typesrrrrrrrrrr r!r"r#r$r%r&mypy.typestater'r)__annotations__r*r+rhrWr}rYr{rrrvrrwrorTrZr]rr8r@r>rsg'''""""""######........555555\\\\\\\\\\\\\\''''''QQQQQQQQQQ 00000000$$$$$$******$&%%%%%11111666666 6666 #" UUUUUp:?:?:?:?z9999x::::z0000fNNNNN "G!G!G!G!T B B B B0    8888:CCCC Br@