mypy.message_registry

ErrorMessage('Type of __all__ must be {}, not {}')

ErrorMessage('Function is missing a type annotation for one or more arguments', codes.NO_UNTYPED_DEF↵
)

ErrorMessage('Unsupported decorated constructor type')

'Missing type parameters for generic type {}'

'Cannot access final instance attribute "{}" on class object'

'Cannot access "__init__" directly'

'Cannot assign to a method'

'Cannot assign to a type'

ErrorMessage('Cannot infer type of lambda')

ErrorMessage('Cannot inherit from final class "{}"')

ErrorMessage('Cannot instantiate protocol class "{}"')

ErrorMessage('Deletable attribute cannot be final')

ErrorMessage('Cannot override class variable (previously declared on base class ↵
"{}") with instance variable')

ErrorMessage('Cannot override instance variable (previously declared on base cla↵
ss "{}") with class variable')

'Type variable "{}.{}" cannot be used as an expression'

'ClassVar can only be used for assignments in class body'

'ClassVar cannot contain type variables'

ErrorMessage('Contiguous iterable with same type expected')

ErrorMessage('Final name declared in class body cannot depend on type variables'↵
)

'{}.__get__ is not callable'

ErrorMessage('{}.__set__ is not callable')

'Function has duplicate type signatures'

ErrorMessage('The erased type of self "{}" is not a supertype of its class "{}"'↵
)

'Format requires a mapping'

ErrorMessage('Function {} could always be true in boolean context',
             code=codes.TRUTHY_BOOL)

ErrorMessage('Cannot use a covariant type variable as a parameter')

ErrorMessage('Function is missing a type annotation', codes.NO_UNTYPED_DEF)

'Access to generic class variables is ambiguous'

'Access to generic instance variables via class is ambiguous'

'Implicit generic "Any". Use "{}" and specify generic parameters'

'Incompatible import of'

ErrorMessage('Incompatible redefinition')

ErrorMessage('Incompatible return value type', codes.RETURN_VALUE)

'Incompatible types'

'Incompatible types in assignment'

'Incompatible types in "async for"'

'Incompatible types in "async with" for "__aenter__"'

'Incompatible types in "async with" for "__aexit__"'

ErrorMessage('Incompatible types in "await"')

'Incompatible types in string interpolation'

ErrorMessage('Incompatible types in "yield"')

ErrorMessage('Incompatible types in "yield from"')

'Value of type variable "{}" of {} cannot be {}'

ErrorMessage('Overloaded method has both abstract and non-abstract variants')

ErrorMessage('Exception must be derived from BaseException')

ErrorMessage('Exception type must be derived from BaseException')

ErrorMessage('The return type of a generator function must be None in its third ↵
type parameter in Python 2')

ErrorMessage('Implicit return in function which does not return')

ErrorMessage('Incompatible return type for "__new__"')

ErrorMessage('The return type of an async generator function should be "AsyncGen↵
erator" or one of its supertypes')

ErrorMessage('The return type of a generator function should be "Generator" or o↵
ne of its supertypes')

ErrorMessage('Invalid type for self, or extra argument type in function annotati↵
on')

ErrorMessage('Slice index must be an integer or None')

ErrorMessage('Invalid tuple index type')

'Invalid type: try using Literal[{}.{}] instead?'

ErrorMessage('Expected keyword arguments, {...}, or dict(...) in TypedDict const↵
ructor')

'Type argument {} of "{}" must be a subtype of {}'

'Invalid type argument value for "{}"'

'Type variable "{}" not valid as type argument value for "{}"'

ErrorMessage('Invalid type \'{}\' for *expr (iterable expected)')

ErrorMessage('Keyword argument only valid with "str" key type in call to "dict"'↵
)

ErrorMessage('Assertion is always true, perhaps remove parentheses?')

ErrorMessage('Self argument missing for a non-static method (or an invalid type ↵
for self)')

ErrorMessage('Missing return statement', codes.RETURN)

ErrorMessage('__getattribute__ is not valid at the module level')

ErrorMessage('Single overload definition, multiple required')

ErrorMessage('The return type of "{}" must be None')

ErrorMessage('Trying to assign name "{}" that is not in "__slots__" of type "{}"'↵
)

ErrorMessage('Return statement in function which does not return')

ErrorMessage('No return value expected', codes.RETURN_VALUE)

ErrorMessage('"__new__" must return a class instance (got {})')

'{} not callable'

ErrorMessage('Type application is only supported for generic classes')

'Argument "file" to "print" has incompatible type "{}"; expected "{}"'

ErrorMessage('Read-only property cannot override read-write property')

ErrorMessage('"return" with value in async generator is not allowed')

ErrorMessage('Cannot use a contravariant type variable as return type')

ErrorMessage('Function is missing a return type annotation', codes.NO_UNTYPED_DEF↵
)

ErrorMessage('Return value expected', codes.RETURN_VALUE)

ErrorMessage('Only @runtime_checkable protocols can be used with instance and cl↵
ass checks')

ErrorMessage('Argument 2 for "super" not an instance of argument 1')

ErrorMessage('super() requires one or more positional arguments in enclosing fun↵
ction')

ErrorMessage('super() outside of a method is not supported')

ErrorMessage('"super" only accepts positional arguments')

ErrorMessage('Varargs not supported with "super"')

ErrorMessage('"super" with a single argument not supported')

ErrorMessage('Target class has no base class')

ErrorMessage('Too few arguments for "super"', codes.CALL_ARG)

ErrorMessage('Too many arguments for "super"')

ErrorMessage('Not all union combinations were tried because there are too many u↵
nions')

ErrorMessage('Tuple index out of range')

ErrorMessage('{} which does not implement __bool__ or __len__ so it could always↵
 be true in boolean context',
             code=codes.TRUTHY_BOOL)

ErrorMessage('{} of which no members implement __bool__ or __len__ so it could a↵
lways be true in boolean context',
             code=codes.TRUTHY_BOOL)

ErrorMessage('Type guard requires positional argument')

ErrorMessage('Expected TypedDict key to be string literal')

'TypeVar "bound" must be a type'

'Unexpected argument to "TypeVar()"'

'TypeVar "{}" may only be a literal bool'

ErrorMessage('Unsupported argument 1 for "super"')

ErrorMessage('Unsupported argument 2 for "super"')

ErrorMessage('Yield value expected')