mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/memprofile.py

@@ -0,0 +1,121 @@
+"""Utility for dumping memory usage stats.
+
+This is tailored to mypy and knows (a little) about which list objects are
+owned by particular AST nodes, etc.
+"""
+
+from __future__ import annotations
+
+import gc
+import sys
+from collections import defaultdict
+from typing import Dict, Iterable, cast
+
+from mypy.nodes import FakeInfo, Node
+from mypy.types import Type
+from mypy.util import get_class_descriptors
+
+
+def collect_memory_stats() -> tuple[dict[str, int], dict[str, int]]:
+    """Return stats about memory use.
+
+    Return a tuple with these items:
+      - Dict from object kind to number of instances of that kind
+      - Dict from object kind to total bytes used by all instances of that kind
+    """
+    objs = gc.get_objects()
+    find_recursive_objects(objs)
+
+    inferred = {}
+    for obj in objs:
+        if type(obj) is FakeInfo:
+            # Processing these would cause a crash.
+            continue
+        n = type(obj).__name__
+        if hasattr(obj, "__dict__"):
+            # Keep track of which class a particular __dict__ is associated with.
+            inferred[id(obj.__dict__)] = f"{n} (__dict__)"
+        if isinstance(obj, (Node, Type)):  # type: ignore[misc]
+            if hasattr(obj, "__dict__"):
+                for x in obj.__dict__.values():
+                    if isinstance(x, list):
+                        # Keep track of which node a list is associated with.
+                        inferred[id(x)] = f"{n} (list)"
+                    if isinstance(x, tuple):
+                        # Keep track of which node a list is associated with.
+                        inferred[id(x)] = f"{n} (tuple)"
+
+            for k in get_class_descriptors(type(obj)):
+                x = getattr(obj, k, None)
+                if isinstance(x, list):
+                    inferred[id(x)] = f"{n} (list)"
+                if isinstance(x, tuple):
+                    inferred[id(x)] = f"{n} (tuple)"
+
+    freqs: dict[str, int] = {}
+    memuse: dict[str, int] = {}
+    for obj in objs:
+        if id(obj) in inferred:
+            name = inferred[id(obj)]
+        else:
+            name = type(obj).__name__
+        freqs[name] = freqs.get(name, 0) + 1
+        memuse[name] = memuse.get(name, 0) + sys.getsizeof(obj)
+
+    return freqs, memuse
+
+
+def print_memory_profile(run_gc: bool = True) -> None:
+    if not sys.platform.startswith("win"):
+        import resource
+
+        system_memuse = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    else:
+        system_memuse = -1  # TODO: Support this on Windows
+    if run_gc:
+        gc.collect()
+    freqs, memuse = collect_memory_stats()
+    print("%7s  %7s  %7s  %s" % ("Freq", "Size(k)", "AvgSize", "Type"))
+    print("-------------------------------------------")
+    totalmem = 0
+    i = 0
+    for n, mem in sorted(memuse.items(), key=lambda x: -x[1]):
+        f = freqs[n]
+        if i < 50:
+            print("%7d  %7d  %7.0f  %s" % (f, mem // 1024, mem / f, n))
+        i += 1
+        totalmem += mem
+    print()
+    print("Mem usage RSS   ", system_memuse // 1024)
+    print("Total reachable ", totalmem // 1024)
+
+
+def find_recursive_objects(objs: list[object]) -> None:
+    """Find additional objects referenced by objs and append them to objs.
+
+    We use this since gc.get_objects() does not return objects without pointers
+    in them such as strings.
+    """
+    seen = {id(o) for o in objs}
+
+    def visit(o: object) -> None:
+        if id(o) not in seen:
+            objs.append(o)
+            seen.add(id(o))
+
+    for obj in objs.copy():
+        if type(obj) is FakeInfo:
+            # Processing these would cause a crash.
+            continue
+        if type(obj) in (dict, defaultdict):
+            for key, val in cast(Dict[object, object], obj).items():
+                visit(key)
+                visit(val)
+        if type(obj) in (list, tuple, set):
+            for x in cast(Iterable[object], obj):
+                visit(x)
+        if hasattr(obj, "__slots__"):
+            for base in type.mro(type(obj)):
+                for slot in getattr(base, "__slots__", ()):
+                    if hasattr(obj, slot):
+                        visit(getattr(obj, slot))

mypy/message_registry.py

@@ -0,0 +1,326 @@
+"""Message constants for generating error messages during type checking.
+
+Literal messages should be defined as constants in this module so they won't get out of sync
+if used in more than one place, and so that they can be easily introspected. These messages are
+ultimately consumed by messages.MessageBuilder.fail(). For more non-trivial message generation,
+add a method to MessageBuilder and call this instead.
+"""
+
+from __future__ import annotations
+
+from typing import Final, NamedTuple
+
+from mypy import errorcodes as codes
+
+
+class ErrorMessage(NamedTuple):
+    value: str
+    code: codes.ErrorCode | None = None
+
+    def format(self, *args: object, **kwargs: object) -> ErrorMessage:
+        return ErrorMessage(self.value.format(*args, **kwargs), code=self.code)
+
+    def with_additional_msg(self, info: str) -> ErrorMessage:
+        return ErrorMessage(self.value + info, code=self.code)
+
+
+# Invalid types
+INVALID_TYPE_RAW_ENUM_VALUE: Final = ErrorMessage(
+    "Invalid type: try using Literal[{}.{}] instead?", codes.VALID_TYPE
+)
+
+# Type checker error message constants
+NO_RETURN_VALUE_EXPECTED: Final = ErrorMessage("No return value expected", codes.RETURN_VALUE)
+MISSING_RETURN_STATEMENT: Final = ErrorMessage("Missing return statement", codes.RETURN)
+EMPTY_BODY_ABSTRACT: Final = ErrorMessage(
+    "If the method is meant to be abstract, use @abc.abstractmethod", codes.EMPTY_BODY
+)
+INVALID_IMPLICIT_RETURN: Final = ErrorMessage("Implicit return in function which does not return")
+INCOMPATIBLE_RETURN_VALUE_TYPE: Final = ErrorMessage(
+    "Incompatible return value type", codes.RETURN_VALUE
+)
+RETURN_VALUE_EXPECTED: Final = ErrorMessage("Return value expected", codes.RETURN_VALUE)
+NO_RETURN_EXPECTED: Final = ErrorMessage("Return statement in function which does not return")
+INVALID_EXCEPTION: Final = ErrorMessage("Exception must be derived from BaseException")
+INVALID_EXCEPTION_TYPE: Final = ErrorMessage(
+    "Exception type must be derived from BaseException (or be a tuple of exception classes)"
+)
+INVALID_EXCEPTION_GROUP: Final = ErrorMessage(
+    "Exception type in except* cannot derive from BaseExceptionGroup"
+)
+RETURN_IN_ASYNC_GENERATOR: Final = ErrorMessage(
+    '"return" with value in async generator is not allowed'
+)
+INVALID_RETURN_TYPE_FOR_GENERATOR: Final = ErrorMessage(
+    'The return type of a generator function should be "Generator" or one of its supertypes'
+)
+INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR: Final = ErrorMessage(
+    'The return type of an async generator function should be "AsyncGenerator" or one of its '
+    "supertypes"
+)
+YIELD_VALUE_EXPECTED: Final = ErrorMessage("Yield value expected")
+INCOMPATIBLE_TYPES: Final = ErrorMessage("Incompatible types")
+INCOMPATIBLE_TYPES_IN_ASSIGNMENT: Final = ErrorMessage(
+    "Incompatible types in assignment", code=codes.ASSIGNMENT
+)
+COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE: Final = ErrorMessage(
+    "Covariant override of a mutable attribute", code=codes.MUTABLE_OVERRIDE
+)
+INCOMPATIBLE_TYPES_IN_AWAIT: Final = ErrorMessage('Incompatible types in "await"')
+INCOMPATIBLE_REDEFINITION: Final = ErrorMessage("Incompatible redefinition")
+INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AENTER: Final = (
+    'Incompatible types in "async with" for "__aenter__"'
+)
+INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AEXIT: Final = (
+    'Incompatible types in "async with" for "__aexit__"'
+)
+INCOMPATIBLE_TYPES_IN_ASYNC_FOR: Final = 'Incompatible types in "async for"'
+INVALID_TYPE_FOR_SLOTS: Final = 'Invalid type for "__slots__"'
+
+ASYNC_FOR_OUTSIDE_COROUTINE: Final = '"async for" outside async function'
+ASYNC_WITH_OUTSIDE_COROUTINE: Final = '"async with" outside async function'
+
+INCOMPATIBLE_TYPES_IN_YIELD: Final = ErrorMessage('Incompatible types in "yield"')
+INCOMPATIBLE_TYPES_IN_YIELD_FROM: Final = ErrorMessage('Incompatible types in "yield from"')
+INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION: Final = "Incompatible types in string interpolation"
+INCOMPATIBLE_TYPES_IN_CAPTURE: Final = ErrorMessage("Incompatible types in capture pattern")
+MUST_HAVE_NONE_RETURN_TYPE: Final = ErrorMessage('The return type of "{}" must be None')
+TUPLE_INDEX_OUT_OF_RANGE: Final = ErrorMessage("Tuple index out of range")
+AMBIGUOUS_SLICE_OF_VARIADIC_TUPLE: Final = ErrorMessage("Ambiguous slice of a variadic tuple")
+TOO_MANY_TARGETS_FOR_VARIADIC_UNPACK: Final = ErrorMessage(
+    "Too many assignment targets for variadic unpack"
+)
+INVALID_SLICE_INDEX: Final = ErrorMessage("Slice index must be an integer, SupportsIndex or None")
+CANNOT_INFER_LAMBDA_TYPE: Final = ErrorMessage("Cannot infer type of lambda")
+CANNOT_ACCESS_INIT: Final = (
+    'Accessing "__init__" on an instance is unsound, since instance.__init__ could be from'
+    " an incompatible subclass"
+)
+NON_INSTANCE_NEW_TYPE: Final = ErrorMessage('"__new__" must return a class instance (got {})')
+INVALID_NEW_TYPE: Final = ErrorMessage('Incompatible return type for "__new__"')
+BAD_CONSTRUCTOR_TYPE: Final = ErrorMessage("Unsupported decorated constructor type")
+CANNOT_ASSIGN_TO_METHOD: Final = "Cannot assign to a method"
+CANNOT_ASSIGN_TO_TYPE: Final = "Cannot assign to a type"
+INCONSISTENT_ABSTRACT_OVERLOAD: Final = ErrorMessage(
+    "Overloaded method has both abstract and non-abstract variants"
+)
+MULTIPLE_OVERLOADS_REQUIRED: Final = ErrorMessage("Single overload definition, multiple required")
+READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE: Final = ErrorMessage(
+    "Read-only property cannot override read-write property"
+)
+FORMAT_REQUIRES_MAPPING: Final = "Format requires a mapping"
+RETURN_TYPE_CANNOT_BE_CONTRAVARIANT: Final = ErrorMessage(
+    "Cannot use a contravariant type variable as return type"
+)
+FUNCTION_PARAMETER_CANNOT_BE_COVARIANT: Final = ErrorMessage(
+    "Cannot use a covariant type variable as a parameter"
+)
+INCOMPATIBLE_IMPORT_OF: Final = ErrorMessage('Incompatible import of "{}"', code=codes.ASSIGNMENT)
+FUNCTION_TYPE_EXPECTED: Final = ErrorMessage(
+    "Function is missing a type annotation", codes.NO_UNTYPED_DEF
+)
+ONLY_CLASS_APPLICATION: Final = ErrorMessage(
+    "Type application is only supported for generic classes"
+)
+RETURN_TYPE_EXPECTED: Final = ErrorMessage(
+    "Function is missing a return type annotation", codes.NO_UNTYPED_DEF
+)
+ARGUMENT_TYPE_EXPECTED: Final = ErrorMessage(
+    "Function is missing a type annotation for one or more arguments", codes.NO_UNTYPED_DEF
+)
+KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE: Final = ErrorMessage(
+    'Keyword argument only valid with "str" key type in call to "dict"'
+)
+ALL_MUST_BE_SEQ_STR: Final = ErrorMessage("Type of __all__ must be {}, not {}")
+INVALID_TYPEDDICT_ARGS: Final = ErrorMessage(
+    "Expected keyword arguments, {...}, or dict(...) in TypedDict constructor"
+)
+TYPEDDICT_KEY_MUST_BE_STRING_LITERAL: Final = ErrorMessage(
+    "Expected TypedDict key to be string literal"
+)
+MALFORMED_ASSERT: Final = ErrorMessage("Assertion is always true, perhaps remove parentheses?")
+DUPLICATE_TYPE_SIGNATURES: Final = ErrorMessage("Function has duplicate type signatures")
+DESCRIPTOR_SET_NOT_CALLABLE: Final = ErrorMessage("{}.__set__ is not callable")
+DESCRIPTOR_GET_NOT_CALLABLE: Final = "{}.__get__ is not callable"
+MODULE_LEVEL_GETATTRIBUTE: Final = ErrorMessage(
+    "__getattribute__ is not valid at the module level"
+)
+CLASS_VAR_CONFLICTS_SLOTS: Final = '"{}" in __slots__ conflicts with class variable access'
+NAME_NOT_IN_SLOTS: Final = ErrorMessage(
+    'Trying to assign name "{}" that is not in "__slots__" of type "{}"'
+)
+TYPE_ALWAYS_TRUE: Final = ErrorMessage(
+    "{} which does not implement __bool__ or __len__ "
+    "so it could always be true in boolean context",
+    code=codes.TRUTHY_BOOL,
+)
+TYPE_ALWAYS_TRUE_UNIONTYPE: Final = ErrorMessage(
+    "{} of which no members implement __bool__ or __len__ "
+    "so it could always be true in boolean context",
+    code=codes.TRUTHY_BOOL,
+)
+FUNCTION_ALWAYS_TRUE: Final = ErrorMessage(
+    "Function {} could always be true in boolean context", code=codes.TRUTHY_FUNCTION
+)
+ITERABLE_ALWAYS_TRUE: Final = ErrorMessage(
+    "{} which can always be true in boolean context. Consider using {} instead.",
+    code=codes.TRUTHY_ITERABLE,
+)
+NOT_CALLABLE: Final = "{} not callable"
+TYPE_MUST_BE_USED: Final = "Value of type {} must be used"
+
+# Generic
+GENERIC_INSTANCE_VAR_CLASS_ACCESS: Final = (
+    "Access to generic instance variables via class is ambiguous"
+)
+GENERIC_CLASS_VAR_ACCESS: Final = "Access to generic class variables is ambiguous"
+BARE_GENERIC: Final = "Missing type parameters for generic type {}"
+IMPLICIT_GENERIC_ANY_BUILTIN: Final = (
+    'Implicit generic "Any". Use "{}" and specify generic parameters'
+)
+INVALID_UNPACK: Final = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
+INVALID_UNPACK_POSITION: Final = "Unpack is only valid in a variadic position"
+
+# TypeVar
+INCOMPATIBLE_TYPEVAR_VALUE: Final = 'Value of type variable "{}" of {} cannot be {}'
+CANNOT_USE_TYPEVAR_AS_EXPRESSION: Final = 'Type variable "{}.{}" cannot be used as an expression'
+INVALID_TYPEVAR_AS_TYPEARG: Final = 'Type variable "{}" not valid as type argument value for "{}"'
+INVALID_TYPEVAR_ARG_BOUND: Final = 'Type argument {} of "{}" must be a subtype of {}'
+INVALID_TYPEVAR_ARG_VALUE: Final = 'Invalid type argument value for "{}"'
+TYPEVAR_VARIANCE_DEF: Final = 'TypeVar "{}" may only be a literal bool'
+TYPEVAR_ARG_MUST_BE_TYPE: Final = '{} "{}" must be a type'
+TYPEVAR_UNEXPECTED_ARGUMENT: Final = 'Unexpected argument to "TypeVar()"'
+UNBOUND_TYPEVAR: Final = (
+    "A function returning TypeVar should receive at least "
+    "one argument containing the same TypeVar"
+)
+
+# Super
+TOO_MANY_ARGS_FOR_SUPER: Final = ErrorMessage('Too many arguments for "super"')
+SUPER_WITH_SINGLE_ARG_NOT_SUPPORTED: Final = ErrorMessage(
+    '"super" with a single argument not supported'
+)
+UNSUPPORTED_ARG_1_FOR_SUPER: Final = ErrorMessage('Unsupported argument 1 for "super"')
+UNSUPPORTED_ARG_2_FOR_SUPER: Final = ErrorMessage('Unsupported argument 2 for "super"')
+SUPER_VARARGS_NOT_SUPPORTED: Final = ErrorMessage('Varargs not supported with "super"')
+SUPER_POSITIONAL_ARGS_REQUIRED: Final = ErrorMessage('"super" only accepts positional arguments')
+SUPER_ARG_2_NOT_INSTANCE_OF_ARG_1: Final = ErrorMessage(
+    'Argument 2 for "super" not an instance of argument 1'
+)
+TARGET_CLASS_HAS_NO_BASE_CLASS: Final = ErrorMessage("Target class has no base class")
+SUPER_OUTSIDE_OF_METHOD_NOT_SUPPORTED: Final = ErrorMessage(
+    '"super()" outside of a method is not supported'
+)
+SUPER_ENCLOSING_POSITIONAL_ARGS_REQUIRED: Final = ErrorMessage(
+    '"super()" requires one or two positional arguments in enclosing function'
+)
+
+# Self-type
+MISSING_OR_INVALID_SELF_TYPE: Final = ErrorMessage(
+    "Self argument missing for a non-static method (or an invalid type for self)"
+)
+ERASED_SELF_TYPE_NOT_SUPERTYPE: Final = ErrorMessage(
+    'The erased type of self "{}" is not a supertype of its class "{}"'
+)
+
+# Final
+CANNOT_INHERIT_FROM_FINAL: Final = ErrorMessage('Cannot inherit from final class "{}"')
+DEPENDENT_FINAL_IN_CLASS_BODY: Final = ErrorMessage(
+    "Final name declared in class body cannot depend on type variables"
+)
+CANNOT_ACCESS_FINAL_INSTANCE_ATTR: Final = (
+    'Cannot access final instance attribute "{}" on class object'
+)
+CANNOT_MAKE_DELETABLE_FINAL: Final = ErrorMessage("Deletable attribute cannot be final")
+
+# Enum
+ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDEN: Final = ErrorMessage(
+    'Assigned "__members__" will be overridden by "Enum" internally'
+)
+
+# ClassVar
+CANNOT_OVERRIDE_INSTANCE_VAR: Final = ErrorMessage(
+    'Cannot override instance variable (previously declared on base class "{}") with class '
+    "variable"
+)
+CANNOT_OVERRIDE_CLASS_VAR: Final = ErrorMessage(
+    'Cannot override class variable (previously declared on base class "{}") with instance '
+    "variable"
+)
+CLASS_VAR_WITH_TYPEVARS: Final = "ClassVar cannot contain type variables"
+CLASS_VAR_WITH_GENERIC_SELF: Final = "ClassVar cannot contain Self type in generic classes"
+CLASS_VAR_OUTSIDE_OF_CLASS: Final = "ClassVar can only be used for assignments in class body"
+
+# Protocol
+RUNTIME_PROTOCOL_EXPECTED: Final = ErrorMessage(
+    "Only @runtime_checkable protocols can be used with instance and class checks"
+)
+CANNOT_INSTANTIATE_PROTOCOL: Final = ErrorMessage('Cannot instantiate protocol class "{}"')
+TOO_MANY_UNION_COMBINATIONS: Final = ErrorMessage(
+    "Not all union combinations were tried because there are too many unions"
+)
+
+CONTIGUOUS_ITERABLE_EXPECTED: Final = ErrorMessage("Contiguous iterable with same type expected")
+ITERABLE_TYPE_EXPECTED: Final = ErrorMessage("Invalid type '{}' for *expr (iterable expected)")
+TYPE_GUARD_POS_ARG_REQUIRED: Final = ErrorMessage("Type guard requires positional argument")
+
+# Match Statement
+MISSING_MATCH_ARGS: Final = 'Class "{}" doesn\'t define "__match_args__"'
+OR_PATTERN_ALTERNATIVE_NAMES: Final = "Alternative patterns bind different names"
+CLASS_PATTERN_GENERIC_TYPE_ALIAS: Final = (
+    "Class pattern class must not be a type alias with type parameters"
+)
+CLASS_PATTERN_TYPE_REQUIRED: Final = 'Expected type in class pattern; found "{}"'
+CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGS: Final = "Too many positional patterns for class pattern"
+CLASS_PATTERN_KEYWORD_MATCHES_POSITIONAL: Final = (
+    'Keyword "{}" already matches a positional pattern'
+)
+CLASS_PATTERN_DUPLICATE_KEYWORD_PATTERN: Final = 'Duplicate keyword pattern "{}"'
+CLASS_PATTERN_UNKNOWN_KEYWORD: Final = 'Class "{}" has no attribute "{}"'
+CLASS_PATTERN_CLASS_OR_STATIC_METHOD: Final = "Cannot have both classmethod and staticmethod"
+MULTIPLE_ASSIGNMENTS_IN_PATTERN: Final = 'Multiple assignments to name "{}" in pattern'
+CANNOT_MODIFY_MATCH_ARGS: Final = 'Cannot assign to "__match_args__"'
+
+DATACLASS_FIELD_ALIAS_MUST_BE_LITERAL: Final = (
+    '"alias" argument to dataclass field must be a string literal'
+)
+DATACLASS_POST_INIT_MUST_BE_A_FUNCTION: Final = '"__post_init__" method must be an instance method'
+
+# fastparse
+FAILED_TO_MERGE_OVERLOADS: Final = ErrorMessage(
+    "Condition can't be inferred, unable to merge overloads"
+)
+TYPE_IGNORE_WITH_ERRCODE_ON_MODULE: Final = ErrorMessage(
+    "type ignore with error code is not supported for modules; "
+    'use `# mypy: disable-error-code="{}"`',
+    codes.SYNTAX,
+)
+INVALID_TYPE_IGNORE: Final = ErrorMessage('Invalid "type: ignore" comment', codes.SYNTAX)
+TYPE_COMMENT_SYNTAX_ERROR_VALUE: Final = ErrorMessage(
+    'Syntax error in type comment "{}"', codes.SYNTAX
+)
+ELLIPSIS_WITH_OTHER_TYPEARGS: Final = ErrorMessage(
+    "Ellipses cannot accompany other argument types in function type signature", codes.SYNTAX
+)
+TYPE_SIGNATURE_TOO_MANY_ARGS: Final = ErrorMessage(
+    "Type signature has too many arguments", codes.SYNTAX
+)
+TYPE_SIGNATURE_TOO_FEW_ARGS: Final = ErrorMessage(
+    "Type signature has too few arguments", codes.SYNTAX
+)
+ARG_CONSTRUCTOR_NAME_EXPECTED: Final = ErrorMessage("Expected arg constructor name", codes.SYNTAX)
+ARG_CONSTRUCTOR_TOO_MANY_ARGS: Final = ErrorMessage(
+    "Too many arguments for argument constructor", codes.SYNTAX
+)
+MULTIPLE_VALUES_FOR_NAME_KWARG: Final = ErrorMessage(
+    '"{}" gets multiple values for keyword argument "name"', codes.SYNTAX
+)
+MULTIPLE_VALUES_FOR_TYPE_KWARG: Final = ErrorMessage(
+    '"{}" gets multiple values for keyword argument "type"', codes.SYNTAX
+)
+ARG_CONSTRUCTOR_UNEXPECTED_ARG: Final = ErrorMessage(
+    'Unexpected argument "{}" for argument constructor', codes.SYNTAX
+)
+ARG_NAME_EXPECTED_STRING_LITERAL: Final = ErrorMessage(
+    "Expected string literal for argument name, got {}", codes.SYNTAX
+)