Update mypy configuration (#2799)

* Remove redundant mypy configuration options

- Remove `ignore_missing_imports = false` as it's the default
- `check_untyped_defs = true` is covered by `strict = true`
- `strict_bytes = true` is covered by `strict = true`

* Move third-party overrides into affected test

Instead of setting this globally, move it into the affected test.

* Enable `exhaustive-match` error code

* Enable `ignore-without-code` error code

* Enable `possibly-undefined` error code

* Enable `redundant-expr` error code

* Enable `redundant-self` error code

* Enable `truthy-bool` error code

* Enable `truthy-iterable` error code

* Enable `unimported-reveal` error code

* Enable `unused-awaitable` error code

* Disable `allow-redefinition` option

Author: ngnpope

mypy.ini

@@ -5,32 +5,33 @@
 incremental = true
 
 # Strictness:
-allow_redefinition = true
-check_untyped_defs = true
 # TODO: add type args to all generics
 disallow_any_generics = false
 # TODO: fix `Any` subclassing in `typeshed/builtins.pyi`
 disallow_subclassing_any = false
-ignore_missing_imports = false
 strict = true
-strict_bytes = true
 local_partial_types = true
 warn_unreachable = true
 
 disable_error_code = empty-body
-enable_error_code = deprecated
+enable_error_code =
+    deprecated,
+    exhaustive-match,
+    ignore-without-code,
+    possibly-undefined,
+    redundant-expr,
+    redundant-self,
+    truthy-bool,
+    truthy-iterable,
+    unimported-reveal,
+    unused-awaitable,
 
 show_traceback = true
 
 plugins =
     mypy_django_plugin.main,
     mypy.plugins.proper_plugin
 
-# Ignore incomplete hints in 3rd party stubs:
-[mypy-yaml.*]
-disallow_untyped_defs = false
-disallow_incomplete_defs = false
-
 # Our settings:
 [mypy.plugins.django-stubs]
 django_settings_module = scripts.django_tests_settings

mypy_django_plugin/django/context.py

@@ -200,8 +200,6 @@ def get_primary_key_field(self, model_cls: type[Model]) -> "Field[Any, Any]":
 
     def get_expected_types(self, api: TypeChecker, model_cls: type[Model], *, method: str) -> dict[str, MypyType]:
         contenttypes_in_apps = self.apps_registry.is_installed("django.contrib.contenttypes")
-        if contenttypes_in_apps:
-            from django.contrib.contenttypes.fields import GenericForeignKey
 
         expected_types = {}
         # add pk if not abstract=True
@@ -256,17 +254,20 @@ def get_expected_types(self, api: TypeChecker, model_cls: type[Model], *, method
 
                     expected_types[field_name] = model_set_type
 
-            elif contenttypes_in_apps and isinstance(field, GenericForeignKey):
-                # it's generic, so cannot set specific model
-                field_name = field.name
-                gfk_info = helpers.lookup_class_typeinfo(api, field.__class__)
-                if gfk_info is None:
-                    gfk_set_type: MypyType = AnyType(TypeOfAny.unannotated)
-                else:
-                    gfk_set_type = helpers.get_private_descriptor_type(
-                        gfk_info, "_pyi_private_set_type", is_nullable=True
-                    )
-                expected_types[field_name] = gfk_set_type
+            elif contenttypes_in_apps:
+                from django.contrib.contenttypes.fields import GenericForeignKey
+
+                if isinstance(field, GenericForeignKey):
+                    # it's generic, so cannot set specific model
+                    field_name = field.name
+                    gfk_info = helpers.lookup_class_typeinfo(api, field.__class__)
+                    if gfk_info is None:
+                        gfk_set_type: MypyType = AnyType(TypeOfAny.unannotated)
+                    else:
+                        gfk_set_type = helpers.get_private_descriptor_type(
+                            gfk_info, "_pyi_private_set_type", is_nullable=True
+                        )
+                    expected_types[field_name] = gfk_set_type
 
         return expected_types
 
@@ -510,7 +511,7 @@ def resolve_lookup_expected_type(
         for lookup_base in helpers.iter_bases(lookup_info):
             if lookup_base.args and isinstance((lookup_type := get_proper_type(lookup_base.args[0])), Instance):
                 # if it's Field, consider lookup_type a __get__ of current field
-                if isinstance(lookup_type, Instance) and lookup_type.type.fullname == fullnames.FIELD_FULLNAME:
+                if lookup_type.type.fullname == fullnames.FIELD_FULLNAME:
                     field_info = helpers.lookup_class_typeinfo(helpers.get_typechecker_api(ctx), field.__class__)
                     if field_info is None:
                         return AnyType(TypeOfAny.explicit)

mypy_django_plugin/transformers/models.py

@@ -317,7 +317,7 @@ class AddPrimaryKeyAlias(AddDefaultPrimaryKey):
     def run_with_model_cls(self, model_cls: type[Model]) -> None:
         # We also need to override existing `pk` definition from `stubs`:
         auto_field = model_cls._meta.pk
-        if auto_field:
+        if auto_field is not None:
             self.create_autofield(
                 auto_field=auto_field,
                 dest_name="pk",
@@ -1147,13 +1147,13 @@ def get_annotated_type(
     """
     if model_type.extra_attrs:
         extra_attrs = ExtraAttrs(
-            attrs={**model_type.extra_attrs.attrs, **(fields_dict.items if fields_dict is not None else {})},
+            attrs={**model_type.extra_attrs.attrs, **fields_dict.items},
             immutable=model_type.extra_attrs.immutable.copy(),
             mod_name=None,
         )
     else:
         extra_attrs = ExtraAttrs(
-            attrs=fields_dict.items if fields_dict is not None else {},
+            attrs=fields_dict.items,
             immutable=None,
             mod_name=None,
         )

mypy_django_plugin/transformers/querysets.py

@@ -258,8 +258,7 @@ def extract_proper_type_queryset_annotate(ctx: MethodContext, django_context: Dj
                 "builtins.dict", [api.named_generic_type("builtins.str", []), AnyType(TypeOfAny.from_omitted_generics)]
             )
         elif isinstance(original_row_type, TupleType):
-            fallback: Instance = original_row_type.partial_fallback
-            if fallback is not None and fallback.type.has_base("typing.NamedTuple"):
+            if original_row_type.partial_fallback.type.has_base("typing.NamedTuple"):
                 # TODO: Use a NamedTuple which contains the known fields, but also
                 #  falls back to allowing any attribute access.
                 row_type = AnyType(TypeOfAny.implementation_artifact)
@@ -535,10 +534,11 @@ def extract_prefetch_related_annotations(ctx: MethodContext, django_context: Dja
 
     See https://docs.djangoproject.com/en/5.2/ref/models/querysets/#prefetch-objects
     """
+    api = helpers.get_typechecker_api(ctx)
+
     if not (
         isinstance(ctx.type, Instance)
         and isinstance((default_return_type := get_proper_type(ctx.default_return_type)), Instance)
-        and (api := helpers.get_typechecker_api(ctx))
         and (qs_model := helpers.get_model_info_from_qs_ctx(ctx, django_context)) is not None
         and ctx.args
         and ctx.arg_types

tests/assert_type/db/models/test_enums.py

@@ -270,24 +270,24 @@ class Joker(TextChoices):
 assert_type(Award.choices, list[tuple[str, str]])  # pyright: ignore[reportAssertTypeFailure]
 
 # Assertions for mixing multiple choices types with consistent base types - only `IntegerChoices`.
-x = (Suit, Vehicle)
-assert_type([member.label for choices in x for member in choices], list[_StrOrPromise])
-assert_type([member.value for choices in x for member in choices], list[int])
+x0 = (Suit, Vehicle)
+assert_type([member.label for choices in x0 for member in choices], list[_StrOrPromise])
+assert_type([member.value for choices in x0 for member in choices], list[int])
 
 # Assertions for mixing multiple choices types with consistent base types - only `TextChoices`.
-x = (Medal, Gender)
-assert_type([member.label for choices in x for member in choices], list[_StrOrPromise])
-assert_type([member.value for choices in x for member in choices], list[str])
+x1 = (Medal, Gender)
+assert_type([member.label for choices in x1 for member in choices], list[_StrOrPromise])
+assert_type([member.value for choices in x1 for member in choices], list[str])
 
 # Assertions for mixing multiple choices types with different base types - `IntegerChoices` and `TextChoices`.
-x = (Medal, Suit)
-assert_type([member.label for choices in x for member in choices], list[_StrOrPromise])
-assert_type([member.value for choices in x for member in choices], list[int | str])
+x2 = (Medal, Suit)
+assert_type([member.label for choices in x2 for member in choices], list[_StrOrPromise])
+assert_type([member.value for choices in x2 for member in choices], list[int | str])
 
 # Assertions for mixing multiple choices types with consistent base types - custom types.
-x = (Constants, Separator)
-assert_type([member.label for choices in x for member in choices], list[_StrOrPromise])
-assert_type([member.value for choices in x for member in choices], list[Any])
+x3 = (Constants, Separator)
+assert_type([member.label for choices in x3 for member in choices], list[_StrOrPromise])
+assert_type([member.value for choices in x3 for member in choices], list[Any])
 
 
 # Assertions for choices objects defined and aliased in a model.

tests/typecheck/conf/test_settings.yml

@@ -18,6 +18,7 @@
         -   path: myapp/lib.py
             content: |
                 from typing import TYPE_CHECKING
+                from typing_extensions import reveal_type
                 import django.conf
 
                 settings = django.conf.settings

tests/typecheck/contrib/admin/test_decorators.yml

@@ -1,5 +1,7 @@
 - case: test_admin_decorators_display
   main: |
+    from typing_extensions import reveal_type
+
     from django.db import models
 
     from django.contrib import admin
@@ -56,6 +58,8 @@
 
 - case: test_admin_decorators_action
   main: |
+    from typing_extensions import reveal_type
+
     from django.db import models
 
     from django.contrib import admin

tests/typecheck/contrib/auth/test_auth.yml

@@ -1,5 +1,6 @@
 -   case: test_objects_using_auth_user_model_picks_up_configured_type
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth import authenticate, aauthenticate, get_user, get_user_model, login
         from django.contrib.auth.backends import ModelBackend
         from django.contrib.auth.decorators import user_passes_test
@@ -32,6 +33,7 @@
 
 -   case: test_objects_using_auth_user_model_uses_builtin_auth_user_per_default
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth import authenticate, aauthenticate, get_user, get_user_model, login
         from django.contrib.auth.backends import ModelBackend
         from django.contrib.auth.decorators import user_passes_test
@@ -62,6 +64,7 @@
 
 -   case: test_objects_for_auth_user_model_returns_stub_types_when_contrib_auth_is_not_installed
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth import authenticate, aauthenticate, get_user, get_user_model, login
         from django.contrib.auth.backends import ModelBackend
         from django.contrib.auth.base_user import AbstractBaseUser

tests/typecheck/contrib/auth/test_decorators.yml

@@ -1,6 +1,7 @@
 -   case: login_required_bare
     main: |
         from typing import Any
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import login_required
         from django.http import HttpRequest, HttpResponse
         @login_required
@@ -9,13 +10,15 @@
 -   case: login_required_bare_async
     main: |
         from typing import Any
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import login_required
         from django.http import HttpRequest, HttpResponse
         @login_required
         async def view_func(request: HttpRequest) -> HttpResponse: ...
         reveal_type(view_func)  # N: Revealed type is "def (request: django.http.request.HttpRequest) -> typing.Coroutine[Any, Any, django.http.response.HttpResponse]"
 -   case: login_required_fancy
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import login_required
         from django.core.handlers.wsgi import WSGIRequest
         from django.http import HttpResponse
@@ -24,6 +27,7 @@
         reveal_type(view_func)  # N: Revealed type is "def (request: django.core.handlers.wsgi.WSGIRequest, arg: builtins.str) -> django.http.response.HttpResponse"
 -   case: login_required_fancy_async
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import login_required
         from django.core.handlers.asgi import ASGIRequest
         from django.http import HttpResponse
@@ -32,6 +36,7 @@
         reveal_type(view_func)  # N: Revealed type is "def (request: django.core.handlers.asgi.ASGIRequest, arg: builtins.str) -> typing.Coroutine[Any, Any, django.http.response.HttpResponse]"
 -   case: login_required_weird
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import login_required
         from django.http import HttpRequest, HttpResponse
         # This is non-conventional usage, but covered in Django tests, so we allow it.
@@ -46,13 +51,15 @@
         def view_func2(request: Any) -> str: ...
 -   case: user_passes_test
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import user_passes_test
         from django.http import HttpRequest, HttpResponse
         @user_passes_test(lambda u: u.get_username().startswith('super'))
         def view_func(request: HttpRequest) -> HttpResponse: ...
         reveal_type(view_func)  # N: Revealed type is "def (request: django.http.request.HttpRequest) -> django.http.response.HttpResponse"
 -   case: user_passes_test_async
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import user_passes_test
         from django.http import HttpRequest, HttpResponse
         @user_passes_test(lambda u: u.get_username().startswith('super'))
@@ -66,13 +73,15 @@
         def view_func(request: HttpRequest) -> HttpResponse: ...
 -   case: permission_required
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import permission_required
         from django.http import HttpRequest, HttpResponse
         @permission_required('polls.can_vote')
         def view_func(request: HttpRequest) -> HttpResponse: ...
         reveal_type(view_func)  # N: Revealed type is "def (request: django.http.request.HttpRequest) -> django.http.response.HttpResponse"
 -   case: permission_required_async
     main: |
+        from typing_extensions import reveal_type
         from django.contrib.auth.decorators import permission_required
         from django.http import HttpRequest, HttpResponse
         @permission_required('polls.can_vote')

tests/typecheck/contrib/contenttypes/test_models.yml

@@ -1,5 +1,6 @@
 - case: test_contenttypes_models
   main: |
+    from typing_extensions import reveal_type
     from django.contrib.contenttypes.models import ContentType
 
     c = ContentType.objects.create(app_label='abc', model='abc')