ML iƳUdZddlmZddlZddlmZmZddlmZmZm Z m Z ddl m Z ddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZmZmZm 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/dd l0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCe e-e fZDdeEd<eFee$gdfee;geGffZHdeEd<eIeFeJeJfeeKfZLdeEd<d1dZMd2dZNeMZOdeEd<eNdZPdeEd<eNdZQdeEd<dZRdeEd<hdZSdeEd <hd!ZTdeEd"<hd#ZUdeEd$<hd%ZVdeEd&<hd'ZWdeEd(<Gd)d*ZXd3d+ZY d4 d5d,ZZ d6d-Z[Gd.d/Z\d7d0Z]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)MatchPattern)CallableFinalUnioncast) TypeAlias)message_registry)TypeCheckerSharedApi)Errors)map_instance_to_supertype)MessageBuilder) ARG_NAMEDARG_POSARG_STAR ARG_STAR2 BytesExprCallExprContextDictExpr ExpressionExpressionStmt IndexExprIntExpr MemberExprMypyFileNameExprNodeStarExprStrExprTempNode 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 Y/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/mypy/checkstrformat.pycompile_format_rerFHsT &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+)?r9z(?P:z)?z(?P:.*)?r;) custom_specfield conversion fill_alignnum_spec conv_type format_specs rEcompile_new_format_rerPXsa 5E+J 1 V# *Z7(BYNQVV / ::ej(;6 77rGr FORMAT_REF FORMAT_RE_NEWTFORMAT_RE_NEW_CUSTOM__dummy_name__DUMMY_FIELD_NAME> EFGXdefgiouxNUMERIC_TYPES_OLD> rVrWrXrYbrZr[r\r]nr_rar:NUMERIC_TYPES_NEW>rYr_raREQUIRE_INT_OLD>rYrcrZr_raREQUIRE_INT_NEW>rVrWrXr[r\r] FLOAT_TYPESc6eZdZ d ddZddZddZy)ConversionSpecifierc|j|_||_|j}|j d|_|j dd|_|j dd|_|j dd|_|j dd|_ |j d|_ ||_ |j d|_ |j d |_ y) Nkeytypeflagswidth precisionrOrKrJ)group whole_seq start_pos groupdictgetrlrNrorprqrOnon_standard_format_specrKrJ)selfmatchrtrwm_dicts rE__init__zConversionSpecifier.__init__s""::e$ FB/ZZ, ZZ, K4"::m4(@% **\2ZZ( rGc|jduSNrlrxs rEhas_keyzConversionSpecifier.has_keysxxt##rGcB|jdk(xs|jdk(S)N*)rprqrs rEhas_starzConversionSpecifier.has_starszzS 9DNNc$99rGN)F)ryz Match[str]rtintrwboolreturnNone)rr)__name__ __module__ __qualname__r{rrrGrErjrjs4W\)),/)PT) )0$:rGrjcg}tjt|D],}|jt ||j .|S)zFParse c-printf-style format string into list of conversion specifiers.rt)r<finditerrQappendrjstart) format_str specifiersms rEparse_conversion_specifiersrsE,.J [[J /G-a1779EFG rGct|||}|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)rtrwz-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_targetsrR fullmatchrjrSfailcodesSTRING_FORMATTINGrlrrOrwparse_format_valueextend) format_valuectxmsgr top_targetsresulttargetrtry conv_spec custom_matchsub_conv_specss rErrsp+<cBK(*F('* ''/ +EYGI/99&AL/ IPT C00  ==cY]]2cY]]6J HH?5KbKbH c i   ! !22 --- 8M8M1MH00 / 0E0EsCX\]N% MM. )O'*P MrGcg}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. rnrrrz;Invalid conversion specifier in format string: unexpected }rNz:Invalid conversion specifier in format string: unmatched {)lenrrrr)rrrr next_specposnestingcs rErrsTFI CG L! !  Cx\*Q..<a3HC3O1HCGCx\*Q..<a3HC3O1HCHHU"44  Cx1 Cx1 Q  y#I*>?@  q= L! !>  H ((   MrGceZdZUdZded<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)rxrrs rEr{zStringFormatterChecker.__init__-srGct|||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)rxcallr conv_specss rEcheck_str_format_callz,StringFormatterChecker.check_str_format_call2sD*( dDHHE   &&z48  ''j,GrGc 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 rE zDStringFormatterChecker.check_specs_in_format_call..Us(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 strrlrzipapply_field_accessors isinstancer"rmr lookup_typerOrwr&rKrrrrrNr'r, special_formcalleerexprr!conversion_type named_typer2r/r3itemscheck_placeholder_typeperform_special_format_checks) rxrspecsrr replacementsspecrepl actual_type expected_typera_type actual_itemss rErz1StringFormatterChecker.check_specs_in_format_callNs(%((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)rNrr!rrvaluerrequires_int_or_charr2rrr(last_known_valuer)rrKhas_type_componentr&rr STR_BYTES_PY3ror/rrer%r)rxrrrrrc_typ numeric_typess rErz4StringFormatterChecker.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?& rGc"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) rxrkeysrusedrlrkindtotal_explicits rErz0StringFormatterChecker.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)rargsrrrrr2rrrr(rmhas_baser"r'r,rnamed_generic_typer) rxrrargrpos_args star_argsstar_arg varargs_type iter_infos rErz+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_namesrrr2rrrr(rmrr"r'r,rrr) rxrlrrrname named_args star_args_2 star_arg_2 kwargs_typeany_type mapping_infos rErz'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})rlrrs rErz.#s'J11556QUU__%66Js24c3FK|]}t|jywr})rrlrs rErz.$s9!$quu+9s!zGCannot combine automatic field numbering and manual field specificationrFTrr) anyrrrrrrlrrJ)rx all_specsr some_defined all_defined next_indexr str_indexs rErz)StringFormatterChecker.auto_generate_keyss J JJ 9y99  HHMMY,,      D88 O $zz!*DJ!*TZZ!7DJa  rGc|jsJd|j|jk(r|S|jsJt|jj}t |jt |jdz}t|dd|jj|}|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). rNz)fnammoduleoptionserrorsz"Syntax error in format specifier "rrrr)rlrJr rrrUrr$ is_errorsrrrrr"r'r,rrrdefsrr validate_and_transform_accessorslinecolumn expr_checkeraccept)rxrrr temp_errorsdummytemp_asts rErz,StringFormatterChecker.apply_field_accessors;szxx===x :: !KzzzTXX--.  4::c$((mo#>>  49I9IR]   " HHMM4TZZLB,,   GI$8$89: :(H---==#(N333==44XtTs4SGI$8$89: : ** $$X.rGct|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)rrrrrformatrJrrrbaseindexrrrlrr!rrUr r!r)rxr&r(rrnodes rErz7StringFormatterChecker.validate_and_transform_accessorscs&(Z$;< HHMM44:F4::4F,,    h +==D==Dhnnx.ABxxT!TTxzz!z LSS 3txx=?300 (..(3!()<)2 2 5rGctd|D}td|D}td|D}|r|r|jj|y|r|s|jj |y|S)Nc3<K|]}|jywr})rr specifiers rErzGStringFormatterChecker.analyze_conversion_specifiers..sH y))+Hc3<K|]}|jywr})rr5s rErzGStringFormatterChecker.analyze_conversion_specifiers..sFii'')Fr7c3^K|]%}|jxs|jdk('yw)r:N)rrNr5s rErzGStringFormatterChecker.analyze_conversion_specifiers..s1 BKI    =9#6#6##= = s+-)rrr&string_interpolation_with_star_and_key,string_interpolation_mixing_key_and_non_keys)rxrcontextrr all_have_keyss rEr.z4StringFormatterChecker.analyze_conversion_specifierssvHZHHF:FF OY   x HH ; ;G D = HH A A' JrGc|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 rErzHStringFormatterChecker.check_simple_str_interpolation..sA/3 4*Ar7)build_replacement_checkersr2r#rr*rr1maxrr0rmr- upper_boundr(fullnamerr'r/relevant_itemsr"r r0r%rrr#too_few_string_formatting_argumentsrr#rr)rxrrrcheckersrhs_type rep_types unpack_indexextrasunpacked unpack_itemstyp temp_node check_node check_typechecksrep_noderep_types rEr0z5StringFormatterChecker.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()rGc Vt|trtd|jDri}|jD]\}}t|tr.s%6 48AqJq7I. /6 s#%z>Dictionary keys in bytes formatting must be bytes, not stringsrr:Nexpression has typezplaceholder with key 'z ' has typerzexpected type for mapping is)rrrrrrrrrr r5rr#rNrlkey_not_in_mappingrr check_subtyper 'INCOMPATIBLE_TYPES_IN_STR_INTERPOLATIONcheck_s_special_casesbuild_dict_typeFORMAT_REQUIRES_MAPPING) rxrrrmappingrWrXkey_strr6rTr dict_types rEr/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%.,, # rGcjttj}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!)rxrr  bytes_typestr_types rEr^z&StringFormatterChecker.build_dict_typeJs9112 dI &445ErJJ88..2Z4J g &xx22>2FH88..2Xx4H  (- '5rGchg}|D]*}|j|||}|y|j|,|Sr})replacement_checkersr)rxrr<rrGr6checkers rErAz1StringFormatterChecker.build_replacement_checkersZsG$&# %I// 7DIG OOG $  % rGcg}|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. rrNr:)rprcheckers_for_starrqrNcheckers_for_c_typecheckers_for_regular_type)rxr6r<rrGrs rErhz+StringFormatterChecker.replacement_checkerses$& ??c ! OOD227; <   # % OOD227; <   # %(()<).check_types>~6H88))hU=T=T* rGc:j|}|yr}r#)rrmrQrprxs rE check_exprz.check_exprs;;tX.D t rGrmr+rrrrrr)r)rxr<rsrQrps`` @@rErkz(StringFormatterChecker.checkers_for_stars*??>2   :%%rGc ~|jj|||tjddtj S)NrYzplaceholder has typer)rr[r r\rr)rxrNrr<s rErz-StringFormatterChecker.check_placeholder_types?xx%%     D D ! "((&  rGcfjydfd 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])rNretr<rNrrrxs rErQzDStringFormatterChecker.checkers_for_regular_type..check_typesF , ,,--c='JCyC'00sGDJrGc:j|}|yr}rr)rrmrQrrxs rErszDStringFormatterChecker.checkers_for_regular_type..check_exprs;;t]3D t rG)rNr+rrrur)rxrNr<rrsrQrs```` @@rErmz0StringFormatterChecker.checkers_for_regular_types> ,,YF     :%%rGc(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) rr!rrrrrrr)rxrrNr<s rEr]z,StringFormatterChecker.check_s_special_casess dG $!#'78 \,,   dI &!#~6 B00 rGcfj|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 charrYr)rrrr[rr)rmerr_msgr<r format_exprrxs rErQz>StringFormatterChecker.checkers_for_c_type..check_typesW , ,,+y1S588))%,, * rGczj|}|rttrDt|tr4t|jdk7rj j yt|ttfr5t|jdk7rj jyyyy)zint, or str with length 1rN) r#rrrrrrequires_int_or_single_byter!r)rrmrQr<rrrxs rErsz>StringFormatterChecker.checkers_for_c_type..check_exprs;;t]3D${I6"43DJJ1,HH88Aw &:;DJJST@THH11':AU; rGrtrur{)rxrmr<rrsrQrs` `` @@rErlz*StringFormatterChecker.checkers_for_c_typesC ,,T7KH     ; ; :%%rGc|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. rcz8Format character "b" is only supported on bytes patternsrNra)rrrrztyping.SupportsFloatztyping.SupportsInt)rr)rerbrgrfrrrrrrrr'r,rrhrr/ make_unionunsupported_placeholder)rxpr<rr NUMERIC_TYPES INT_TYPESrs rErz&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 8rGc8|jj|S)z}Return an instance type with type given by the name and no type arguments. Alias for TypeChecker.named_type. )rr)rxrs rErz!StringFormatterChecker.named_type/sxx""4((rGNcN|jjj||S)z0Type check a node. Alias for TypeChecker.accept.)rr"r#)rxrr<s rEr#zStringFormatterChecker.accept5sxx$$++D'::rG)rr rrrr)rrrrrr)rrrlist[ConversionSpecifier]rrrr) rrjrrrrrr+rr+rr)rrrz list[str]rzlist[Expression])rrrrrExpression | None)rlrrrrr)rrrrrr)rrjrrrrrr) r&rr(rrrjrrrr)rr5rrrr+)rrr<rrz bool | None)rrrrrr5rr)rr5rr+)rrr<rrr5rlist[Checkers] | None)r6rjr<rrr5rr)r<rrr6)rNr+rr+r<rrr)rNrr<rrr5rCheckers | None)rr5rNr+r<rrr)rmrr<rrr5rrF) rrr<rrr5rrr Type | None)rrrr(r})rrr<rrr+)rrr__doc____annotations__r{rrrrrrrrrr2r.r0r/r^rArhrkrrmr]rlrrr#rrGrErr"sj   H8G\G\%>G\NQG\ G\R,!,, ,  ,  , ,\"HT4V6:&'&/9&@G& &P8 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) ;rGrcbt|}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)rrXrDs rErz%has_type_component..Fs D 01 q( +D c36K|]}t|ywr}r)rtrDs rErz%has_type_component..JsQq%a2QrF) r2rr(rmrr.rrCrvaluesr/rE)rNrDs `rErr:s # C#x xx  ** C %!#//8< D 58ZZD A   C #QCrs # //5!42(,$. %Wi%78*8XzlD&898TFDL;QQR*RE#s(OU3Z78*8 ! 8@%& 5&,U3 u33D9e9*%*X5W\5\)(224 U3::@JO55#5*85BF5%5p66#6*86!6rU ;U ;prG