X-PhƳ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<dCdZMdDdZNeMZOdeEd<eNdZPdeEd<eNdZQdeEd <d!ZRdeEd"<hd#ZSdeEd$<hd%ZTdeEd&<hd'ZUdeEd(<hd)ZVdeEd*<hd+ZWdeEd,<Gd-d.ZXdEd2ZY dFdGd:ZZdHd<Z[Gd=d>Z\dIdBZ]dS)Ja 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 _TypeAliasFormatStringExprCheckersMatchMapreturn Pattern[str]cjd}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 S/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/checkstrformat.pycompile_format_rerHHsU &F&H,H6LMGf x'(2\AMQT[[I :i  custom_specboolcpd}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+)?r;z(?P:z)?z(?P:.*)?r=)rJfield conversion fill_alignnum_spec conv_type format_specs rGcompile_new_format_rerSXsi 5E+J  /1 V# *Z7(BYNQVV / :ej(;6 7 77rIr FORMAT_REF FORMAT_RE_NEWTFORMAT_RE_NEW_CUSTOM__dummy_name__DUMMY_FIELD_NAME> EFGXdefgiouxNUMERIC_TYPES_OLD> rYrZr[r\br]r^r_r`nrbrdr<NUMERIC_TYPES_NEW>r\rbrdREQUIRE_INT_OLD>r\rfr]rbrdREQUIRE_INT_NEW>rYrZr[r^r_r` FLOAT_TYPESc*eZdZ ddd Zdd Zdd ZdS)ConversionSpecifierFmatch Match[str] start_posintnon_standard_format_specrKr8Nonec$||_||_|}|d|_|dd|_|dd|_|dd|_|dd|_ |d|_ ||_ |d|_ |d |_ dS) Nkeytypeflagswidth precisionrRrNrM)group whole_seqrq groupdictgetrvrQryrzr{rRrsrNrM)selfrorqrsm_dicts rG__init__zConversionSpecifier.__init__s"""::e$$ FB//ZZ,, ZZ,, K44"::m44(@% **\22ZZ(( rIc|jduSNrvrs rGhas_keyzConversionSpecifier.has_keysxt##rIc.|jdkp |jdkS)N*)rzr{rs rGhas_starzConversionSpecifier.has_starszS 9DNc$99rIN)rnF)rorprqrrrsrKr8rt)r8rK)__name__ __module__ __qualname__rrrrIrGrmrmsXW\)))))0$$$$::::::rIrm format_strstrlist[ConversionSpecifier]cg}tjt|D]8}|t ||9|S)zFParse c-printf-style format string into list of conversion specifiers.rq)r>finditerrTappendrmstart)r specifiersms rGparse_conversion_specifiersrsW,.J [J / /GG-a17799EEEFFFF rI format_valuectxrmsgrnested list[ConversionSpecifier] | Nonect|||}|dSg}|D]T\}}t|}|rt||} nTt|} | rt| |d} n%|d|t jdS| jr7d| jvs d| jvr%|d |t jdS| | | j rr| j rkd| j vs d| j vrY|r%|d |t jdSt| j ||d } | dS| | V|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)rqrsz-Invalid conversion specifier in format stringcode{}z(Conversion value must not contain { or }z2Formatting nesting must be at most two levels deep)r)find_non_escaped_targetsrU fullmatchrmrVfailcodesSTRING_FORMATTINGrvrrRrsparse_format_valueextend) rrrr top_targetsresulttargetrqro conv_spec custom_matchsub_conv_specss rGrrs+<cBBKt(*F('*'* ''//  +EYGGGII/99&AAL / IPT C0 tt = cY]22cY]6J6J HH?5KbH c c c44 i     ! *2 * --- 8M1M1M H0 tt/ 0EsCX\]]]N%tt MM. ) ) ) MrIlist[tuple[str, int]] | Noneclg}d}d}d}|t|kr||}|s|dkr-|t|dz kr||dzdkr|dz }nd}|dkrO|t|dz kr||dzdkr|dz }nl|d|tjdSnG|dkr|dz }|dkr|dz}|r||z }n)|||t|z fd}|dz }|t|k|r$|d |tjdS|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. rxrrrz;Invalid conversion specifier in format string: unexpected }rNz:Invalid conversion specifier in format string: unmatched {)lenrrrr)rrrr next_specposnestingcs rGrrsFI CG L!! ! !   Cxx\**Q...<a3HC3O3O1HCCGCxx\**Q...<a3HC3O3O1HCCHHU"4  4Cxx1 Cxx1  Q  y#I*>?@@@  q= L!! ! !>  H (    t MrIceZdZUdZded<ded<dPdZdQd ZdRdZdSdZdTdZ dUd Z dVd"Z dWd'Z dXd(Z dYd+ZdZd/Zd[d3Zd\d4Zd\d5Zd]d6Zd^d8Zd_d:Zd`d<Zdad>ZdbdAZdcdBZdddEZ dedfdJZdgdMZdhdidOZdNS)jStringFormatterCheckerzxString interpolation/formatter type checker. This class works closely together with checker.ExpressionChecker. r chkrrr8rtc"||_||_dS)z%Construct an expression type checker.N)rr)rrrs rGrzStringFormatterChecker.__init__-srIcallrrrct|||j}|dS|||sdS||||dS)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)rrr conv_specss rGcheck_str_format_callz,StringFormatterChecker.check_str_format_call2s]*( dDHEE   F&&z488  F ''j,GGGGGrIspecsrc td|Ds Jd||d|D}t|t|ksJt||D]F\}}||||}t |t r|jn|j |}|J|j rk|j rdd|j vs[d|j vsRt|dd r|j r9|jd |j d dd |t j|jst't(j}nut |jt.sJt |jjt2r |jj} nt3|} ||j|| d }|j Z|j d dvr6|jd|j d d|t j|d}|t9|} t | t:rt=| jn| g} | D]C} t| dr| | |||!|||| |DHdS)zPerform pairwise checks for conversion specifiers vs their replacements. The core logic for format checking is implemented in this method. c3$K|] }|jV dSrr.0ss rG zDStringFormatterChecker.check_specs_in_format_call..Us$((Q15((((((rI"Keys must be auto-generated first!cBg|]}tt|jSr)r rrvrs rG zEStringFormatterChecker.check_specs_in_format_call..Vs%<]<]<]RST#qu=M=M<]<]<]rIrNrr __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_callrzipapply_field_accessors isinstancer"rwr lookup_typerRrsr&rNrrrrrQr'r, special_formcalleerexprr!conversion_type named_typer2r/r3itemscheck_placeholder_typeperform_special_format_checks) rrrr replacementsspecrepl actual_type expected_typera_type actual_itemss rGrz1StringFormatterChecker.check_specs_in_format_callNs6((%(((((NN*NNNN55d<]<]W\<]<]<]^^ <  CJJ....e\22= \= \JD$--dDd-CCD'1$'A'Aa$))txG[G[\`GaGaK***  1  D,,,t7G0G0G.kNqrr>RUUU"4" > -4Y5K-L-L !$+z:::::dk.887!%!1JJ!(!6!6J $ 4 4ND*$!5!! *?1%U22HMM>8J>>>"4 "#oon== $$[11F2>++FM4HHH224tV][[[[  \s= \= \rIrrmrrrr+rc(|jdkrt|ttfr4t |jdkr|j|dt|j |}t|tr|j r|j }t|trNt|jtr4t |jdkr|j|d|jr |jdkrN|jsGt!|dr7t#|ds'|jd|t&j |jrt-|d |d g}|jr|jt0vs'|jsKt3||s=t#|d s/|jd |t&j dSdSdSdSdS)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)rQrr!rrvaluerrequires_int_or_charr2rrr(last_known_valuer)rrNhas_type_componentr&rr STR_BYTES_PY3ryr/rrhr%r)rrrrrrc_typ numeric_typess rGrz4StringFormatterChecker.perform_special_format_checkss? >S $) 455 F#dj//Q:N:N--d-EEE#DH$8$8$>$>??E%** /u/E /.%-- J*U[#2N2N Ju{##q((H11$D1III $.C"7"7"7!+/?@@ I^YJJ  2,  : %00$//BR2S2STM N*;;;~<"; >><.k<HH<  F0   <;;;;;rIkeys list[str]list[Expression]c.g}t}|D]5}|rv|t||}|sP|jd||t jtttj }ni| ||}|sQ|jd|d|t jtttj }| |t|ts||7t!d|jD}t!||kr|j||S)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 "rc2g|]}|ttfv|Sr)rr)rkinds rGrzDStringFormatterChecker.find_replacements_in_call..s(^^^t'S\I]A]A]dA]A]A]rI)set isdecimalget_expr_by_positionrrrrrrr"r'r, from_errorget_expr_by_namerraddr arg_kinds$too_many_string_formatting_arguments)rrrrusedrvrtotal_explicits rGrz0StringFormatterChecker.find_replacements_in_calls $& #  C}} C00S4@@CHMMXSVXX"4" $GI,@$A$ABBD,,S$77CHMMUsUUU"4" $GI,@$A$ABBD MM$   dH-- ^^t~^^^__ t99~ % % H 9 9$ ? ? ? rIrrrExpression | Nonecdt|j|jD}|t|kr||Sdt|j|jD}|sdS|d}t |j|}t|tr|j ds&tttjS|jdttjgj }tt!||jdS)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. c.g|]\}}|tk|Sr)rrargrs rGrz?StringFormatterChecker.get_expr_by_position..s"[[[IC4SZ??C???rIc.g|]\}}|tk|Sr)rr s rGrz?StringFormatterChecker.get_expr_by_position..s']]]YS$DT\L\L\SL\L\L\rINrztyping.Sequence)rargsrrr2rrrr(rwhas_baser"r'r,rnamed_generic_typer)rrrpos_args star_argsstar_arg varargs_type iter_infos rGrz+StringFormatterChecker.get_expr_by_positions5 \[TY)G)G[[[ X  C= ]]#di*H*H]]]  4Q<&tx';';H'E'EFF ,11 =9J9S9S : :  =GI$:;;<< <H//  (> ? ?@   1, JJOPQRSSSrIrvcfdt|j|j|jD}|r|dSdt|j|jD}|sdS|d}t |j|}t|tr|j ds&tttjSttj}|jd||gj }tt!||jdS)zGet named replacement expression from '{name}'.format(name=...) call. If the type is from **kwargs, return TempNode(). Return None in case of an error. c>g|]\}}}|tk|k|Sr)r)rr rnamervs rGrz;StringFormatterChecker.get_expr_by_name.. s:   T4y  TS[[ %0[[rIrc.g|]\}}|tk|Sr)rr s rGrz;StringFormatterChecker.get_expr_by_name..s'```ysDdV_N_N_sN_N_N_rINztyping.Mappingr)rr r arg_namesr2rrrr(rwr r"r'r,rrr) rrvr named_args star_args_2 star_arg_2 kwargs_typeany_type mapping_infos ` rGrz'StringFormatterChecker.get_expr_by_namesB     #&ty$.$.#Q#Q    !a= ``C 4>,J,J```  4 ^ %dh&:&::&F&FGG +x00 = 8H8Q8Q 9 9  =GI$:;;<< <9122x223ChPXEYZZ_ 1+|LLQRSTUUUrI all_specsrrrKcZtd|D}td|D}|r+|s)|jd|tjdS|rdSd}|D]B}|js9t|}||_|js||_n||jz|_|dz }CdS) zTranslate '{} {name} {}' to '{0} {name} {1}'. Return True if generation was successful, otherwise report an error and return false. c3VK|]$}|jo|jV%dSr)rvrrs rGrz.#s5JJ1156QU__%6%6JJJJJJrIc3>K|]}t|jVdSr)rKrvrs rGrz.$s*99!$qu++999999rIzGCannot combine automatic field numbering and manual field specificationrFTrr) anyrrrrrrvrrM)rrr some_defined all_defined next_indexr str_indexs rGrz)StringFormatterChecker.auto_generate_keyss JJ JJJJJ 99y99999     HMMY,     5  4  D8  OO $z8!*DJJ!*TZ!7DJa trIcb|js Jd|j|jkr|S|jsJt|jj}t |jt |jdz}t|dd|jj|}|rV|j d|jd|tj tttjSt#|t$sJ|jd}t#|t(sJ|j}||||| s&tttjS|j|_|j|_|jj||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)rvrMr rr+rXrr$ is_errorsrrrrr"r'r,rrrdefsrr validate_and_transform_accessorslinecolumn expr_checkeraccept)rrrr temp_errorsdummytemp_asts rGrz,StringFormatterChecker.apply_field_accessors;sx====== : ! !KzTX-..  4:c$(mmoo#>>  49IR]     " " ; HMMBTZBBB,     GI$899:: :(H-----=#(N33333=44XtTs4SS ;GI$899:: : * $$X...rIr6 original_replct|ttfsA|jd|j|tjdSt|tr|j }n|j }t|j ttfsu|js Jd|jsJ|jd|jt|jd|tjdSt|j trt!|j j|_ t|trT|jt$krDt|ttfsJt|tr||_ n||_ dS|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)r7rr)rrrrrformatrMrrrbaseindexrrrvrr!rrXr0r1r/)rr6r7rrnodes rGr/z7StringFormatterChecker.validate_and_transform_accessorscs&(Z$;<<  HMM44:F4:4F4F,     5 h + + >=DD=Dhnx.ABB xTT!TTTTz!!! LSS 3tx==??30 u(.(33 >!()22 2 LrIrcontext bool | Nonectd|D}td|D}td|D}|r|r|j|dS|r|s|j|dS|S)Nc3>K|]}|VdSr)rr specifiers rGrzGStringFormatterChecker.analyze_conversion_specifiers..s.HH y))++HHHHHHrIc3>K|]}|VdSr)rrGs rGrzGStringFormatterChecker.analyze_conversion_specifiers..s.FFii''))FFFFFFrIc3TK|]#}|p |jdkV$dS)r<N)rrQrGs rGrzGStringFormatterChecker.analyze_conversion_specifiers..sL  BKI     =9#6##=      rI)r#rr&string_interpolation_with_star_and_key,string_interpolation_mixing_key_and_non_keys)rrrCrr all_have_keyss rGr>z4StringFormatterChecker.analyze_conversion_specifierssHHZHHHHHFF:FFFFF  OY       x  H ; ;G D D D4  =  H A A' J J J4rIct||||}|dSt||}g}t|tr|j}t |}|tdt|t|z dz}||} t| tsJt| j } t| trt| j } t| tr| j jdksJ| jdg|z} |d|| z||dzdz}nt|t rdSt|tr/|j jdkr|jdgt|z}nct|t"rK|D]4} t'| } |j| _||| |5dS|g}t|t|kr[t-||jdrt|tsdS|j|dSt|t|kr|j|dSt|dkr]|d\} }t|tr0t|jdkr||jddS| |dSt|t8rKt;d|jDs-t=||jD]\}}|\} }| |dSt=||D]\}}|\} }||dS)zOCheck % string interpolation with positional specifiers '%s, %d' % ('yes, 42').Nrrzbuiltins.tupleztyping.Iterablec3@K|]}t|tVdSr)rr )ritems rGrzHStringFormatterChecker.check_simple_str_interpolation..sEAA/3 4**AAAAAArI)build_replacement_checkersr2r3rr*rr1maxrr0rwr- upper_boundr(fullnamer r'r/relevant_itemsr"r0r@r%rrr#too_few_string_formatting_argumentsrr#r#r)rrrrcheckersrhs_type rep_types unpack_indexextrasunpacked unpack_itemstyp temp_node check_node check_typechecksrep_noderep_types rGr@z5StringFormatterChecker.check_simple_str_interpolations 22:|TRR   F"4;;|#<#<== " h * * # I.y99L'QH I > BCC$\2!(J77777*8=99h(899E.x/CDDHx227?}7MQa7a7a7a7a ( a 01F: %m|m4|CiP\_`P`PbPbFcc ' * * # F ( + + # 0FJZ0Z0Z!q)*S]]:II ) , , #..00 Q Q$SMM !-!2 33J 4PPPP F! I x==3y>> ) )(DH$7$78I$J$JKK KT^)UU K<<\JJJJJ ]]S^^ + + H 9 9, G G G G G8}}!!)1!& Jh 22-s8>7J7Ja7O7OJx~a011111J|,,,,,L)44 )SAA7C7IAAA>> )),Hl6H(I(I))$FH-3*J Jx(((())),Hi(@(@))$FH-3*J Jx(((())rIc t|trtd|jDrqi}|jD]\}}t|tr.sF6 6 48AqJq7I. / /6 6 6 6 6 6 rIz>Dictionary keys in bytes formatting must be bytes, not stringsrr<Nexpression has typezplaceholder with key 'z ' has typerzexpected type for mapping is)rrrrrrrrrr r5rr3rQrvkey_not_in_mappingrr check_subtyper 'INCOMPATIBLE_TYPES_IN_STR_INTERPOLATIONcheck_s_special_casesbuild_dict_typeFORMAT_REQUIRES_MAPPING) rrrrmappingrgrhkey_strrHrdr dict_types rGr?z6StringFormatterChecker.check_mapping_str_interpolationsc lH - -3 #6 6 >  ' E E &#-- }000=//H// |LLLFF"9=1 *666 $ 4 4Y5H,X\ ] ]  (FF&&! $L)FY]FFF0'&#--..tXtDDD/ E E2{{<00H,,T22I H " " 8%., #     rIc|ttj}t|tr8|jdg}|jd||gSt|tr8|jdg}|jd||gSJd)z>Build expected mapping type for right operand in % formatting.rz _typeshed.SupportsKeysAndGetItemrF Unreachable)r'r,rrrrrr!)rrr bytes_typestr_types rGrnz&StringFormatterChecker.build_dict_typeJs9122 dI & & (445ErJJJ8..2Z4J g & & (x22>2FFH8..2Xx4H  (- ' ' 'rIlist[Checkers] | Nonecvg}|D]3}||||}|dS||4|Sr)replacement_checkersr)rrrCrrWrHcheckers rGrQz1StringFormatterChecker.build_replacement_checkersZsU$&# % %I// 7DIIGtt OOG $ $ $ $rIrHcg}|jdkr(||||jdkr(||||jdkr6||j||}|dS||nG|j@|jdkr5||j||}|dS|||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<)rzrcheckers_for_starr{rQcheckers_for_c_typecheckers_for_regular_type)rrHrCrrWrs rGryz+StringFormatterChecker.replacement_checkerses$& ?c ! ! OOD227;; < < <  # % % OOD227;; < < <  # % %(().check_typesA~66H8))hU=T* rIrrrtcJ|}|dSrr3)rrwrarrs rG check_exprz.check_exprs,;;tX..D Jt     rIrwr+r8rKrrr8rt)r)rrCrrars`` @@rGr|z(StringFormatterChecker.checkers_for_starsq??>22                :%%rIr^c l|j|||tjddtjS)Nrizplaceholder has typer)rrkr rlrr)rr^rrCs rGrz-StringFormatterChecker.check_placeholder_types<x%%     D ! "(&   rIrQCheckers | NonecpdSd fd d fd }|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. Nr^r+r8rKc|J|}|rdkr|}|S)Nr)rrm)r^retrCrQrrrs rGrazDStringFormatterChecker.checkers_for_regular_type..check_typesU ,,,--c='JJC EyC''00sGDDJrIrrrtcJ|}|dSrr)rrwrarrs rGrzDStringFormatterChecker.checkers_for_regular_type..check_exprs,;;t]33D Jt     rI)r^r+r8rKrr)rrQrCrrrars```` @@rGr~z0StringFormatterChecker.checkers_for_regular_types ,,YFF  4                  :%%rIc>t|tr9t|dr)|jd|t jdSt|tr9t|dr)|jd|t jdSdS)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)rrr^rCs rGrmz,StringFormatterChecker.check_s_special_casess dG $ $ !#'788  \,  u dI & & !#~66  B0 utrIrw format_exprcp|dSd fd d fd }|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. Nrwr+r8rKcJttrd}nd}j||dtjS)Nz7"%c" requires an integer in range(256) or a single bytez"%c" requires int or charrir)rrrrkrr)rwerr_msgrCrrrs rGraz>StringFormatterChecker.checkers_for_c_type..check_typesa ,,,+y11 6S58))%, * rIrrrtc|}|rttrIt|tr4t|jdkrjdSt|ttfr6t|jdkr jdSdSdSdS)zint, or str with length 1rN) r3rrrrrrequires_int_or_single_byter!r)rrwrarCrrrs rGrz>StringFormatterChecker.checkers_for_c_type..check_exprs;;t]33Dz$ ;{I66;"433;DJ1,,H88AAAAAw &:;;;DJST@T@TH11'::::: ; ;;;@T@TrIrrr)rrwrCrrrars` `` @@rGr}z*StringFormatterChecker.checkers_for_c_types ,,T7KHH  4          ; ; ; ; ; ; ; ; ; ; :%%rIFpr Type | Nonec*|rtnt}|rtnt}|dkrU|sSt |t s)|jd|tj dS| dS|dkrttj S|dvrttj S||vr||vr| dg}n| d| d g}|sZ|tvr)|| d n(|| d t!j|S|d vrt |t r7t!| d| dgSt!| d| d gS|j||dS)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. rfz8Format character "b" is only supported on bytes patternsrNra)rrrrztyping.SupportsFloatztyping.SupportsInt)rr)rhrerjrirrrrrrrr'r,rrkrr/ make_unionunsupported_placeholder)rrrCrr NUMERIC_TYPES INT_TYPESrs rGrz&StringFormatterChecker.conversion_types.9O))>O '2GOO 88K8dI..  N0 t??#344 4 #XX9122 2 *__9122 2 -  I~~!%!@!@ A OON33OO$455! #TK''%,,T__=S-T-TUUUU%,,T__=Q-R-RSSS' 66 6 %ZZ$ **  __^44dooFV6W6WX!__^44doon6U6UV H , ,Q 8 8 84rIrr(c6|j|S)z}Return an instance type with type given by the name and no type arguments. Alias for TypeChecker.named_type. )rr)rrs rGrz!StringFormatterChecker.named_type/sx""4(((rINcB|jj||S)z0Type check a node. Alias for TypeChecker.accept.)rr2r3)rrrCs rGr3zStringFormatterChecker.accept5sx$++D':::rI)rr rrr8rt)rrrrr8rt)rrrrrrr8rt) rrmrrrrrr+rr+r8rt)rrrrr8r)rrrrrr8r)rvrrrr8r)rrrrr8rK)rrmrrrrr8r) r6rr7rrrmrrr8rK)rr5rrr8r+)rrrCrr8rD)rrrrrr5r8rt)rr5r8r+)rrrCrrr5r8rw)rHrmrCrrr5r8rw)rCrr8r6)r^r+rr+rCrr8rK)rQrrCrrr5r8r)rr5r^r+rCrr8rK)rwrrCrrr5r8rF) rrrCrrr5rrKr8r)rrr8r(r)rrrCrr8r+)rrr__doc____annotations__rrrrrrrrrr/rBr>r@r?rnrQryr|rr~rmr}rrr3rrIrGrr"s`  HHHH8G\G\G\G\R,,,,\""""HTTTT4VVVV6:&&&&P8 8 8 8 x*"G)G)G)G)R::::x((((    4&&&&$     &&&&..)&)&)&)&XUZ44444t)))) ;;;;;;;rIrr^r+rTct|}t|tr|jSt|t r5t |jptfd|j DSt|tr-tfd| DSdS)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. c38K|]}t|VdSrr)rrhrTs rGrz%has_type_component..FsGD D 01 q( + +D D D D D D rIc38K|]}t|VdSrr)rtrTs rGrz%has_type_component..Js.QQq%a22QQQQQQrIF) r2rr(rwr r.rrSr#valuesr/rU)r^rTs `rGrr:s #  C#x  Rx  *** C % %R!#/8<< D D D D 58ZD D D A A   C # #RQQQQCrrtypingrrrr typing_extensionsr r4mypy.errorcodes errorcodesrmypyr mypy.checker_sharedr mypy.errorsr mypy.maptyper mypy.messagesr mypy.nodesrrrrrrrrrrrrrrrrr r!r"r# mypy.parser$ mypy.subtypesr% mypy.typeopsr& mypy.typesr'r(r)r*r+r,r-r.r/r0r1r2r3r5rtuplerKr6dictrrrr7rHrSrTrUrVrXrerhrirjrkrmrrrrrrrIrGrs   #""""" ////////////555555!!!!!!444444222222((((((,$$$$$$...... %Wi%788888XzlD&898TFDL;QQRRRRRE#s(OU3Z788888 ! ! ! ! 8888@%$&& &&&&,,U33 333333D999999*****XWWWWWW\\\\\\\)((((2222222433 3333::::::::@JO55555p6666rU ;U ;U ;U ;U ;U ;U ;U ;prI