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

'"async for" outside async function'

'"async with" outside async function'

ErrorMessage('Unsupported decorated constructor type')

'Missing type parameters for generic type {}'

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

'Accessing "__init__" on an instance is unsound, since instance.__init__ could b↵
e from an incompatible subclass'

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

'Cannot assign to "__match_args__"'

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'

'Duplicate keyword pattern "{}"'

'Class pattern class must not be a type alias with type parameters'

'Keyword "{}" already matches a positional pattern'

'Too many positional patterns for class pattern'

'Expected type in class pattern; found "{}"'

'Class "{}" has no attribute "{}"'

'"{}" in __slots__ conflicts with class variable access'

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

'ClassVar cannot contain Self type in generic classes'

'ClassVar cannot contain type variables'

ErrorMessage('Contiguous iterable with same type expected')

'"alias" argument to dataclass field must be a string literal'

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('If the method is meant to be abstract, use @abc.abstractmethod', codes.EMPTY_BODY↵
)

ErrorMessage('Assigned "__members__" will be overridden by "Enum" internally')

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

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'

ErrorMessage('Incompatible import of "{}"',
             code=codes.ASSIGNMENT)

ErrorMessage('Incompatible redefinition')

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

ErrorMessage('Incompatible types')

ErrorMessage('Incompatible types in assignment',
             code=codes.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"')

ErrorMessage('Incompatible types in capture pattern')

'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 in except* cannot derive from BaseExceptionGroup')

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

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('Slice index must be an integer or None')

'Invalid type for "__slots__"'

ErrorMessage('Invalid type: try using Literal[{}.{}] instead?', codes.VALID_TYPE↵
)

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 "{}"'

'{} cannot be unpacked (must be tuple or TypeVarTuple)'

ErrorMessage('{} which can always be true in boolean context. Consider using {} ↵
instead.',
             code=codes.TRUTHY_ITERABLE)

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?')

'Class "{}" doesn\'t define "__match_args__"'

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

'Multiple assignments to name "{}" in pattern'

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

'Alternative patterns bind different names'

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

'Value of type {} must be used'

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'

'A function returning TypeVar should receive at least one argument containing th↵
e same TypeVar'

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

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

ErrorMessage('Yield value expected')