X-Ph!RUdZddlmZddlmZddlmZddlmZ ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZdd lmZdd lm 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.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8dd l9m:Z:ee;efZ?d e@d <eAee?dfdfZBd e@d<eAeCdfZDd e@d<d2dZEd3dZFd4dZGd5d"ZHd6d$ZId7d'ZJd5d(ZKd8d+ZLGd,d-e4eBZMd9d0ZNd1S):ab Utilities for comparing two versions of a module symbol table. The goal is to find which AST nodes have externally visible changes, so that we can fire triggers and re-process other parts of the program that are stale because of the changes. Only look at detail at definitions at the current module -- don't recurse into other modules. A summary of the module contents: * snapshot_symbol_table(...) creates an opaque snapshot description of a module/class symbol table (recursing into nested class symbol tables). * compare_symbol_table_snapshots(...) compares two snapshots for the same module id and returns fully qualified names of differences (which act as triggers). To compare two versions of a module symbol table, take snapshots of both versions and compare the snapshots. The use of snapshots makes it easy to compare two versions of the *same* symbol table that is being mutated. Summary of how this works for certain kinds of differences: * If a symbol table node is deleted or added (only present in old/new version of the symbol table), it is considered different, of course. * If a symbol table node refers to a different sort of thing in the new version, it is considered different (for example, if a class is replaced with a function). * If the signature of a function has changed, it is considered different. * If the type of a variable changes, it is considered different. * If the MRO of a class changes, or a non-generic class is turned into a generic class, the class is considered different (there are other such "big" differences that cause a class to be considered changed). However, just changes to attributes or methods don't generally constitute a difference at the class level -- these are handled at attribute level (say, 'mod.Cls.method' is different rather than 'mod.Cls' being different). * If an imported name targets a different name (say, 'from x import y' is replaced with 'from z import y'), the name in the module is considered different. If the target of an import continues to have the same name, but it's specifics change, this doesn't mean that the imported name is treated as changed. Say, there is 'from x import y' in 'm', and the type of 'x.y' has changed. This doesn't mean that that 'm.y' is considered changed. Instead, processing the difference in 'm' will be handled through fine-grained dependencies. ) annotations)Sequence)Union) TypeAlias) expand_type)SYMBOL_FUNCBASE_TYPESUNBOUND_IMPORTED DecoratorFuncDefFuncItemMypyFileOverloadedFuncDef ParamSpecExpr SymbolNode SymbolTablerTypeInfo TypeVarExprTypeVarTupleExprVar)find_dataclass_transform_spec)state)AnyType CallableType DeletedType ErasedTypeInstance LiteralTypeNoneType Overloaded Parameters ParamSpecType PartialType TupleTypeType TypeAliasType TypedDictTypeTypeType TypeVarIdTypeVarLikeTypeTypeVarTupleType TypeVarType TypeVisitor UnboundTypeUninhabitedType UnionType UnpackType) get_prefix _TypeAlias Primitive SnapshotItem.SymbolSnapshot name_prefixstr snapshot1dict[str, SymbolSnapshot] snapshot2returnset[str]cfd|D}fd|D}||z }t|t|zD]}||}||}|d} |d} d|} | | kr|| E| dkr|dd|ddkr|| t|dtsJt|dtsJ|t | |d|dz}||||kr|| |S)aReturn names that are different in two snapshots of a symbol table. Only shallow (intra-module) differences are considered. References to things defined outside the module are compared based on the name of the target only. Recurse into class symbol tables (if the class is defined in the target module). Return a set of fully-qualified names (e.g., 'mod.func' or 'mod.Class.method'). ch|] }d| S..0namer6s S/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/server/astdiff.py z1compare_symbol_table_snapshots..' < < <$%%t%% < < <ch|] }d| Sr?rArBs rErFz1compare_symbol_table_snapshots..rGrHrr@rN)setkeysadd isinstancedictcompare_symbol_table_snapshots) r6r8r:names1names2triggersrDitem1item2kind1kind2 item_names ` rErPrP|s= < < <) < < > LL # # # # j SbSzU3B3Z'' Y'''eBi.. . . .eBi.. . . . 6y%)USUYWW WHH)D/11 Y''' OrHtablerci}|D]\}}|j}|r|jnd}||j|jf}t |t rd|f||<Dt |trCd|jd|j Dt|j t|j f||<t |tr9dt|j|j|jt%|jf||<t |t(r4d|jt|j t|j f||<3t |t*r4d|jt|j t|j f||<||jt,ksJ|r4t/|j|krd|t1|jf||<t5||||<|S) amCreate a snapshot description that represents the state of a symbol table. The snapshot has a representation based on nested tuples and dicts that makes it easy and fast to find differences. Only "shallow" state is included in the snapshot -- references to things defined in other modules are represented just by the names of the targets. N ModulerefTypeVarc,g|]}t|SrA snapshot_type)rCvalues rE z)snapshot_symbol_table..s ???%u%%???rHr ParamSpec TypeVarTupleCrossRef)itemsnodefullnamekind module_publicrNr rvariancevaluesr_ upper_bounddefaultrsnapshot_types alias_tvars normalizedno_argssnapshot_optional_typetargetrrr r1type__name__snapshot_definition)r6rYresultrDsymbolrfrgcommons rEsnapshot_symbol_tablerzs)+F 1A1A f{$(24==dFK)=> dH % %, A (0F4LL k * *& A ??4;???d.//dl++ F4LLi ( ( At/00 &t{33 F4LLm , , A d.//dl++ F4LL . / / A d.//dl++ F4LL;"22222 A 4=11[@@!+FDJJ4GHt 24@@t MrHrfSymbolNode | Noneryc~t|trK|jrt|j}nt |}d}t|t r|}n4|jr-t|jtr |jjn|j}d}t|trN|j rG|j d}t|tr%|jj rt|j j}|r|jnd}t!|}d||j |j|j|j||||ndt|t r|jnd|f St|t,rd|t|j|jfSt|tr5d|jt|j jt1|j|fSt|t2r4|j}|t!|}|j|j|j|j|j|j |j!t|j"t|j#t|j$d|j%DtMd|j'j(Dd |j)Dd |j*D||nd|jf}|j+} tY| |j-} d tMt]|j/f| d <d ||| fSJt|)zCreate a snapshot description of a symbol table node. The representation is nested tuples and dicts. Only externally visible attributes are included. NrFFuncrr cg|] }|j SrA)rgrCbases rEraz'snapshot_definition..,s 0 0 0tT] 0 0 0rHc34K|]}t|VdSNr^)rCtdefs rE z&snapshot_definition..5s*FF$-%%FFFFFFrHc,g|]}t|SrAr^rs rEraz'snapshot_definition..6s 8 8 8T]4 8 8 8rHc,g|]}t|SrAr^)rCps rEraz'snapshot_definition..7s 5 5 5!]1   5 5 5rHAbstractz (abstract)r)0rNrrtr_snapshot_untyped_signaturer implr funcrre is_propertyrrvar setter_typeis_trivial_bodyris_finalis_class is_static serialize deprecatedr is_overloadrvrdataclass_transform_spec is_abstractis_enum is_protocolfallback_to_anymeta_fallback_to_anyis_named_tuple is_newtypemetaclass_type tuple_typetypeddict_typemrotupledefn type_varsbases_promotergrznamessortedabstract_attributes) rfry signaturerr first_itemrrattrsprefix symbol_tables rErvrvsF $-..U! 9 9,9$),D,DII2488I# dG $ $ UDD Y U%/ 9%E%ET49>>49D d- . . Q4: QAJ*i00 QZ_5P Q4Z^5OPP 26A$..E#@#F#F     M M N  4L4X $ . . 0 0 0^b)$88 BDOOd    D#  6!v5di@@$-PP D) $ $4!    "48= 1 1  6 2 2   D( # #'!#'#@ # +'DT'J'J $   L     %   O "4#6 7 7 "4? 3 3 "4#6 7 7 0 0tx 0 0 0 FF$)2EFFF F F 8 8TZ 8 8 8 5 5t} 5 5 54L4X $ . . 0 0 0^b O3 6,VTZ@@ &0%t?W8X8X2Y2Y%Z \"FE<88 !d4jj   rHtypr$cD|tS)z?Create a snapshot representation of a type using nested tuples.)acceptSnapshotTypeVisitorrs rEr_r_Es ::)++ , ,,rH Type | Nonec(|rt|SdS)N)z r^rs rErrrrJs S!!!~rHtypesSequence[Type]c4td|DS)Nc34K|]}t|VdSrr^rCitems rErz!snapshot_types..Rs*77t$$777777rH)r)rs rErnrnQs 77777 7 77rHc,t|jfSr)rtrurs rEsnapshot_simple_typerUs II   rHs str | Nonec|dS|S)NzrA)rs rEencode_optional_strrYsyxrHceZdZdZd1dZd2dZd3d Zd4d Zd5dZd6dZ d7dZ d8dZ d9dZ d:dZ d;dZddZd?d!Zd@d#ZdAd%ZdBd'ZdCd)ZdDd+ZdEd-ZdFd/Zd0S)Gra<Creates a read-only, self-contained snapshot of a type object. Properties of a snapshot: - Contains (nested) tuples and other immutable primitive objects only. - References to AST nodes are replaced with full names of targets. - Has no references to mutable or non-primitive objects. - Two snapshots represent the same object if and only if they are equal. - Results must be sortable. It's important that tuples have consistent types and can't arbitrarily mix str and None values, for example, since they can't be compared. rr-r;r4cRd|j|j|jt|jfS)Nr-)rDoptionalempty_tuple_indexrnargsselfrs rEvisit_unbound_typez&SnapshotTypeVisitor.visit_unbound_typeos,  H L  ! 38 $ $   rHrc t|Srrrs rE visit_anyzSnapshotTypeVisitor.visit_anyx#C(((rHrc t|Srrrs rEvisit_none_typez#SnapshotTypeVisitor.visit_none_type{rrHr.c t|Srrrs rEvisit_uninhabited_typez*SnapshotTypeVisitor.visit_uninhabited_type~rrHrc t|Srrrs rEvisit_erased_typez%SnapshotTypeVisitor.visit_erased_typerrHrc t|Srrrs rEvisit_deleted_typez&SnapshotTypeVisitor.visit_deleted_typerrHrch|jr^ttfd|jjDt|jjf}nd}dt |jjt|j |j dnt|j |fS)Nc3LK|]\}}||fVdSr)r)rCkvrs rErz5SnapshotTypeVisitor.visit_instance..s6[[TQa$0[[[[[[rHrAr)None) extra_attrsrrrre immutablerrtrgrnrlast_known_valuer_)rrrs` rEvisit_instancez"SnapshotTypeVisitor.visit_instances ? f[[[[S_=R=X=X=Z=Z[[[[[\\co/00KK K   1 2 2 38 $ $-5II=I];^;^    rHr+c d|j|j|jj|jjt |jt|jt|j |j f S)Nr\) rDrgidraw_id meta_levelrnrkr_rlrmrjrs rEvisit_type_varz"SnapshotTypeVisitor.visit_type_varsT  H L FM F  3: & & #/ * * #+ & & L  rHr!cd|jj|jj|jt |jt |jfS)Nrb)rrrflavorr_rlrmrs rEvisit_param_specz$SnapshotTypeVisitor.visit_param_specs=  FM F  J #/ * * #+ & &   rHr*cd|jj|jjt|jt|jfS)Nr*)rrrr_rlrmrs rEvisit_type_var_tuplez(SnapshotTypeVisitor.visit_type_var_tuples8  FM F  #/ * * #+ & &   rHr0c.dt|jfS)Nr0)r_rtrs rEvisit_unpack_typez%SnapshotTypeVisitor.visit_unpack_typesmCH5566rHr cdt|jtd|jDtd|jDfS)Nr c34K|]}t|VdSrrrCrDs rErz7SnapshotTypeVisitor.visit_parameters..+FF%d++FFFFFFrHc3$K|] }|jV dSrr`rCrs rErz7SnapshotTypeVisitor.visit_parameters..$11a!'111111rH)rn arg_typesr arg_names arg_kindsrs rEvisit_parametersz$SnapshotTypeVisitor.visit_parameterssT  3= ) ) FF FFF F F 113=111 1 1   rHrc r|r||}dt|jt |jt d|jDt d|jD| |j t|j fS)Nrc34K|]}t|VdSrrrs rErz:SnapshotTypeVisitor.visit_callable_type..rrHc3$K|] }|jV dSrrrs rErz:SnapshotTypeVisitor.visit_callable_type..rrH) is_genericnormalize_callable_variablesrnrr_ret_typerrr is_type_objis_ellipsis_args variablesrs rEvisit_callable_typez'SnapshotTypeVisitor.visit_callable_types >>   933C88C  3= ) ) #, ' ' FF FFF F F 113=111 1 1 OO    3= ) )  rHcNg}i}t|jD]\}}td|z }t|tr||}nYt|t r||}n-t|tsJ||}|||||j <tj d5t|||cdddS#1swxYwYdS)zBNormalize all type variable ids to run from -1 to -len(variables).rJ)rT)rN) enumeraterr(rNr+ copy_modifiedr*r!appendrrstrict_optional_setr)rrtvstvmapirtidtvs rErz0SnapshotTypeVisitor.normalize_callable_variablessu')cm,,  DAqBF##C![)) -&'ooo&=&=A/00 -___,,!!]33333___,, JJrNNNE!$KK  &t , , H HsE**8838GG H H H H H H H H H H H H H H H H H Hs)$DD!Dr#c.dt|jfS)Nr#rnrers rEvisit_tuple_typez$SnapshotTypeVisitor.visit_tuple_types^CI6677rHr&ctd|jD}tt|j}tt|j}d|||fS)Nc3>K|]\}}|t|fVdSrr^)rCkey item_types rErz;SnapshotTypeVisitor.visit_typeddict_type..s3^^.#ysM)445^^^^^^rHr&)rrer required_keys readonly_keys)rrrerequiredreadonlys rEvisit_typeddict_typez(SnapshotTypeVisitor.visit_typeddict_typesi^^CIOOL]L]^^^^^ 12233 12233(;;rHrc:dt|j|jfS)Nr)r_fallbackr`rs rEvisit_literal_typez&SnapshotTypeVisitor.visit_literal_types}S\::CIFFrHr/cdd|jD}tt|}d|fS)Nc,h|]}t|SrAr^rs rErFz7SnapshotTypeVisitor.visit_union_type..s ;;;t$$;;;rHr/)rerr)rrrerps rEvisit_union_typez$SnapshotTypeVisitor.visit_union_types7<;;;;6%==)) Z((rHrc.dt|jfS)Nrr rs rEvisit_overloadedz$SnapshotTypeVisitor.visit_overloadedsnSY7788rHr"ctr) RuntimeErrorrs rEvisit_partial_typez&SnapshotTypeVisitor.visit_partial_types rHr'c.dt|jfS)Nr')r_rrs rEvisit_type_typez#SnapshotTypeVisitor.visit_type_typesM#(3344rHr%cV|jJd|jjt|jfS)Nr%)aliasrgrnrrs rEvisit_type_alias_typez)SnapshotTypeVisitor.visit_type_alias_types,y$$$!3^CH5M5MNNrHN)rr-r;r4)rrr;r4)rrr;r4)rr.r;r4)rrr;r4)rrr;r4)rrr;r4)rr+r;r4)rr!r;r4)rr*r;r4)rr0r;r4)rr r;r4)rrr;r4)rrr;r)rr#r;r4)rr&r;r4)rrr;r4)rr/r;r4)rrr;r4)rr"r;r4)rr'r;r4)rr%r;r4)ru __module__ __qualname____doc__rrrrrrrrrrrrrrrrrrrr"r$r'rArHrErr`s      ))))))))))))))))))))    "             7777         HHHH$8888<<<< GGGG))))9999 5555OOOOOOrHrrOverloadedFuncDef | FuncItemct|tr(t|jt|jfSg}|jD]}t|t rO|jjr-| t|jjP| df| t|t|S)aCreate a snapshot of the signature of a function that has no explicit signature. If the arguments to a function without signature change, it must be considered as different. We have this special casing since we don't store the implicit signature anywhere, and we'd rather not construct new Callable objects in this module (the idea is to only read properties of the AST here). )DecoratorWithoutType) rNr rrrrer rrtrr_r)rrwrs rErrs$!! dn%%uT^'<'<==')J @ @D$ ** @8==MM- ">">????MM";<<<< 8>>????V}}rHN)r6r7r8r9r:r9r;r<)r6r7rYrr;r9)rfr{ryr5r;r5)rr$r;r4)rrr;r4)rrr;r4)rrr;r7)rr+r;r5)Or* __future__rcollections.abcrtypingrtyping_extensionsrr2mypy.expandtyper mypy.nodesrr r r r r rrrrrrrrmypy.semanal_sharedr mypy.stater mypy.typesrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0 mypy.utilr1r7floatintboolr3__annotations__rr4objectr5rPrzrvr_rrrnrrrrrArHrEr=s222h#"""""$$$$$$555555''''''">=====6! c5#t34 4444 y.'@!A3!FG GGGG#63;/////((((V====@[![![![!|---- 8888!!!!cOcOcOcOcO+l3cOcOcOLrH