mypy.checkstrformat.StringFormatterChecker

class documentation

class StringFormatterChecker: (source)

String interpolation/formatter type checker.

This class works closely together with checker.ExpressionChecker.

Method	`__init__`	Construct an expression type checker.
Method	`accept`	Type check a node. Alias for TypeChecker.accept.
Method	`analyze_conversion_specifiers`	Undocumented
Method	`apply_field_accessors`	Transform and validate expr in '{.attr[item]}'.format(expr) into expr.attr['item'].
Method	`auto_generate_keys`	Translate '{} {name} {}' to '{0} {name} {1}'.
Method	`build_dict_type`	Build expected mapping type for right operand in % formatting.
Method	`build_replacement_checkers`	Undocumented
Method	`check_mapping_str_interpolation`	Check % string interpolation with names specifiers '%(name)s' % {'name': 'John'}.
Method	`check_placeholder_type`	Undocumented
Method	`check_s_special_cases`	Additional special cases for %s in bytes vs string context.
Method	`check_simple_str_interpolation`	Check % string interpolation with positional specifiers '%s, %d' % ('yes, 42').
Method	`check_specs_in_format_call`	Perform pairwise checks for conversion specifiers vs their replacements.
Method	`check_str_format_call`	Perform more precise checks for str.format() calls when possible.
Method	`check_str_interpolation`	Check the types of the 'replacements' in a string interpolation expression: str % replacements.
Method	`checkers_for_c_type`	Returns a tuple of check functions that check whether, respectively, a node or a type is compatible with 'type' that is a character type.
Method	`checkers_for_regular_type`	Returns 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.
Method	`checkers_for_star`	Returns a tuple of check functions that check whether, respectively, a node or a type is compatible with a star in a conversion specifier.
Method	`conversion_type`	Return the type that is accepted for a string interpolation conversion specifier type.
Method	`find_replacements_in_call`	Find replacement expression for every specifier in str.format() call.
Method	`get_expr_by_name`	Get named replacement expression from '{name}'.format(name=...) call.
Method	`get_expr_by_position`	Get positional replacement expression from '{0}, {1}'.format(x, y, ...) call.
Method	`named_type`	Return an instance type with type given by the name and no type arguments. Alias for TypeChecker.named_type.
Method	`perform_special_format_checks`	Undocumented
Method	`replacement_checkers`	Returns 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.
Method	`validate_and_transform_accessors`	Validate and transform (in-place) format field accessors.
Instance Variable	`chk`	Undocumented
Instance Variable	`exprchk`	Undocumented
Instance Variable	`msg`	Undocumented
Instance Variable	`unicode_upcast`	Undocumented

def __init__(self, exprchk, chk, msg): (source)

Construct an expression type checker.

Parameters
exprchk:`mypy.checkexpr.ExpressionChecker`	Undocumented
chk:`mypy.checker.TypeChecker`	Undocumented
msg:`MessageBuilder`	Undocumented

def accept(self, expr, context=None): (source)

Type check a node. Alias for TypeChecker.accept.

Parameters
expr:`Expression`	Undocumented
context:`Optional[Type]`	Undocumented
Returns
`Type`	Undocumented

def analyze_conversion_specifiers(self, specifiers, context): (source)

Undocumented

Parameters
specifiers:`List[ConversionSpecifier]`	Undocumented
context:`Context`	Undocumented
Returns
`Optional[bool]`	Undocumented

def apply_field_accessors(self, spec, repl, ctx): (source)

Transform and validate expr in '{.attr[item]}'.format(expr) into expr.attr['item'].

If validation fails, return TempNode(AnyType).

Parameters
spec:`ConversionSpecifier`	Undocumented
repl:`Expression`	Undocumented
ctx:`Context`	Undocumented
Returns
`Expression`	Undocumented

def auto_generate_keys(self, all_specs, ctx): (source)

Translate '{} {name} {}' to '{0} {name} {1}'.

Return True if generation was successful, otherwise report an error and return false.

Parameters
all_specs:`List[ConversionSpecifier]`	Undocumented
ctx:`Context`	Undocumented
Returns
`bool`	Undocumented

def build_dict_type(self, expr): (source)

Build expected mapping type for right operand in % formatting.

Parameters
expr:`FormatStringExpr`	Undocumented
Returns
`Type`	Undocumented

def build_replacement_checkers(self, specifiers, context, expr): (source)

Undocumented

Parameters
specifiers:`List[ConversionSpecifier]`	Undocumented
context:`Context`	Undocumented
expr:`FormatStringExpr`	Undocumented
Returns
`Optional[List[Checkers]]`	Undocumented

def check_mapping_str_interpolation(self, specifiers, replacements, expr): (source)

Check % string interpolation with names specifiers '%(name)s' % {'name': 'John'}.

Parameters
specifiers:`List[ConversionSpecifier]`	Undocumented
replacements:`Expression`	Undocumented
expr:`FormatStringExpr`	Undocumented

def check_placeholder_type(self, typ, expected_type, context): (source)

Undocumented

Parameters
typ:`Type`	Undocumented
expected_type:`Type`	Undocumented
context:`Context`	Undocumented
Returns
`bool`	Undocumented

def check_s_special_cases(self, expr, typ, context): (source)

Additional special cases for %s in bytes vs string context.

Parameters
expr:`FormatStringExpr`	Undocumented
typ:`Type`	Undocumented
context:`Context`	Undocumented
Returns
`bool`	Undocumented

def check_simple_str_interpolation(self, specifiers, replacements, expr): (source)

Check % string interpolation with positional specifiers '%s, %d' % ('yes, 42').

Parameters
specifiers:`List[ConversionSpecifier]`	Undocumented
replacements:`Expression`	Undocumented
expr:`FormatStringExpr`	Undocumented

def check_specs_in_format_call(self, call, specs, format_value): (source)

Perform pairwise checks for conversion specifiers vs their replacements.

The core logic for format checking is implemented in this method.

Parameters
call:`CallExpr`	Undocumented
specs:`List[ConversionSpecifier]`	Undocumented
format_value:`str`	Undocumented

def check_str_format_call(self, call, format_value): (source)

Perform 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

Parameters
call:`CallExpr`	Undocumented
format_value:`str`	Undocumented

def check_str_interpolation(self, expr, replacements): (source)

Check the types of the 'replacements' in a string interpolation expression: str % replacements.

Parameters
expr:`FormatStringExpr`	Undocumented
replacements:`Expression`	Undocumented
Returns
`Type`	Undocumented

def checkers_for_c_type(self, type, context, format_expr): (source)

Returns a tuple of check functions that check whether, respectively, a node or a type is compatible with 'type' that is a character type.

Parameters
type:`str`	Undocumented
context:`Context`	Undocumented
format_expr:`FormatStringExpr`	Undocumented
Returns
`Optional[Checkers]`	Undocumented

def checkers_for_regular_type(self, conv_type, context, expr): (source)

Returns 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.

Parameters
conv_type:`str`	Undocumented
context:`Context`	Undocumented
expr:`FormatStringExpr`	Undocumented
Returns
`Optional[Checkers]`	Undocumented

def checkers_for_star(self, context): (source)

Returns a tuple of check functions that check whether, respectively, a node or a type is compatible with a star in a conversion specifier.

Parameters
context:`Context`	Undocumented
Returns
`Checkers`	Undocumented

def conversion_type(self, p, context, expr, format_call=False): (source)

Return 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.

Parameters
p:`str`	Undocumented
context:`Context`	Undocumented
expr:`FormatStringExpr`	Undocumented
format_call:`bool`	Undocumented
Returns
`Optional[Type]`	Undocumented

def find_replacements_in_call(self, call, keys): (source)

Find replacement expression for every specifier in str.format() call.

In case of an error use TempNode(AnyType).

Parameters
call:`CallExpr`	Undocumented
keys:`List[str]`	Undocumented
Returns
`List[Expression]`	Undocumented

def get_expr_by_name(self, key, call): (source)

Get named replacement expression from '{name}'.format(name=...) call.

If the type is from **kwargs, return TempNode(<item type>). Return None in case of an error.

Parameters
key:`str`	Undocumented
call:`CallExpr`	Undocumented
Returns
`Optional[Expression]`	Undocumented

def get_expr_by_position(self, pos, call): (source)

Get positional replacement expression from '{0}, {1}'.format(x, y, ...) call.

If the type is from *args, return TempNode(<item type>). Return None in case of an error.

Parameters
pos:`int`	Undocumented
call:`CallExpr`	Undocumented
Returns
`Optional[Expression]`	Undocumented

def named_type(self, name): (source)

Return an instance type with type given by the name and no type arguments. Alias for TypeChecker.named_type.

Parameters
name:`str`	Undocumented
Returns
`Instance`	Undocumented

def perform_special_format_checks(self, spec, call, repl, actual_type, expected_type): (source)

Undocumented

Parameters
spec:`ConversionSpecifier`	Undocumented
call:`CallExpr`	Undocumented
repl:`Expression`	Undocumented
actual_type:`Type`	Undocumented
expected_type:`Type`	Undocumented

def replacement_checkers(self, specifier, context, expr): (source)

Returns 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.

Parameters
specifier:`ConversionSpecifier`	Undocumented
context:`Context`	Undocumented
expr:`FormatStringExpr`	Undocumented
Returns
`Optional[List[Checkers]]`	Undocumented

def validate_and_transform_accessors(self, temp_ast, original_repl, spec, ctx): (source)

Validate 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)

Parameters
temp_ast:`Expression`	Undocumented
original_repl:`Expression`	Undocumented
spec:`ConversionSpecifier`	Undocumented
ctx:`Context`	Undocumented
Returns
`bool`	Undocumented

chk = (source)

Undocumented

exprchk = (source)

Undocumented

msg = (source)

Undocumented

unicode_upcast: bool = (source)

Undocumented