pPjUdZddlmZddlZddlmZddlmZmZddlm Z m Z m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZmZmZmZm 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-dd l.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAe+ezZBdeCd<eDee#gdfee9geEffZFdeCd<eGeDeHeHfeeIfZJdeCd<d1dZKd2dZLeKZMdeCd<eLdZNdeCd<eLdZOdeCd<dZPdeCd<hdZQdeCd <hd!ZRdeCd"<hd#ZSdeCd$<hd%ZTdeCd&<hd'ZUdeCd(<Gd)d*ZVd3d+ZW d4 d5d,ZX d6d-ZYGd.d/ZZd7d0Z[y)8a Format expression type checker. This file is conceptually part of ExpressionChecker and TypeChecker. Main functionality is located in StringFormatterChecker.check_str_format_call() for '{}'.format(), and in StringFormatterChecker.check_str_interpolation() for printf-style % interpolation. Note that although at runtime format strings are parsed using custom parsers, here we use a regexp-based approach. This way we 99% match runtime behaviour while keeping implementation simple. ) annotationsN)Callable)MatchPattern)Final TypeAliascast)message_registry)TypeCheckerSharedApi)Errors)map_instance_to_supertype)MessageBuilder) ARG_NAMEDARG_POSARG_STAR ARG_STAR2 BytesExprCallExprContextDictExpr ExpressionExpressionStmt IndexExprIntExpr MemberExprMypyFileNameExprStarExprStrExprTempNode TupleExpr)parse) is_subtype)custom_special_method) AnyTypeInstance LiteralType TupleTypeType TypeOfAnyTypeVarTupleType TypeVarType UnionType UnpackTypefind_unpack_in_listget_proper_typeget_proper_types _TypeAliasFormatStringExprCheckersMatchMapcld}d}d}d}d}d}d|z|z|z|z|z|z}tj|S)zConstruct regexp to match format conversion specifiers in % interpolation. See https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting The regexp is intentionally a bit wider to report better errors. z(\((?P[^)]*)\))?z(?P[#0\-+ ]*)z(?P[1-9][0-9]*|\*)?z (?:\.(?P\*|[0-9]+)?)?z[hlL]? (?P.)?%recompile)key_reflags_rewidth_re precision_re length_mod_retype_re format_res X/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/checkstrformat.pycompile_format_rerDGsT &F&H,H6LMGf x'(2\AMQT[[I ::i  crd}d}|sd}d}d}d|z|z|zdz}nd}tj||z|zS) aConstruct regexps to match format conversion specifiers in str.format() calls. See After https://docs.python.org/3/library/string.html#formatspec for specifications. The regexps are intentionally wider, to report better errors, instead of just not matching. z%(?P(?P[^.[!:]*)([^:!]+)?)z(?P![^:])?z(?P.?[<>=^])?z?(?P[+\- ]?#?0?)(?P\d+)?[_,]?(?P\.\d+)?r7z(?P:z)?z(?P:.*)?r9) custom_specfield conversion fill_alignnum_spec conv_type format_specs rCcompile_new_format_rerNWsa 5E+J 1 V# *Z7(BYNQVV / ::ej(;6 77rEr FORMAT_REF FORMAT_RE_NEWTFORMAT_RE_NEW_CUSTOM__dummy_name__DUMMY_FIELD_NAME> EFGXdefgiouxNUMERIC_TYPES_OLD> rTrUrVrWbrXrYrZr[nr]r_r8NUMERIC_TYPES_NEW>rWr]r_REQUIRE_INT_OLD>rWrarXr]r_REQUIRE_INT_NEW>rTrUrVrYrZr[ FLOAT_TYPESc6eZdZ d ddZddZddZy)ConversionSpecifierc|j|_||_|j}|j d|_|j dxsd|_|j dxsd|_|j dxsd|_|j dxsd|_ |j d|_ ||_ |j d|_ |j d |_ y) Nkeytypeflagswidth precisionrMrIrH)group whole_seq start_pos groupdictgetrjrLrmrnrorMnon_standard_format_specrIrH)selfmatchrrrum_dicts rC__init__zConversionSpecifier.__init__s""::e$ F+1rZZ(.B ZZ(.B K06B"::m4(@% **\2ZZ( rEc|jduSNrjrvs rChas_keyzConversionSpecifier.has_keysxxt##rEcB|jdk(xs|jdk(S)N*)rnror}s rChas_starzConversionSpecifier.has_starszzS 9DNNc$99rEN)F)rwz Match[str]rrintruboolreturnNone)rr)__name__ __module__ __qualname__ryr~rrErCrhrhs4W\)),/)PT) )0$:rErhcg}tjt|D],}|jt ||j .|S)zFParse c-printf-style format string into list of conversion specifiers.rr)r:finditerrOappendrhstart) format_str specifiersms rCparse_conversion_specifiersrsE,.J [[J /G-a1779EFG rEct|||}|yg}|D]^\}}tj|}|rt||} nJtj|} | rt| |d} n$|j d|t jy| jr@d| jvsd| jvr$|j d |t jy|j| | js| jsd| jvsd| jvs |r$|j d |t jyt| j||d } | y|j| a|S) zParse format string into list of conversion specifiers. The specifiers may be nested (two levels maximum), in this case they are ordered as '{0:{1}}, {2:{3}{4}}'. Return None in case of an error. NrT)rrruz-Invalid conversion specifier in format stringcode{}z(Conversion value must not contain { or }z2Formatting nesting must be at most two levels deep)nested)find_non_escaped_targetsrP fullmatchrhrQfailcodesSTRING_FORMATTINGrjrrMruparse_format_valueextend) format_valuectxmsgr top_targetsresulttargetrrrw conv_spec custom_matchsub_conv_specss rCrrsp+<cBK(*F('* ''/ +EYGI/99&AL/ IPT C00  ==cY]]2cY]]6J HH?5KbKbH c i   ! !22 --- 8M8M1MH00 / 0E0EsCX\]N% MM. )O'*P MrEcg}d}d}d}|t|kr||}|ss|dk(r$|t|dz kr||dzdk(r|dz }nd}|dk(r|t|dz kr||dzdk(r|dz }n`|jd|tjy|dk(r|dz }|dk(r|dz}|r||z }n!|j ||t|z fd}|dz }|t|kr|r#|jd |tjy|S) amReturn list of raw (un-parsed) format specifiers in format string. Format specifiers don't include enclosing braces. We don't use regexp for this because they don't work well with nested/repeated patterns (both greedy and non-greedy), and these are heavily used internally for representation of f-strings. Return None in case of an error. rlrrrz;Invalid conversion specifier in format string: unexpected }rNz:Invalid conversion specifier in format string: unmatched {)lenrrrr)rrrr next_specposnestingcs rCrrsTFI CG L! !  Cx\*Q..<a3HC3O1HCGCx\*Q..<a3HC3O1HCHHU"44  Cx1 Cx1 Q  y#I*>?@  q= L! !>  H ((   MrEceZdZUdZded<ded<d dZd!dZ d"dZ d#d Zd$d Z d%d Z d&d Z d'd Z d(dZ d)dZd*dZ d+dZ d,dZ d,dZd-dZ d.dZ d/dZd0dZd1dZ d2dZd3dZ d4dZ d5 d6dZd7dZd8d9dZy):StringFormatterCheckerzxString interpolation/formatter type checker. This class works closely together with checker.ExpressionChecker. r chkrrc ||_||_y)z%Construct an expression type checker.N)rr)rvrrs rCryzStringFormatterChecker.__init__,srEct|||j}|y|j||sy|j|||y)aPerform more precise checks for str.format() calls when possible. Currently the checks are performed for: * Actual string literals * Literal types with string values * Final names with string values The checks that we currently perform: * Check generic validity (e.g. unmatched { or }, and {} in invalid positions) * Check consistency of specifiers' auto-numbering * Verify that replacements can be found for all conversion specifiers, and all arguments were used * Non-standard format specs are only allowed for types with custom __format__ * Type check replacements with accessors applied (if any). * Verify that specifier type is known and matches replacement type * Perform special checks for some specifier types: - 'c' requires a single character string - 's' must not accept bytes - non-empty flags are only allowed for numeric types N)rrauto_generate_keyscheck_specs_in_format_call)rvcallr conv_specss rCcheck_str_format_callz,StringFormatterChecker.check_str_format_call1sD*( dDHHE   &&z48  ''j,GrEc td|DsJd|j||Dcgc]}tt|jc}}t |t |k(sJt ||D]f\}}|j|||}t|tr |jn|jj|}|J|jr|jrtd|jvsfd|jvsXt|dd r |j r>|j"j%d |jd dd |t&j( |j*st-t.j0} nt|j2t4sJt|j2j6t8r|j2j6} n t9|} |j;|j*|| d} |j _|j d dvr=|j"j%d|j d d|t&j( |j=d}| t?|} t| t@rtC| jDn| g} | D]7} t| dr|jG| | ||jI|||| | 9iycc}w)zPerform pairwise checks for conversion specifiers vs their replacements. The core logic for format checking is implemented in this method. c34K|]}|jywr{r|.0ss rC zDStringFormatterChecker.check_specs_in_format_call..Ts(Q155(s"Keys must be auto-generated first!rNrr __format__T) check_allz#Unrecognized format specification "r"r format_callrsazInvalid conversion type "z!", must be one of "r", "s" or "a" builtins.str)%allfind_replacements_in_callr strrjrzipapply_field_accessors isinstancer rkr lookup_typerMrur$rIrrrrrLr%r* special_formcalleerexprrconversion_type named_typer0r-r1itemscheck_placeholder_typeperform_special_format_checks) rvrspecsrr replacementsspecrepl actual_type expected_typera_type actual_itemss rCrz1StringFormatterChecker.check_specs_in_format_callMs(%((N*NN(55dW\<]RST#quu=M<]^ < CJ...e\2= \JD$--dDd-CD'1$'A$))txxG[G[\`GaK* **  11D,,,t7G7G0G.kN>Nqr>R=SSTU"44" >>-4Y5K5K-L !$++z:::dkk..8!%!1!1J!(!6J $ 4 4NND*$!5! *??1%U2HHMM78J7KL=>"44 "#oon= $$[1F2++FM4H224tV][  \s= \=^s!K" c6|jdk(rt|ttfr5t |j dk7r|j j|dt|jj|}t|tr|jr |j}t|trOt|j tr5t |j dk7r|j j|d|jr|jdk(rP|jsDt!|dr8t#|ds,|j j%d|t&j( |j*rt-|j/d |j/d g}|jr|jt0vs$|jsGt3||s:t#|d s-|j j%d |t&j4 yyyyy)NrrTrrbuiltins.bytes__str__zIf x = b'abc' then f"{x}" or "{}".format(x) produces "b'abc'", not "abc". If this is desired behavior, use f"{x!r}" or "{!r}".format(x). Otherwise, decode the bytesr builtins.intbuiltins.floatrz0Numeric flags are only allowed for numeric types)rLrrrrvaluerrequires_int_or_charr0rrr&last_known_valuer'rrIhas_type_componentr$rr STR_BYTES_PY3rmr-rrcr#r)rvrrrrrc_typ numeric_typess rCrz4StringFormatterChecker.perform_special_format_checkss >>S $) 45#djj/Q:N--d-E#DHH$8$8$>?E%*u/E/E..%-*U[[#2Nu{{#q(HH11$D1I$..C"7!+/?@I^YJ 2,,  ::%0$//BR2STMNN*;;~~"; >-k<H F00I?& rEc"g}t}|D]}|jro|jt||}|s|jj d||t jtttj}nf|j||}|sR|jj d|d|t jtttj}|j|t|tr |j|t!|j"Dcgc]}|t$t&fvs|c}}t!||kr|jj)||Scc}w)zFind replacement expression for every specifier in str.format() call. In case of an error use TempNode(AnyType). z8Cannot find replacement for positional format specifier rz4Cannot find replacement for named format specifier "r)set isdecimalget_expr_by_positionrrrrrr r%r* from_errorget_expr_by_namerraddr arg_kindsrr$too_many_string_formatting_arguments) rvrkeysrusedrjrkindtotal_explicits rCrz0StringFormatterChecker.find_replacements_in_callsQ $& # C}}00S4@HHMMRSVRWX"44" $GI,@,@$ABD,,S$7HHMMNseSTU"44" $GI,@,@$ABD MM$ dH-+ 0t~~^t'S\I]A]d^_ t9~ % HH 9 9$ ? _s F F ct|j|jDcgc]\}}|tk(s|}}}|t |kr||St|j|jDcgc]\}}|t k(s|}}}|sy|d}t |jj|}t|tr|jjds"tttj S|jj#dttj gj} tt%|| jdScc}}wcc}}w)zGet positional replacement expression from '{0}, {1}'.format(x, y, ...) call. If the type is from *args, return TempNode(). Return None in case of an error. Nrztyping.Sequence)rargsrrrrr0rrrr&rkhas_baser r%r*rnamed_generic_typer ) rvrrargrpos_args star_argsstar_arg varargs_type iter_infos rCrz+StringFormatterChecker.get_expr_by_positions3 *-TYY)G[IC4SZ?C[[ X C= *-dii*H]YS$DT\L\S] ]Q<&txx';';H'EF ,19J9J9S9S : GI$:$:;< <HH//  (>(> ?@ $ 1, JOOPQRSS%\^sE%E%3E+E+ct|j|j|jDcgc]\}}}|tk(r||k(r|}}}}|r|dSt|j|jDcgc]\}}|t k(s|}}}|sy|d}t |jj|} t| tr| jjds"tttj Sttj } |jj#d| | gj} tt%| | jdScc}}}wcc}}w)zGet named replacement expression from '{name}'.format(name=...) call. If the type is from **kwargs, return TempNode(). Return None in case of an error. rNztyping.Mappingr)rrr arg_namesrrr0rrrr&rkrr r%r*rrr ) rvrjrrrname named_args star_args_2 star_arg_2 kwargs_typeany_type mapping_infos rCrz'StringFormatterChecker.get_expr_by_namesI$'tyy$..$..#Q  T4y TS[   a= ,/ 4>>,J`ysDdV_N_s` ` ^ %dhh&:&::&FG +x0 8H8H8Q8Q 9 GI$:$:;< <9112xx223ChPXEYZ__ 1+|LQQRSTUU' asE.9E5 E5c^td|D}td|D}|r/|s-|jjd|tj y|ryd}|D]N}|j rt|}||_|js||_n||jz|_|dz }Py) zTranslate '{} {name} {}' to '{0} {name} {1}'. Return True if generation was successful, otherwise report an error and return false. c3lK|],}|jxr|jj.ywr{)rjrrs rCrz."s'J11556QUU__%66Js24c3FK|]}t|jywr{)rrjrs rCrz.#s9!$quu+9s!zGCannot combine automatic field numbering and manual field specificationrFTrr) anyrrrrrrjrrH)rv all_specsr some_defined all_defined next_indexr str_indexs rCrz)StringFormatterChecker.auto_generate_keyss J JJ 9y99  HHMMY,,      D88 O $zz!*DJ!*TZZ!7DJa  rEc|jsJd|j|jk(r|S|jsJt|jj}t |jt |jdz}t|dd|jj|d}|jr\|jjd|jd|tjtttj St#|t$sJ|j&d }t#|t(sJ|j*}|j-|||| s"tttj S|j.|_|j0|_|jj2j5||S) zTransform and validate expr in '{.attr[item]}'.format(expr) into expr.attr['item']. If validation fails, return TempNode(AnyType). rNzT)fnammoduleoptionserrorseagerz"Syntax error in format specifier "rrrr)rjrHr rrrSrr" is_errorsrrrrr r%r*rrrdefsrr validate_and_transform_accessorslinecolumn expr_checkeraccept)rvrrr temp_errorsdummytemp_asts rCrz,StringFormatterChecker.apply_field_accessors:sxx===x :: !KzzzTXX--.  4::c$((mo#>> HH$$    " HHMM4TZZLB,,   GI$8$89: :(H---==#(N333==44XtTs4SGI$8$89: : ** $$X.rEct|ttfsF|jj dj |j |tjyt|tr |j}n|j}t|jttfs}|jsJd|j sJ|jj dj |j t|jd|tjyt|jtr$t!|jj"|_ t|trK|j"t$k(r8t|ttfsJt|tr||_ y||_ y|j&|_|j(|_|j+||||S) aValidate and transform (in-place) format field accessors. On error, report it and return False. The transformations include replacing the dummy variable with actual replacement expression and translating any name expressions in an index into strings, so that this will work: class User(TypedDict): name: str id: int u: User '{[id]:d} -> {[name]}'.format(u) zQOnly index and member expressions are allowed in format field accessors; got "{}"rFz1Call this method only after auto-generating keys!z6Invalid index expression in format field accessor "{}"NT) original_replrr)rrrrrformatrHrrrbaseindexrrrjrrrrSrr r)rvr%r'rrnodes rCrz7StringFormatterChecker.validate_and_transform_accessorsgs&(Z$;< HHMM44:F4::4F,,    h +==D==Dhnnx.ABxxT!TTxzz!z LSS 3txx=?300 (..(3!()<)2 2 5rEctd|D}td|D}td|D}|r|r|jj|y|r|s|jj |y|S)Nc3<K|]}|jywr{)rr specifiers rCrzGStringFormatterChecker.analyze_conversion_specifiers..sH y))+Hc3<K|]}|jywr{)r~r4s rCrzGStringFormatterChecker.analyze_conversion_specifiers..sFii'')Fr6c3^K|]%}|jxs|jdk('yw)r8N)r~rLr4s rCrzGStringFormatterChecker.analyze_conversion_specifiers..s1 BKI    =9#6#6##= = s+-)rrr&string_interpolation_with_star_and_key,string_interpolation_mixing_key_and_non_keys)rvrcontextrr~ all_have_keyss rCr-z4StringFormatterChecker.analyze_conversion_specifierssvHZHHF:FF OY   x HH ; ;G D = HH A A' JrEc|j|||}|yt|j|}g}t|tr|j }t |}|ttdt|t|z dz}||} t| tsJt| j} t| trt| j} t| tr| jjdk(sJ| jdg|z} |d|| z||dzdz}nt|t ryt|tr6|jjdk(r|jdgt|z}nXt|t"rE|j%D]1} t'| } |j(| _|j+|| |3y|g}t|t|kDrRt-||j.j1drt|tsy|j2j5|yt|t|kr|j2j7|yt|dk(rO|d\} }t|tr.t|j dk(r||j dy| |yt|t8rHt;d|j Ds,t=||j D]\}}|\} }| |yt=||D]\}}|\} }||y)zOCheck % string interpolation with positional specifiers '%s, %d' % ('yes, 42').Nrrzbuiltins.tupleztyping.Iterablec3<K|]}t|tywr{)rr)ritems rCrzHStringFormatterChecker.check_simple_str_interpolation..sA/3 4*Ar6)build_replacement_checkersr0r"rr(rr/maxrr.rkr+ upper_boundr&fullnamerr%r-relevant_itemsr rr/r#rrr#too_few_string_formatting_argumentsrr!rr)rvrrrcheckersrhs_type rep_types unpack_indexextrasunpacked unpack_itemstyp temp_node check_node check_typechecksrep_noderep_types rCr/z5StringFormatterChecker.check_simple_str_interpolations22:|TR   "4;;|#<= " h * I.y9L'QH I > BC$\2!(J777*8==9h(89.x/C/CDHx2x}}7M7MQa7aa ( a 01F: %m|4|CiP\_`P`PbFcc ' *  ( + 0F0FJZ0Z!q)*S]:I ) ,..0 Q$SM !-!2!2 33J 4P Q ! I x=3y> )(DHH$7$78I$JKT^)U<<\J ]S^ + HH 9 9, G8}!)1!& Jh 2s8>>7Ja7Ox~~a01|,L)4SA7C7I7IA>),Hl6H6H(I)$FH-3*J x()),Hi(@)$FH-3*J x()rEc Vt|trtd|jDri}|jD]\}}t|tr.s%6 48AqJq7I. /6 s#%z>Dictionary keys in bytes formatting must be bytes, not stringsrr8Nexpression has typezplaceholder with key 'z ' has typerzexpected type for mapping is)rrrrrrrrrr r3rr"rLrjkey_not_in_mappingrr check_subtyper 'INCOMPATIBLE_TYPES_IN_STR_INTERPOLATIONcheck_s_special_casesbuild_dict_typeFORMAT_REQUIRES_MAPPING) rvrrrmappingrVrWkey_strr5rSr dict_types rCr.z6StringFormatterChecker.check_mapping_str_interpolations lH -#6   2( E &&#- }}000==/HH// |L"9==1 **666 $ 4 4Y5H5H,X\ ]  (&&! $LL),Y]]O:F00'&&#-..tXtD/ E2{{<0H,,T2I HH " " 88%.,, # rEcjttj}t|tr:|j j dg}|j j d||gSt|tr:|j j dg}|j j d||gSJd)z>Build expected mapping type for right operand in % formatting.rz _typeshed.SupportsKeysAndGetItemr Unreachable)r%r*rrrrrr)rvrr  bytes_typestr_types rCr]z&StringFormatterChecker.build_dict_typeNs9112 dI &445ErJJ88..2Z4J g &xx22>2FH88..2Xx4H  (- '5rEchg}|D]*}|j|||}|y|j|,|Sr{)replacement_checkersr)rvrr;rrFr5checkers rCr@z1StringFormatterChecker.build_replacement_checkers^sG$&# %I// 7DIG OOG $  % rEcg}|jdk(r |j|j||jdk(r |j|j||jdk(r3|j |j||}|y|j||S|j@|jdk7r1|j |j||}|y|j||S)aReturns a list of tuples of two functions that check whether a replacement is of the right type for the specifier. The first function takes a node and checks its type in the right type context. The second function just checks a type. rrNr8)rnrcheckers_for_starrorLcheckers_for_c_typecheckers_for_regular_type)rvr5r;rrFrs rCrgz+StringFormatterChecker.replacement_checkersis$& ??c ! OOD227; <   # % OOD227; <   # %(()<).check_types>~6H88))hU=T=T* rEc:j|}|yr{r")rrkrProrvs rC check_exprz.check_exprs;;tX.D t rErkr)rrrrrr)r)rvr;rrrPros`` @@rCrjz(StringFormatterChecker.checkers_for_stars*??>2   :%%rEc ~|jj|||tjddtj S)NrXzplaceholder has typer)rrZr r[rr)rvrMrr;s rCrz-StringFormatterChecker.check_placeholder_types?xx%%     D D ! "((&  rEcfjydfd dfd }|fS)zReturns a tuple of check functions that check whether, respectively, a node or a type is compatible with 'type'. Return None in case of an error. NcjJj|}|rdk(rj|}|S)Nr)rr\)rMretr;rLrrrvs rCrPzDStringFormatterChecker.checkers_for_regular_type..check_typesF , ,,--c='JCyC'00sGDJrEc:j|}|yr{rq)rrkrPrrvs rCrrzDStringFormatterChecker.checkers_for_regular_type..check_exprs;;t]3D t rE)rMr)rrrtr)rvrLr;rrrrPrs```` @@rCrlz0StringFormatterChecker.checkers_for_regular_types> ,,YF     :%%rEc(t|tr9t|dr-|jj d|t j yt|tr9t|dr-|jj d|t jyy)z;Additional special cases for %s in bytes vs string context.rzIf x = b'abc' then "%s" % x produces "b'abc'", not "abc". If this is desired behavior use "%r" % x. Otherwise, decode the bytesrFrz,On Python 3 b'%s' requires bytes, not stringT) rrrrrrrrr)rvrrMr;s rCr\z,StringFormatterChecker.check_s_special_casess dG $!#'78 \,,   dI &!#~6 B00 rEcfj|ydfd dfd }|fS)zReturns a tuple of check functions that check whether, respectively, a node or a type is compatible with 'type' that is a character type. NcJttrd}nd}jj||dtj S)Nz7"%c" requires an integer in range(256) or a single bytez"%c" requires int or charrXr)rrrrZrr)rkerr_msgr;r format_exprrvs rCrPz>StringFormatterChecker.checkers_for_c_type..check_typesW , ,,+y1S588))%,, * rEczj|}|rttrDt|tr4t|jdk7rj j yt|ttfr5t|jdk7rj jyyyy)zint, or str with length 1rN) r"rrrrrrequires_int_or_single_byterr)rrkrPr;rrrvs rCrrz>StringFormatterChecker.checkers_for_c_type..check_exprs;;t]3D${I6"43DJJ1,HH88Aw &:;DJJST@THH11':AU; rErsrtrz)rvrkr;rrrrPrs` `` @@rCrkz*StringFormatterChecker.checkers_for_c_typesC ,,T7KH     ; ; :%%rEc|rtnt}|rtnt}|dk(rP|sNt |t s-|j jd|tjy|jdS|dk(rttjS|dvrttjS||vr||vr|jdg}nm|jd|jd g}|sI|tvr!|j|jd n |j|jd t!j"|S|d vrft |t r+t!|jd|jdgSt!|jd|jd gS|j j%||y)aReturn the type that is accepted for a string interpolation conversion specifier type. Note that both Python's float (e.g. %f) and integer (e.g. %d) specifier types accept both float and integers. The 'format_call' argument indicates whether this type came from % interpolation or from a str.format() call, the meaning of few formatting types are different. raz8Format character "b" is only supported on bytes patternsrNra)rrrrztyping.SupportsFloatztyping.SupportsInt)rr)rcr`rerdrrrrrrrr%r*rrfrr- make_unionunsupported_placeholder)rvpr;rr NUMERIC_TYPES INT_TYPESrs rCrz&StringFormatterChecker.conversion_types.9)>O '2O 8KdI. N00 ??#34 4 #X9112 2 *_9112 2 - I~!%!@ A OON3OO$45! #K'%,,T__=S-TU%,,T__=Q-RS'' 6 6 %Z$ * __^4dooFV6WX!__^4doon6UV HH , ,Q 8rEc8|jj|S)z}Return an instance type with type given by the name and no type arguments. Alias for TypeChecker.named_type. )rr)rvrs rCrz!StringFormatterChecker.named_type3sxx""4((rENcN|jjj||S)z0Type check a node. Alias for TypeChecker.accept.)rr!r")rvrr;s rCr"zStringFormatterChecker.accept9sxx$$++D'::rE)rr rrrr)rrrrrr)rrrlist[ConversionSpecifier]rrrr) rrhrrrrrr)rr)rr)rrrz list[str]rzlist[Expression])rrrrrExpression | None)rjrrrrr)rrrrrr)rrhrrrrrr) r%rr'rrrhrrrr)rr3rrrr))rrr;rrz bool | None)rrrrrr3rr)rr3rr))rrr;rrr3rlist[Checkers] | None)r5rhr;rrr3rr)r;rrr4)rMr)rr)r;rrr)rLrr;rrr3rCheckers | None)rr3rMr)r;rrr)rkrr;rrr3rrF) rrr;rrr3rrr Type | None)rrrr&r{)rrr;rrr))rrr__doc____annotations__ryrrrrrrrrrr1r-r/r.r]r@rgrjrrlr\rkrrr"rrErCrr!sj   H8G\G\%>G\NQG\ G\R,!,, ,  ,  , ,\"HT4V6:+'+/9+@G+ +Z8 8 "8 " 8  8  8 x*3>E "G)-G)!G) G)  G)R:-:!: :  :x( 3 >E M]   ,7>FV 4&$  &&'.&6F& &..)&)&"))&8H)& )&XUZ44&4.>4MQ4 4t) ;rErcbt|}t|tr|jj St|t r6t |jxstfd|jDSt|tr"tfd|jDSy)aMIs this a specific instance type, or a union that contains it? We use this ad-hoc function instead of a proper visitor or subtype check because some str vs bytes errors are strictly speaking not runtime errors, but rather highly counter-intuitive behavior. This is similar to what is used for --strict-equality. c36K|]}t|ywr{r)rrWrCs rCrz%has_type_component..Js D 01 q( +D c36K|]}t|ywr{r)rtrCs rCrz%has_type_component..NsQq%a2QrF) r0rr&rkrr,rrBrvaluesr-rD)rMrCs `rCrr>s # C#x xx  ** C %!#//8< D 58ZZD A   C #QCrs # $77!42(*$. '2*2XzlD&898TFDL;QQR*RE#s(OU3Z78*8 ! 8@%& 5&,U3 u33D9e9*%*X5W\5\)(224 U3::@JO55#5*85BF5%5p66#6*86!6rZ ;Z ;zrE