make ignore_missing_model_attributes behaviour optional (#66)

make "ignore_missing_model_attributes" behaviour opt-in

.gitignore

@@ -7,4 +7,5 @@ out/
 .mypy_cache/
 django-sources
 build/
-dist/
+dist/
+pip-wheel-metadata/

README.md

@@ -44,6 +44,9 @@ django_settings = mysettings.local
 # if True, all unknown settings in django.conf.settings will fallback to Any,
 # specify it if your settings are loaded dynamically to avoid false positives
 ignore_missing_settings = True
+
+# if True, unknown attributes on Model instances won't produce errors
+ignore_missing_model_attributes = True
 ```
 
 ## To get help

django-stubs/__init__.pyi

@@ -1,7 +1,12 @@
-from typing import Any
+from typing import Any, NamedTuple
 from .utils.version import get_version as get_version
 
 VERSION: Any
 __version__: str
 
 def setup(set_prefix: bool = ...) -> None: ...
+
+# Used by mypy_django_plugin when returning a QuerySet row that is a NamedTuple where the field names are unknown
+class _NamedTupleAnyAttr(NamedTuple):
+    def __getattr__(self, item: str) -> Any: ...
+    def __setattr__(self, item: str, value: Any) -> None: ...

django-stubs/conf/__init__.pyi

@@ -2,10 +2,14 @@ from typing import Any
 
 from django.utils.functional import LazyObject
 
+# explicit dependency on standard settings to make it loaded
+from . import global_settings
+
 ENVIRONMENT_VARIABLE: str = ...
 
 # required for plugin to be able to distinguish this specific instance of LazySettings from others
-class _DjangoConfLazyObject(LazyObject): ...
+class _DjangoConfLazyObject(LazyObject):
+    def __getattr__(self, item: Any) -> Any: ...
 
 class LazySettings(_DjangoConfLazyObject):
     configured: bool

django-stubs/conf/global_settings.pyi

@@ -5,14 +5,11 @@ by the DJANGO_SETTINGS_MODULE environment variable.
 
 # This is defined here as a do-nothing function because we can't import
 # django.utils.translation -- that module depends on the settings.
-from typing import Any, Dict, List, Optional, Pattern, Tuple, Protocol, Union, Callable, TYPE_CHECKING, Sequence
+from typing import Any, Dict, List, Optional, Pattern, Protocol, Sequence, Tuple, Union
 
 ####################
 # CORE             #
 ####################
-if TYPE_CHECKING:
-    from django.db.models.base import Model
-
 DEBUG: bool = ...
 
 # Whether the framework should propagate raw exceptions rather than catching
@@ -153,7 +150,7 @@ FORCE_SCRIPT_NAME = None
 #     ]
 DISALLOWED_USER_AGENTS: List[Pattern] = ...
 
-ABSOLUTE_URL_OVERRIDES: Dict[str, Callable[[Model], str]] = ...
+ABSOLUTE_URL_OVERRIDES: Dict[str, Any] = ...
 
 # List of compiled regular expression objects representing URLs that need not
 # be reported by BrokenLinkEmailsMiddleware. Here are a few examples:

django-stubs/contrib/admin/apps.pyi

@@ -1,25 +1,6 @@
-from typing import Any
-
 from django.apps import AppConfig
 
 class SimpleAdminConfig(AppConfig):
-    apps: None
-    label: str
-    models: None
-    models_module: None
-    module: Any
-    path: str
     default_site: str = ...
-    name: str = ...
-    verbose_name: Any = ...
-    def ready(self) -> None: ...
 
-class AdminConfig(SimpleAdminConfig):
-    apps: None
-    label: str
-    models: None
-    models_module: None
-    module: Any
-    name: str
-    path: str
-    def ready(self) -> None: ...
+class AdminConfig(SimpleAdminConfig): ...

django-stubs/contrib/admin/forms.pyi

@@ -1,33 +1,7 @@
-from typing import Any, Dict
-
 from django.contrib.auth.forms import AuthenticationForm, PasswordChangeForm
-from django.contrib.auth.models import User
 
 class AdminAuthenticationForm(AuthenticationForm):
-    auto_id: str
-    data: Dict[str, str]
-    empty_permitted: bool
-    error_class: type
-    fields: Dict[Any, Any]
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
-    request: None
-    user_cache: None
-    error_messages: Any = ...
     required_css_class: str = ...
-    def confirm_login_allowed(self, user: User) -> None: ...
 
 class AdminPasswordChangeForm(PasswordChangeForm):
-    auto_id: str
-    data: Dict[Any, Any]
-    empty_permitted: bool
-    error_class: type
-    fields: Dict[Any, Any]
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
-    user: Any
     required_css_class: str = ...

django-stubs/contrib/admin/helpers.pyi

@@ -1,27 +1,17 @@
-import collections
-from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union, Type
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
 
-from django import forms
 from django.contrib.auth.forms import AdminPasswordChangeForm
-from django.db.models.fields import AutoField
-from django.forms.utils import ErrorDict, ErrorList
+from django.forms.boundfield import BoundField
+from django.forms.utils import ErrorDict
 from django.forms.widgets import Media, Widget
 from django.utils.safestring import SafeText
 
-from django.forms.boundfield import BoundField
+from django import forms
+from django.db.models.fields import AutoField
 
 ACTION_CHECKBOX_NAME: str
 
 class ActionForm(forms.Form):
-    auto_id: None
-    data: Dict[Any, Any]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
     action: Any = ...
     select_across: Any = ...
 
@@ -36,8 +26,8 @@ class AdminForm:
         form: AdminPasswordChangeForm,
         fieldsets: List[Tuple[None, Dict[str, List[str]]]],
         prepopulated_fields: Dict[Any, Any],
-        readonly_fields: None = ...,
-        model_admin: None = ...,
+        readonly_fields: Any = ...,
+        model_admin: Any = ...,
     ) -> None: ...
     def __iter__(self) -> Iterator[Fieldset]: ...
     @property
@@ -137,7 +127,6 @@ class InlineAdminFormSet:
 
 class InlineAdminForm(AdminForm):
     formset: Any = ...
-    model_admin: Any = ...
     original: Any = ...
     show_url: Any = ...
     absolute_url: Any = ...
@@ -152,7 +141,6 @@ class InlineAdminForm(AdminForm):
         model_admin: Optional[Any] = ...,
         view_on_site_url: Optional[Any] = ...,
     ) -> None: ...
-    def __iter__(self) -> Iterator[InlineFieldset]: ...
     def needs_explicit_pk_field(self) -> Union[bool, AutoField]: ...
     def pk_field(self) -> AdminField: ...
     def fk_field(self) -> AdminField: ...
@@ -162,9 +150,6 @@ class InlineAdminForm(AdminForm):
 class InlineFieldset(Fieldset):
     formset: Any = ...
     def __init__(self, formset: Any, *args: Any, **kwargs: Any) -> None: ...
-    def __iter__(self) -> Iterator[Fieldline]: ...
 
 class AdminErrorList(forms.utils.ErrorList):
-    data: List[Any]
-    error_class: str
     def __init__(self, form: Any, inline_formsets: Any) -> None: ...

django-stubs/contrib/admin/views/autocomplete.pyi

@@ -1,18 +1,10 @@
-from typing import Any, Optional
+from typing import Any
 
+from django.contrib.admin.options import ModelAdmin
 from django.core.handlers.wsgi import WSGIRequest
-from django.core.paginator import Paginator
-from django.db.models.query import QuerySet
-from django.http.response import JsonResponse
 from django.views.generic.list import BaseListView
 
 class AutocompleteJsonView(BaseListView):
-    paginate_by: int = ...
     model_admin: ModelAdmin = ...
     term: Any = ...
-    paginator_class: Any = ...
-    object_list: Any = ...
-    def get(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> JsonResponse: ...
-    def get_paginator(self, *args: Any, **kwargs: Any) -> Paginator: ...
-    def get_queryset(self) -> QuerySet: ...
     def has_perm(self, request: WSGIRequest, obj: None = ...) -> bool: ...

django-stubs/contrib/admin/widgets.pyi

@@ -1,18 +1,12 @@
-from collections import OrderedDict
-from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 from uuid import UUID
 
+from django.contrib.admin.sites import AdminSite
+from django.db.models.fields.reverse_related import ForeignObjectRel, ManyToOneRel
 from django.forms.models import ModelChoiceIterator
+from django.forms.widgets import ChoiceWidget, Media
 
 from django import forms
-from django.contrib.admin.sites import AdminSite
-from django.db.models.fields.reverse_related import ForeignObjectRel, ManyToOneRel, ManyToManyRel
-from django.db.models.query_utils import Q
-from django.forms.fields import Field
-from django.forms.widgets import ChoiceWidget, Media, Widget, DateTimeBaseInput
-from django.http.request import QueryDict
-from django.utils.datastructures import MultiValueDict
 
 class FilteredSelectMultiple(forms.SelectMultiple):
     @property
@@ -20,109 +14,34 @@ class FilteredSelectMultiple(forms.SelectMultiple):
     verbose_name: Any = ...
     is_stacked: Any = ...
     def __init__(self, verbose_name: str, is_stacked: bool, attrs: None = ..., choices: Tuple = ...) -> None: ...
-    def get_context(
-        self, name: str, value: Union[List[Any], str], attrs: Optional[Dict[str, str]]
-    ) -> Dict[
-        str,
-        Union[
-            Dict[
-                str,
-                Union[
-                    Dict[str, Union[int, str]],
-                    List[Tuple[None, List[Dict[str, Union[Dict[Any, Any], int, str]]], int]],
-                    bool,
-                    str,
-                ],
-            ],
-            Dict[str, Union[Dict[str, Union[int, str]], List[str], bool, str]],
-        ],
-    ]: ...
 
 class AdminDateWidget(forms.DateInput):
-    attrs: Dict[str, str]
-    input_type: str
     @property
     def media(self) -> Media: ...
-    def __init__(self, attrs: Optional[Dict[str, Union[int, str]]] = ..., format: None = ...) -> None: ...
 
 class AdminTimeWidget(forms.TimeInput):
-    attrs: Dict[str, str]
-    input_type: str
     @property
     def media(self) -> Media: ...
-    def __init__(self, attrs: Optional[Dict[str, Union[int, str]]] = ..., format: None = ...) -> None: ...
 
-class AdminSplitDateTime(forms.SplitDateTimeWidget):
-    attrs: Dict[Any, Any]
-    widgets: List[DateTimeBaseInput]
-    template_name: str = ...
-    def __init__(self, attrs: None = ...) -> None: ...
-    def get_context(
-        self, name: str, value: Optional[Union[List[str], datetime]], attrs: Optional[Dict[str, Union[bool, str]]]
-    ) -> Dict[
-        str,
-        Union[
-            Dict[
-                str,
-                Optional[
-                    Union[
-                        Dict[str, Union[bool, str]],
-                        List[Dict[str, Optional[Union[Dict[str, Union[bool, str]], bool, str]]]],
-                        bool,
-                        str,
-                    ]
-                ],
-            ],
-            str,
-        ],
-    ]: ...
+class AdminSplitDateTime(forms.SplitDateTimeWidget): ...
+class AdminRadioSelect(forms.RadioSelect): ...
+class AdminFileWidget(forms.ClearableFileInput): ...
 
-class AdminRadioSelect(forms.RadioSelect):
-    attrs: Dict[str, str]
-    template_name: str = ...
-
-class AdminFileWidget(forms.ClearableFileInput):
-    attrs: Dict[Any, Any]
-    template_name: str = ...
-
-def url_params_from_lookup_dict(
-    lookups: Union[
-        Dict[str, Callable], Dict[str, List[str]], Dict[str, Tuple[str, str]], Dict[str, bool], Dict[str, str], Q
-    ]
-) -> Dict[str, str]: ...
+def url_params_from_lookup_dict(lookups: Any) -> Dict[str, str]: ...
 
 class ForeignKeyRawIdWidget(forms.TextInput):
-    attrs: Dict[Any, Any]
-    template_name: str = ...
     rel: ManyToOneRel = ...
     admin_site: AdminSite = ...
     db: None = ...
     def __init__(self, rel: ForeignObjectRel, admin_site: AdminSite, attrs: None = ..., using: None = ...) -> None: ...
-    def get_context(
-        self, name: str, value: Optional[Union[List[int], int, str, UUID]], attrs: Optional[Dict[str, Union[bool, str]]]
-    ) -> Dict[str, Union[Dict[str, Optional[Union[Dict[str, Union[bool, str]], bool, str]]], str]]: ...
     def base_url_parameters(self) -> Dict[str, str]: ...
     def url_parameters(self) -> Dict[str, str]: ...
     def label_and_url_for_value(self, value: Union[int, str, UUID]) -> Tuple[str, str]: ...
 
-class ManyToManyRawIdWidget(ForeignKeyRawIdWidget):
-    admin_site: AdminSite
-    attrs: Dict[Any, Any]
-    db: None
-    rel: ManyToManyRel
-    template_name: str = ...
-    def get_context(
-        self, name: str, value: Optional[List[int]], attrs: Optional[Dict[str, str]]
-    ) -> Dict[str, Union[Dict[str, Union[Dict[str, str], bool, str]], str]]: ...
-    def url_parameters(self) -> Dict[Any, Any]: ...
-    def label_and_url_for_value(self, value: List[int]) -> Tuple[str, str]: ...
-    def value_from_datadict(self, data: QueryDict, files: MultiValueDict, name: str) -> None: ...
-    def format_value(self, value: Optional[List[int]]) -> str: ...
+class ManyToManyRawIdWidget(ForeignKeyRawIdWidget): ...
 
 class RelatedFieldWidgetWrapper(forms.Widget):
     template_name: str = ...
-    needs_multipart_form: bool = ...
-    attrs: Dict[Any, Any] = ...
     choices: ModelChoiceIterator = ...
     widget: AutocompleteSelect = ...
     rel: ManyToOneRel = ...
@@ -141,54 +60,19 @@ class RelatedFieldWidgetWrapper(forms.Widget):
         can_delete_related: bool = ...,
         can_view_related: bool = ...,
     ) -> None: ...
-    def __deepcopy__(
-        self, memo: Dict[int, Union[List[Union[Field, Widget]], OrderedDict, Field, Widget]]
-    ) -> RelatedFieldWidgetWrapper: ...
-    @property
-    def is_hidden(self) -> bool: ...
     @property
     def media(self) -> Media: ...
     def get_related_url(self, info: Tuple[str, str], action: str, *args: Any) -> str: ...
-    def get_context(
-        self, name: str, value: Optional[Union[int, str]], attrs: Optional[Dict[str, Union[bool, str]]]
-    ) -> Dict[str, Union[bool, str]]: ...
-    def value_from_datadict(
-        self, data: QueryDict, files: MultiValueDict, name: str
-    ) -> Optional[Union[List[str], str]]: ...
-    def value_omitted_from_data(self, data: Dict[Any, Any], files: Dict[Any, Any], name: str) -> bool: ...
-    def id_for_label(self, id_: str) -> str: ...
 
-class AdminTextareaWidget(forms.Textarea):
-    attrs: Dict[str, str]
-    def __init__(self, attrs: None = ...) -> None: ...
-
-class AdminTextInputWidget(forms.TextInput):
-    attrs: Dict[str, str]
-    input_type: str
-    def __init__(self, attrs: None = ...) -> None: ...
-
-class AdminEmailInputWidget(forms.EmailInput):
-    attrs: Dict[str, str]
-    input_type: str
-    def __init__(self, attrs: None = ...) -> None: ...
-
-class AdminURLFieldWidget(forms.URLInput):
-    attrs: Dict[str, str]
-    input_type: str
-    template_name: str = ...
-    def __init__(self, attrs: None = ...) -> None: ...
-    def get_context(
-        self, name: str, value: Optional[str], attrs: Optional[Dict[str, str]]
-    ) -> Dict[str, Union[Dict[str, Optional[Union[Dict[str, str], bool, str]]], str]]: ...
+class AdminTextareaWidget(forms.Textarea): ...
+class AdminTextInputWidget(forms.TextInput): ...
+class AdminEmailInputWidget(forms.EmailInput): ...
+class AdminURLFieldWidget(forms.URLInput): ...
 
 class AdminIntegerFieldWidget(forms.NumberInput):
-    attrs: Dict[str, str]
-    input_type: str
     class_name: str = ...
-    def __init__(self, attrs: None = ...) -> None: ...
 
-class AdminBigIntegerFieldWidget(AdminIntegerFieldWidget):
-    class_name: str = ...
+class AdminBigIntegerFieldWidget(AdminIntegerFieldWidget): ...
 
 SELECT2_TRANSLATIONS: Any
 
@@ -208,12 +92,6 @@ class AutocompleteMixin:
         using: None = ...,
     ) -> None: ...
     def get_url(self) -> str: ...
-    def build_attrs(
-        self, base_attrs: Dict[str, str], extra_attrs: Optional[Dict[str, Union[bool, str]]] = ...
-    ) -> Dict[str, Union[bool, str]]: ...
-    def optgroups(
-        self, name: str, value: List[str], attr: Dict[str, Union[bool, str]] = ...
-    ) -> List[Tuple[None, List[Dict[str, Union[Dict[str, bool], Set[str], int, str]]], int]]: ...
     @property
     def media(self) -> Media: ...
 

django-stubs/contrib/auth/admin.pyi

@@ -1,55 +1,18 @@
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any
 
-from django.contrib.auth.models import User, Group
 from django.core.handlers.wsgi import WSGIRequest
-from django.db.models.fields import Field
-from django.db.models.fields.related import ManyToManyField
-from django.db.models.options import Options
-from django.forms.models import ModelMultipleChoiceField
-from django.forms.fields import Field as FormField
-from django.forms.widgets import Widget
 from django.http.response import HttpResponse
-from django.urls.resolvers import URLPattern
 
 from django.contrib import admin
-from django.contrib.admin.sites import AdminSite
 
 csrf_protect_m: Any
 sensitive_post_parameters_m: Any
 
-class GroupAdmin(admin.ModelAdmin):
-    admin_site: AdminSite
-    formfield_overrides: Any
-    model: Type[Group]
-    opts: Options
-    search_fields: Any = ...
-    ordering: Any = ...
-    filter_horizontal: Any = ...
-    def formfield_for_manytomany(
-        self, db_field: ManyToManyField, request: WSGIRequest = ..., **kwargs: Any
-    ) -> ModelMultipleChoiceField: ...
+class GroupAdmin(admin.ModelAdmin): ...
 
 class UserAdmin(admin.ModelAdmin):
-    admin_site: AdminSite
-    formfield_overrides: Dict[Type[Field], Dict[str, Type[Union[FormField, Widget]]]]
-    model: Type[User]
-    opts: Options
-    add_form_template: str = ...
     change_user_password_template: Any = ...
-    fieldsets: Any = ...
     add_fieldsets: Any = ...
-    form: Any = ...
     add_form: Any = ...
     change_password_form: Any = ...
-    list_display: Any = ...
-    list_filter: Any = ...
-    search_fields: Any = ...
-    ordering: Any = ...
-    filter_horizontal: Any = ...
-    def get_fieldsets(self, request: WSGIRequest, obj: None = ...) -> Tuple[Tuple[None, Dict[str, Tuple[str]]]]: ...
-    def get_form(self, request: Any, obj: Optional[Any] = ..., **kwargs: Any): ...
-    def get_urls(self) -> List[URLPattern]: ...
-    def lookup_allowed(self, lookup: str, value: str) -> bool: ...
-    def add_view(self, request: WSGIRequest, form_url: str = ..., extra_context: None = ...) -> Any: ...
     def user_change_password(self, request: WSGIRequest, id: str, form_url: str = ...) -> HttpResponse: ...
-    def response_add(self, request: WSGIRequest, obj: User, post_url_continue: None = ...) -> HttpResponse: ...

django-stubs/contrib/auth/apps.pyi

@@ -1,18 +1,3 @@
-from typing import Any, Optional
-
 from django.apps import AppConfig
 
-from .checks import check_models_permissions, check_user_model
-from .management import create_permissions
-from .signals import user_logged_in
-
-class AuthConfig(AppConfig):
-    apps: None
-    label: str
-    models: None
-    models_module: None
-    module: Any
-    path: str
-    name: str = ...
-    verbose_name: Any = ...
-    def ready(self) -> None: ...
+class AuthConfig(AppConfig): ...

django-stubs/contrib/auth/checks.pyi

@@ -1,8 +1,6 @@
-from typing import Any, List, Optional
+from typing import Any, List
 
 from django.core.checks.messages import CheckMessage
 
-from .management import _get_builtin_permissions
-
 def check_user_model(app_configs: None = ..., **kwargs: Any) -> List[CheckMessage]: ...
 def check_models_permissions(app_configs: None = ..., **kwargs: Any) -> List[Any]: ...

django-stubs/contrib/auth/context_processors.pyi

@@ -1,22 +1,20 @@
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict
 
-from django.contrib.auth.models import AnonymousUser, User
 from django.http.request import HttpRequest
-from django.utils.functional import SimpleLazyObject
 
 class PermLookupDict:
-    app_label: django.utils.safestring.SafeText
-    user: SimpleLazyObject
-    def __init__(self, user: SimpleLazyObject, app_label: str) -> None: ...
+    app_label: str
+    user: Any
+    def __init__(self, user: Any, app_label: str) -> None: ...
     def __getitem__(self, perm_name: str) -> bool: ...
     def __iter__(self) -> Any: ...
     def __bool__(self) -> bool: ...
 
 class PermWrapper:
-    user: SimpleLazyObject = ...
-    def __init__(self, user: Union[AnonymousUser, User]) -> None: ...
+    user: Any = ...
+    def __init__(self, user: Any) -> None: ...
     def __getitem__(self, app_label: str) -> PermLookupDict: ...
     def __iter__(self) -> Any: ...
-    def __contains__(self, perm_name: Union[bool, str]) -> bool: ...
+    def __contains__(self, perm_name: Any) -> bool: ...
 
-def auth(request: HttpRequest) -> Dict[str, Union[PermWrapper, AnonymousUser, User]]: ...
+def auth(request: HttpRequest) -> Dict[str, Any]: ...

django-stubs/contrib/auth/forms.pyi

@@ -1,44 +1,24 @@
-import collections
-import datetime
-from typing import Any, Dict, Iterator, List, Optional, Union, Type
+from typing import Any, Dict, Iterator, Optional
 
 from django.contrib.auth.base_user import AbstractBaseUser
 from django.contrib.auth.models import AbstractUser, User
 from django.contrib.auth.tokens import PasswordResetTokenGenerator
 from django.core.exceptions import ValidationError
 from django.core.handlers.wsgi import WSGIRequest
-from django.forms.utils import ErrorList
-from django.http.request import QueryDict
-from django.utils.datastructures import MultiValueDict
 
 from django import forms
 
 UserModel: Any
 
 class ReadOnlyPasswordHashWidget(forms.Widget):
-    attrs: Dict[Any, Any]
     template_name: str = ...
 
 class ReadOnlyPasswordHashField(forms.Field):
-    widget: Any = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    def bound_data(self, data: None, initial: str) -> str: ...
-    def has_changed(self, initial: str, data: Optional[str]) -> bool: ...
 
-class UsernameField(forms.CharField):
-    def to_python(self, value: Optional[str]) -> str: ...
+class UsernameField(forms.CharField): ...
 
 class UserCreationForm(forms.ModelForm):
-    auto_id: str
-    data: Dict[str, str]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    instance: User
-    is_bound: bool
-    label_suffix: str
     error_messages: Any = ...
     password1: Any = ...
     password2: Any = ...
@@ -46,30 +26,11 @@ class UserCreationForm(forms.ModelForm):
     def clean_password2(self) -> str: ...
 
 class UserChangeForm(forms.ModelForm):
-    auto_id: str
-    data: Dict[Any, Any]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[str, Optional[Union[List[Any], datetime.datetime, int, str]]]
-    instance: User
-    is_bound: bool
-    label_suffix: str
     password: Any = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def clean_password(self) -> str: ...
 
 class AuthenticationForm(forms.Form):
-    auto_id: str
-    data: QueryDict
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: MultiValueDict
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
     username: Any = ...
     password: Any = ...
     error_messages: Any = ...
@@ -82,21 +43,12 @@ class AuthenticationForm(forms.Form):
     def get_invalid_login_error(self) -> ValidationError: ...
 
 class PasswordResetForm(forms.Form):
-    auto_id: str
-    data: Dict[Any, Any]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
     email: Any = ...
     def send_mail(
         self,
         subject_template_name: str,
         email_template_name: str,
-        context: Dict[str, Union[AbstractBaseUser, str]],
+        context: Dict[str, Any],
         from_email: Optional[str],
         to_email: str,
         html_email_template_name: Optional[str] = ...,
@@ -116,15 +68,6 @@ class PasswordResetForm(forms.Form):
     ) -> None: ...
 
 class SetPasswordForm(forms.Form):
-    auto_id: str
-    data: Dict[Any, Any]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
     error_messages: Any = ...
     new_password1: Any = ...
     new_password2: Any = ...
@@ -134,31 +77,10 @@ class SetPasswordForm(forms.Form):
     def save(self, commit: bool = ...) -> AbstractBaseUser: ...
 
 class PasswordChangeForm(SetPasswordForm):
-    auto_id: str
-    data: Dict[Any, Any]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
-    user: User
-    error_messages: Any = ...
     old_password: Any = ...
-    field_order: Any = ...
     def clean_old_password(self) -> str: ...
 
 class AdminPasswordChangeForm(forms.Form):
-    auto_id: str
-    data: Dict[Any, Any]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[Any, Any]
-    is_bound: bool
-    label_suffix: str
     error_messages: Any = ...
     required_css_class: str = ...
     password1: Any = ...
@@ -167,5 +89,3 @@ class AdminPasswordChangeForm(forms.Form):
     def __init__(self, user: AbstractUser, *args: Any, **kwargs: Any) -> None: ...
     def clean_password2(self) -> str: ...
     def save(self, commit: bool = ...) -> AbstractUser: ...
-    @property
-    def changed_data(self) -> List[str]: ...

django-stubs/contrib/auth/views.pyi

@@ -1,15 +1,10 @@
-from typing import Any, Dict, Optional, Set, Type, Union
+from typing import Any, Optional, Set
 
 from django.contrib.auth.base_user import AbstractBaseUser
-from django.contrib.auth.forms import AuthenticationForm, PasswordChangeForm, PasswordResetForm, SetPasswordForm
-from django.contrib.auth.models import User
-from django.contrib.sites.models import Site
-from django.contrib.sites.requests import RequestSite
 from django.core.handlers.wsgi import WSGIRequest
 from django.http.request import HttpRequest
-from django.http.response import HttpResponse, HttpResponseRedirect
+from django.http.response import HttpResponseRedirect
 from django.template.response import TemplateResponse
-from django.utils.datastructures import MultiValueDict
 from django.views.generic.base import TemplateView
 from django.views.generic.edit import FormView
 
@@ -20,29 +15,18 @@ class SuccessURLAllowedHostsMixin:
     def get_success_url_allowed_hosts(self) -> Set[str]: ...
 
 class LoginView(SuccessURLAllowedHostsMixin, FormView):
-    form_class: Any = ...
     authentication_form: Any = ...
     redirect_field_name: Any = ...
-    template_name: str = ...
     redirect_authenticated_user: bool = ...
     extra_context: Any = ...
-    def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
-    def get_success_url(self) -> str: ...
     def get_redirect_url(self) -> str: ...
-    def get_form_class(self) -> Type[AuthenticationForm]: ...
-    def get_form_kwargs(self) -> Dict[str, Optional[Union[Dict[str, str], HttpRequest, MultiValueDict]]]: ...
-    def form_valid(self, form: AuthenticationForm) -> HttpResponseRedirect: ...
-    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ...
 
 class LogoutView(SuccessURLAllowedHostsMixin, TemplateView):
     next_page: Any = ...
     redirect_field_name: Any = ...
-    template_name: str = ...
     extra_context: Any = ...
-    def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
     def post(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> TemplateResponse: ...
     def get_next_page(self) -> Optional[str]: ...
-    def get_context_data(self, **kwargs: Any): ...
 
 def logout_then_login(request: HttpRequest, login_url: Optional[str] = ...) -> HttpResponseRedirect: ...
 def redirect_to_login(
@@ -56,55 +40,32 @@ class PasswordContextMixin:
 class PasswordResetView(PasswordContextMixin, FormView):
     email_template_name: str = ...
     extra_email_context: Any = ...
-    form_class: Any = ...
     from_email: Any = ...
     html_email_template_name: Any = ...
     subject_template_name: str = ...
-    success_url: Any = ...
-    template_name: str = ...
     title: Any = ...
     token_generator: Any = ...
-    def dispatch(self, *args: Any, **kwargs: Any) -> HttpResponse: ...
-    def form_valid(self, form: PasswordResetForm) -> HttpResponseRedirect: ...
 
 INTERNAL_RESET_URL_TOKEN: str
 INTERNAL_RESET_SESSION_TOKEN: str
 
 class PasswordResetDoneView(PasswordContextMixin, TemplateView):
-    template_name: str = ...
     title: Any = ...
 
 class PasswordResetConfirmView(PasswordContextMixin, FormView):
-    form_class: Any = ...
     post_reset_login: bool = ...
     post_reset_login_backend: Any = ...
-    success_url: Any = ...
-    template_name: str = ...
     title: Any = ...
     token_generator: Any = ...
     validlink: bool = ...
     user: Any = ...
-    def dispatch(self, *args: Any, **kwargs: Any) -> HttpResponse: ...
     def get_user(self, uidb64: str) -> Optional[AbstractBaseUser]: ...
-    def get_form_kwargs(self) -> Dict[str, Optional[Union[Dict[Any, Any], AbstractBaseUser, MultiValueDict]]]: ...
-    def form_valid(self, form: SetPasswordForm) -> HttpResponseRedirect: ...
-    def get_context_data(self, **kwargs: Any): ...
 
 class PasswordResetCompleteView(PasswordContextMixin, TemplateView):
-    template_name: str = ...
     title: Any = ...
-    def get_context_data(self, **kwargs: Any): ...
 
 class PasswordChangeView(PasswordContextMixin, FormView):
-    form_class: Any = ...
-    success_url: Any = ...
-    template_name: str = ...
     title: Any = ...
-    def dispatch(self, *args: Any, **kwargs: Any) -> HttpResponse: ...
-    def get_form_kwargs(self) -> Dict[str, Optional[Union[Dict[Any, Any], User, MultiValueDict]]]: ...
-    def form_valid(self, form: PasswordChangeForm) -> HttpResponseRedirect: ...
 
 class PasswordChangeDoneView(PasswordContextMixin, TemplateView):
-    template_name: str = ...
     title: Any = ...
-    def dispatch(self, *args: Any, **kwargs: Any) -> TemplateResponse: ...

django-stubs/contrib/contenttypes/apps.pyi

@@ -1,16 +1,3 @@
-from typing import Any, Optional
-
 from django.apps import AppConfig
 
-from .management import create_contenttypes, inject_rename_contenttypes_operations
-
-class ContentTypesConfig(AppConfig):
-    apps: None
-    label: str
-    models: None
-    models_module: None
-    module: Any
-    path: str
-    name: str = ...
-    verbose_name: Any = ...
-    def ready(self) -> None: ...
+class ContentTypesConfig(AppConfig): ...

django-stubs/contrib/contenttypes/management/commands/remove_stale_contenttypes.pyi

@@ -1,20 +1,13 @@
-from typing import Any, Optional
+from typing import Any, Dict, List
 
-from django.core.management import BaseCommand
-from django.core.management.base import CommandParser
 from django.db.models.deletion import Collector
 
-from ...management import get_contenttypes_and_models
+from django.core.management import BaseCommand
 
-class Command(BaseCommand):
-    stderr: django.core.management.base.OutputWrapper
-    stdout: django.core.management.base.OutputWrapper
-    style: django.core.management.color.Style
-    def add_arguments(self, parser: CommandParser) -> None: ...
-    def handle(self, **options: Any) -> None: ...
+class Command(BaseCommand): ...
 
 class NoFastDeleteCollector(Collector):
-    data: collections.OrderedDict
+    data: Dict[str, Any]
     dependencies: Dict[Any, Any]
     fast_deletes: List[Any]
     field_updates: Dict[Any, Any]

django-stubs/contrib/flatpages/forms.pyi

@@ -1,19 +1,7 @@
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 from django import forms
-from django.db.models.query import QuerySet
 
 class FlatpageForm(forms.ModelForm):
-    auto_id: str
-    data: Dict[str, Union[List[int], str]]
-    empty_permitted: bool
-    error_class: Type[ErrorList]
-    fields: collections.OrderedDict
-    files: Dict[Any, Any]
-    initial: Dict[str, Union[List[django.contrib.sites.models.Site], int, str]]
-    instance: django.contrib.flatpages.models.FlatPage
-    is_bound: bool
-    label_suffix: str
     url: Any = ...
     def clean_url(self) -> str: ...
-    def clean(self) -> Dict[str, Union[bool, QuerySet, str]]: ...

django-stubs/contrib/flatpages/models.pyi

@@ -9,5 +9,5 @@ class FlatPage(models.Model):
     enable_comments: models.BooleanField = ...
     template_name: models.CharField = ...
     registration_required: models.BooleanField = ...
-    sites: models.ManyToManyField[Site] = ...
+    sites: models.ManyToManyField[Site, Site] = ...
     def get_absolute_url(self) -> str: ...

django-stubs/contrib/flatpages/sitemaps.pyi

@@ -1,7 +1,3 @@
-from typing import Optional
-
 from django.contrib.sitemaps import Sitemap
-from django.db.models.query import QuerySet
 
-class FlatPageSitemap(Sitemap):
-    def items(self) -> QuerySet: ...
+class FlatPageSitemap(Sitemap): ...

django-stubs/contrib/messages/constants.pyi

@@ -0,0 +1,11 @@
+from typing import Dict
+
+DEBUG: int = ...
+INFO: int = ...
+SUCCESS: int = ...
+WARNING: int = ...
+ERROR: int = ...
+
+DEFAULT_TAGS: Dict[int, str] = ...
+
+DEFAULT_LEVELS: Dict[str, int] = ...

django-stubs/contrib/messages/storage/base.pyi

@@ -16,7 +16,7 @@ class Message:
     def level_tag(self) -> str: ...
 
 class BaseStorage:
-    request: Any = ...
+    request: HttpRequest = ...
     used: bool = ...
     added_new: bool = ...
     def __init__(self, request: HttpRequest, *args: Any, **kwargs: Any) -> None: ...

django-stubs/contrib/messages/storage/cookie.pyi

@@ -1,49 +1,20 @@
 import json
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
-from django.contrib.messages.storage.base import BaseStorage, Message
+from django.contrib.messages.storage.base import BaseStorage
 
 class MessageEncoder(json.JSONEncoder):
     allow_nan: bool
     check_circular: bool
     ensure_ascii: bool
-    indent: None
-    item_separator: str
-    key_separator: str
     skipkeys: bool
     sort_keys: bool
     message_key: str = ...
-    def default(self, obj: Message) -> List[Union[int, str]]: ...
 
 class MessageDecoder(json.JSONDecoder):
-    def process_messages(
-        self,
-        obj: Union[
-            Dict[
-                str, Union[List[Union[Dict[str, List[Union[int, str]]], List[Union[int, str]]]], List[Union[int, str]]]
-            ],
-            List[Union[List[Union[int, str]], str]],
-            str,
-        ],
-    ) -> Union[
-        Dict[str, Union[List[Union[Dict[str, Message], Message]], Message]],
-        List[Union[Dict[str, Union[List[Union[Dict[str, Message], Message]], Message]], Message]],
-        List[Union[Message, str]],
-        Message,
-        str,
-    ]: ...
-    def decode(
-        self, s: str, **kwargs: Any
-    ) -> Union[
-        List[Union[Dict[str, Union[List[Union[Dict[str, Message], Message]], Message]], Message]],
-        List[Union[Message, str]],
-        Message,
-    ]: ...
+    def process_messages(self, obj: Any) -> Any: ...
 
 class CookieStorage(BaseStorage):
-    added_new: bool
-    request: WSGIRequest
-    used: bool
     cookie_name: str = ...
     max_cookie_size: int = ...
     not_finished: str = ...

django-stubs/contrib/messages/storage/fallback.pyi

@@ -1,11 +1,8 @@
-from typing import Any, Optional
+from typing import Any
 
 from django.contrib.messages.storage.base import BaseStorage
 
 class FallbackStorage(BaseStorage):
-    added_new: bool
-    request: WSGIRequest
-    used: bool
     storage_classes: Any = ...
     storages: Any = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...

django-stubs/contrib/messages/storage/session.pyi

@@ -1,15 +1,10 @@
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional, Sequence, Union
 
-from django.contrib.messages.storage.base import BaseStorage, Message
+from django.contrib.messages.storage.base import BaseStorage
 from django.http.request import HttpRequest
 
 class SessionStorage(BaseStorage):
-    added_new: bool
-    request: WSGIRequest
-    used: bool
     session_key: str = ...
     def __init__(self, request: HttpRequest, *args: Any, **kwargs: Any) -> None: ...
-    def serialize_messages(self, messages: Union[List[Message], List[str]]) -> str: ...
-    def deserialize_messages(
-        self, data: Optional[Union[List[Any], str]]
-    ) -> Optional[Union[List[Message], List[str]]]: ...
+    def serialize_messages(self, messages: Sequence[Any]) -> str: ...
+    def deserialize_messages(self, data: Optional[Union[List[Any], str]]) -> Optional[List[Any]]: ...

django-stubs/contrib/sessions/backends/base.pyi

@@ -1,8 +1,6 @@
 from datetime import datetime
 from typing import Any, Dict, Optional, Union
 
-from django.db.models.base import Model
-
 VALID_KEY_CHARS: Any
 
 class CreateError(Exception): ...
@@ -18,8 +16,8 @@ class SessionBase(Dict[str, Any]):
     def set_test_cookie(self) -> None: ...
     def test_cookie_worked(self) -> bool: ...
     def delete_test_cookie(self) -> None: ...
-    def encode(self, session_dict: Dict[str, Model]) -> str: ...
-    def decode(self, session_data: Union[bytes, str]) -> Dict[str, Model]: ...
+    def encode(self, session_dict: Dict[str, Any]) -> str: ...
+    def decode(self, session_data: Union[bytes, str]) -> Dict[str, Any]: ...
     def has_key(self, key: Any): ...
     def keys(self): ...
     def values(self): ...
@@ -33,7 +31,7 @@ class SessionBase(Dict[str, Any]):
     def get_expire_at_browser_close(self) -> bool: ...
     def flush(self) -> None: ...
     def cycle_key(self) -> None: ...
-    def exists(self, session_key: str) -> None: ...
+    def exists(self, session_key: str) -> bool: ...
     def create(self) -> None: ...
     def save(self, must_create: bool = ...) -> None: ...
     def delete(self, session_key: Optional[Any] = ...) -> None: ...

django-stubs/contrib/sessions/backends/cache.pyi

@@ -1,23 +1,11 @@
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from django.contrib.sessions.backends.base import SessionBase
 
-from django.contrib.sessions.serializers import JSONSerializer
-
 KEY_PREFIX: str
 
 class SessionStore(SessionBase):
-    accessed: bool
-    serializer: JSONSerializer
     cache_key_prefix: Any = ...
     def __init__(self, session_key: Optional[str] = ...) -> None: ...
     @property
     def cache_key(self) -> str: ...
-    def load(self) -> Dict[str, str]: ...
-    modified: bool = ...
-    def create(self) -> None: ...
-    def save(self, must_create: bool = ...) -> None: ...
-    def exists(self, session_key: Optional[str]) -> bool: ...
-    def delete(self, session_key: Optional[str] = ...) -> None: ...
-    @classmethod
-    def clear_expired(cls) -> None: ...

django-stubs/contrib/sessions/backends/cached_db.pyi

@@ -1,19 +1,11 @@
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from django.contrib.sessions.backends.db import SessionStore as DBStore
 
 KEY_PREFIX: str
 
 class SessionStore(DBStore):
-    accessed: bool
-    modified: bool
-    serializer: Type[django.core.signing.JSONSerializer]
     cache_key_prefix: Any = ...
     def __init__(self, session_key: Optional[str] = ...) -> None: ...
     @property
     def cache_key(self) -> str: ...
-    def load(self) -> Dict[str, str]: ...
-    def exists(self, session_key: Optional[str]) -> bool: ...
-    def save(self, must_create: bool = ...) -> None: ...
-    def delete(self, session_key: Optional[str] = ...) -> None: ...
-    def flush(self) -> None: ...

django-stubs/contrib/sessions/backends/db.pyi

@@ -1,24 +1,13 @@
-from typing import Dict, Optional, Type, Union
+from typing import Dict, Optional, Type
 
 from django.contrib.sessions.backends.base import SessionBase
 from django.contrib.sessions.base_session import AbstractBaseSession
 from django.contrib.sessions.models import Session
-from django.core.signing import Serializer
 from django.db.models.base import Model
 
 class SessionStore(SessionBase):
-    accessed: bool
-    serializer: Type[Serializer]
     def __init__(self, session_key: Optional[str] = ...) -> None: ...
     @classmethod
     def get_model_class(cls) -> Type[Session]: ...
     def model(self) -> Type[AbstractBaseSession]: ...
-    def load(self) -> Dict[str, Union[Model, int, str]]: ...
-    def exists(self, session_key: Optional[str]) -> bool: ...
-    modified: bool = ...
-    def create(self) -> None: ...
     def create_model_instance(self, data: Dict[str, Model]) -> AbstractBaseSession: ...
-    def save(self, must_create: bool = ...) -> None: ...
-    def delete(self, session_key: Optional[str] = ...) -> None: ...
-    @classmethod
-    def clear_expired(cls) -> None: ...

django-stubs/contrib/sessions/backends/file.pyi

@@ -1,19 +1,9 @@
-from typing import Any, Dict, Optional, Union
+from typing import Optional
 
 from django.contrib.sessions.backends.base import SessionBase
 
 class SessionStore(SessionBase):
-    accessed: bool
-    serializer: Type[django.core.signing.JSONSerializer]
     storage_path: str = ...
     file_prefix: str = ...
     def __init__(self, session_key: Optional[str] = ...) -> None: ...
-    def load(self) -> Dict[str, Union[int, str]]: ...
-    modified: bool = ...
-    def create(self) -> None: ...
-    def save(self, must_create: bool = ...) -> None: ...
-    def exists(self, session_key: Optional[str]) -> bool: ...
-    def delete(self, session_key: Optional[str] = ...) -> None: ...
     def clean(self) -> None: ...
-    @classmethod
-    def clear_expired(cls) -> None: ...

django-stubs/contrib/sessions/backends/signed_cookies.pyi

@@ -1,17 +1,3 @@
-from datetime import datetime
-from typing import Any, Dict, Optional, Union
-
 from django.contrib.sessions.backends.base import SessionBase
 
-class SessionStore(SessionBase):
-    accessed: bool
-    serializer: Type[django.core.signing.JSONSerializer]
-    def load(self) -> Dict[str, Union[datetime, str]]: ...
-    modified: bool = ...
-    def create(self) -> None: ...
-    def save(self, must_create: bool = ...) -> None: ...
-    def exists(self, session_key: Optional[str] = ...) -> bool: ...
-    def delete(self, session_key: Optional[str] = ...) -> None: ...
-    def cycle_key(self) -> None: ...
-    @classmethod
-    def clear_expired(cls) -> None: ...
+class SessionStore(SessionBase): ...

django-stubs/contrib/sessions/management/commands/clearsessions.pyi

@@ -1,10 +1,3 @@
-from typing import Any, Optional
-
 from django.core.management.base import BaseCommand
 
-class Command(BaseCommand):
-    stderr: django.core.management.base.OutputWrapper
-    stdout: django.core.management.base.OutputWrapper
-    style: django.core.management.color.Style
-    help: str = ...
-    def handle(self, **options: Any) -> None: ...
+class Command(BaseCommand): ...

django-stubs/contrib/sitemaps/__init__.pyi

@@ -15,7 +15,7 @@ def ping_google(sitemap_url: Optional[str] = ..., ping_url: str = ...) -> None:
 
 class Sitemap:
     limit: int = ...
-    protocol: Any = ...
+    protocol: Optional[str] = ...
     def items(self) -> List[Any]: ...
     def location(self, obj: Model) -> str: ...
     @property
@@ -29,7 +29,6 @@ class GenericSitemap(Sitemap):
     changefreq: Optional[str] = ...
     queryset: QuerySet = ...
     date_field: None = ...
-    protocol: Optional[str] = ...
     def __init__(
         self,
         info_dict: Dict[str, Union[datetime, QuerySet, str]],
@@ -37,7 +36,6 @@ class GenericSitemap(Sitemap):
         changefreq: Optional[str] = ...,
         protocol: Optional[str] = ...,
     ) -> None: ...
-    def items(self) -> QuerySet: ...
     def lastmod(self, item: Model) -> Optional[datetime]: ...
 
 default_app_config: str

django-stubs/contrib/sites/apps.pyi

@@ -1,14 +1,3 @@
-from typing import Any
-
 from django.apps import AppConfig
 
-class SitesConfig(AppConfig):
-    apps: None
-    label: str
-    models: None
-    models_module: None
-    module: Any
-    path: str
-    name: str = ...
-    verbose_name: Any = ...
-    def ready(self) -> None: ...
+class SitesConfig(AppConfig): ...

django-stubs/contrib/staticfiles/apps.pyi

@@ -1,15 +1,6 @@
-from typing import Any, Optional
+from typing import Any
 
 from django.apps import AppConfig
 
 class StaticFilesConfig(AppConfig):
-    apps: None
-    label: str
-    models: None
-    models_module: None
-    module: Any
-    path: str
-    name: str = ...
-    verbose_name: Any = ...
     ignore_patterns: Any = ...
-    def ready(self) -> None: ...

django-stubs/contrib/staticfiles/finders.pyi

@@ -1,25 +1,21 @@
-from typing import Any, Iterator, List, Optional, Tuple, Union, Mapping, overload
+from typing import Any, Iterable, Iterator, List, Mapping, Optional, Union, overload
 
-from django.contrib.staticfiles.storage import StaticFilesStorage
 from django.core.checks.messages import Error
-from django.core.files.storage import DefaultStorage, FileSystemStorage, Storage
+from django.core.files.storage import Storage
 from typing_extensions import Literal
 
 searched_locations: Any
 
 class BaseFinder:
-    def check(self, **kwargs: Any) -> Any: ...
-    def find(self, path: Any, all: bool = ...) -> None: ...
-    def list(self, ignore_patterns: Any) -> None: ...
+    def check(self, **kwargs: Any) -> List[Error]: ...
+    def find(self, path: str, all: bool = ...) -> Optional[Any]: ...
+    def list(self, ignore_patterns: Any) -> Iterable[Any]: ...
 
 class FileSystemFinder(BaseFinder):
     locations: List[Any] = ...
     storages: Mapping[str, Any] = ...
     def __init__(self, app_names: None = ..., *args: Any, **kwargs: Any) -> None: ...
-    def check(self, **kwargs: Any) -> List[Error]: ...
-    def find(self, path: str, all: bool = ...) -> Union[List[str], str]: ...
     def find_location(self, root: str, path: str, prefix: str = ...) -> Optional[str]: ...
-    def list(self, ignore_patterns: List[str]) -> Iterator[Tuple[str, FileSystemStorage]]: ...
 
 class AppDirectoriesFinder(BaseFinder):
     storage_class: Any = ...
@@ -27,15 +23,11 @@ class AppDirectoriesFinder(BaseFinder):
     apps: List[str] = ...
     storages: Mapping[str, Any] = ...
     def __init__(self, app_names: None = ..., *args: Any, **kwargs: Any) -> None: ...
-    def list(self, ignore_patterns: List[str]) -> Iterator[Tuple[str, FileSystemStorage]]: ...
-    def find(self, path: str, all: bool = ...) -> Union[List[str], str]: ...
     def find_in_app(self, app: str, path: str) -> Optional[str]: ...
 
 class BaseStorageFinder(BaseFinder):
     storage: Storage = ...
     def __init__(self, storage: Optional[Storage] = ..., *args: Any, **kwargs: Any) -> None: ...
-    def find(self, path: str, all: bool = ...) -> Union[List[str], str]: ...
-    def list(self, ignore_patterns: List[str]) -> Iterator[Tuple[str, DefaultStorage]]: ...
 
 class DefaultStorageFinder(BaseStorageFinder): ...
 

django-stubs/contrib/staticfiles/handlers.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from django.core.handlers.wsgi import WSGIHandler, WSGIRequest
 
@@ -7,9 +7,6 @@ class StaticFilesHandler(WSGIHandler):
     application: WSGIHandler = ...
     base_url: Any = ...
     def __init__(self, application: WSGIHandler) -> None: ...
-    def load_middleware(self) -> None: ...
     def get_base_url(self) -> str: ...
     def file_path(self, url: str) -> str: ...
     def serve(self, request: WSGIRequest) -> Any: ...
-    def get_response(self, request: WSGIRequest) -> Any: ...
-    def __call__(self, environ: Any, start_response: Any): ...

django-stubs/contrib/staticfiles/management/commands/collectstatic.pyi

@@ -1,22 +1,16 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 from django.core.files.storage import FileSystemStorage
-from django.core.management.base import BaseCommand, CommandParser
+from django.core.management.base import BaseCommand
 
 class Command(BaseCommand):
-    stderr: django.core.management.base.OutputWrapper
-    stdout: django.core.management.base.OutputWrapper
-    help: str = ...
-    requires_system_checks: bool = ...
     copied_files: Any = ...
     symlinked_files: Any = ...
     unmodified_files: Any = ...
     post_processed_files: Any = ...
     storage: Any = ...
-    style: django.core.management.color.Style = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def local(self) -> bool: ...
-    def add_arguments(self, parser: CommandParser) -> None: ...
     interactive: Any = ...
     verbosity: Any = ...
     symlink: Any = ...
@@ -26,7 +20,6 @@ class Command(BaseCommand):
     post_process: Any = ...
     def set_options(self, **options: Any) -> None: ...
     def collect(self) -> Dict[str, List[str]]: ...
-    def handle(self, **options: Any) -> Optional[str]: ...
     def log(self, msg: str, level: int = ...) -> None: ...
     def is_local_storage(self) -> bool: ...
     def clear_dir(self, path: str) -> None: ...

django-stubs/contrib/staticfiles/management/commands/findstatic.pyi

@@ -1,12 +1,3 @@
-from typing import Any, Optional
+from django.core.management.base import LabelCommand
 
-from django.core.management.base import CommandParser, LabelCommand
-
-class Command(LabelCommand):
-    stderr: django.core.management.base.OutputWrapper
-    stdout: django.core.management.base.OutputWrapper
-    style: django.core.management.color.Style
-    help: str = ...
-    label: str = ...
-    def add_arguments(self, parser: CommandParser) -> None: ...
-    def handle_label(self, path: str, **options: Any) -> str: ...
+class Command(LabelCommand): ...

django-stubs/contrib/staticfiles/management/commands/runserver.pyi

@@ -1,13 +1,3 @@
-from typing import Any, Optional
+from django.core.management.commands.runserver import Command as RunserverCommand  # type: ignore
 
-from django.contrib.staticfiles.handlers import StaticFilesHandler
-from django.core.management.base import CommandParser
-from django.core.management.commands.runserver import Command as RunserverCommand
-
-class Command(RunserverCommand):
-    stderr: django.core.management.base.OutputWrapper
-    stdout: django.core.management.base.OutputWrapper
-    style: django.core.management.color.Style
-    help: str = ...
-    def add_arguments(self, parser: CommandParser) -> None: ...
-    def get_handler(self, *args: Any, **options: Any) -> StaticFilesHandler: ...
+class Command(RunserverCommand): ...

django-stubs/contrib/staticfiles/storage.pyi

@@ -20,7 +20,6 @@ class HashedFilesMixin:
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def file_hash(self, name: str, content: File = ...) -> str: ...
     def hashed_name(self, name: str, content: Optional[File] = ..., filename: Optional[str] = ...) -> str: ...
-    def url(self, name: SafeText, force: bool = ...) -> str: ...
     def url_converter(self, name: str, hashed_files: OrderedDict, template: str = ...) -> Callable: ...
     def post_process(
         self, paths: OrderedDict, dry_run: bool = ..., **options: Any
@@ -33,16 +32,13 @@ class ManifestFilesMixin(HashedFilesMixin):
     manifest_version: str = ...
     manifest_name: str = ...
     manifest_strict: bool = ...
-    hashed_files: Any = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def read_manifest(self) -> Any: ...
     def load_manifest(self) -> OrderedDict: ...
-    def post_process(self, *args: Any, **kwargs: Any) -> None: ...
     def save_manifest(self) -> None: ...
-    def stored_name(self, name: str) -> str: ...
 
 class _MappingCache:
-    cache: django.core.cache.DefaultCacheProxy = ...
+    cache: Any = ...
     def __init__(self, cache: Any) -> None: ...
     def __setitem__(self, key: Any, value: Any) -> None: ...
     def __getitem__(self, key: Any): ...
@@ -51,9 +47,7 @@ class _MappingCache:
     def get(self, key: Any, default: Optional[Any] = ...): ...
 
 class CachedFilesMixin(HashedFilesMixin):
-    hashed_files: Any = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    def hash_key(self, name: str) -> str: ...
 
 class CachedStaticFilesStorage(CachedFilesMixin, StaticFilesStorage): ...
 class ManifestStaticFilesStorage(ManifestFilesMixin, StaticFilesStorage): ...

django-stubs/core/cache/backends/base.pyi

@@ -1,5 +1,4 @@
-from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union
 
 from django.core.exceptions import ImproperlyConfigured
 
@@ -9,7 +8,7 @@ class CacheKeyWarning(RuntimeWarning): ...
 DEFAULT_TIMEOUT: Any
 MEMCACHE_MAX_KEY_LENGTH: int
 
-def default_key_func(key: Union[int, str], key_prefix: str, version: Union[int, str]) -> str: ...
+def default_key_func(key: Any, key_prefix: str, version: Any) -> str: ...
 def get_key_func(key_func: Optional[Union[Callable, str]]) -> Callable: ...
 
 class BaseCache:
@@ -17,9 +16,9 @@ class BaseCache:
     key_prefix: str = ...
     version: int = ...
     key_func: Callable = ...
-    def __init__(self, params: Dict[str, Optional[Union[Callable, Dict[str, int], int, str]]]) -> None: ...
+    def __init__(self, params: Dict[str, Any]) -> None: ...
     def get_backend_timeout(self, timeout: Any = ...) -> Optional[float]: ...
-    def make_key(self, key: Union[int, str], version: Optional[Union[int, str]] = ...) -> str: ...
+    def make_key(self, key: Any, version: Optional[Any] = ...) -> str: ...
     def add(self, key: Any, value: Any, timeout: Any = ..., version: Optional[Any] = ...) -> None: ...
     def get(self, key: Any, default: Optional[Any] = ..., version: Optional[Any] = ...) -> Any: ...
     def set(self, key: Any, value: Any, timeout: Any = ..., version: Optional[Any] = ...) -> None: ...
@@ -27,19 +26,14 @@ class BaseCache:
     def delete(self, key: Any, version: Optional[Any] = ...) -> None: ...
     def get_many(self, keys: List[str], version: Optional[int] = ...) -> Dict[str, Union[int, str]]: ...
     def get_or_set(
-        self, key: str, default: Optional[Union[Callable, int, str]], timeout: Any = ..., version: Optional[int] = ...
-    ) -> Optional[Union[int, str]]: ...
+        self, key: Any, default: Optional[Any], timeout: Any = ..., version: Optional[int] = ...
+    ) -> Optional[Any]: ...
     def has_key(self, key: Any, version: Optional[Any] = ...): ...
     def incr(self, key: str, delta: int = ..., version: Optional[int] = ...) -> int: ...
     def decr(self, key: str, delta: int = ..., version: Optional[int] = ...) -> int: ...
     def __contains__(self, key: str) -> bool: ...
-    def set_many(
-        self,
-        data: Union[Dict[str, bytes], Dict[str, int], Dict[str, str], OrderedDict],
-        timeout: Any = ...,
-        version: Optional[Union[int, str]] = ...,
-    ) -> List[Any]: ...
-    def delete_many(self, keys: Union[Dict[str, str], List[str]], version: None = ...) -> None: ...
+    def set_many(self, data: Dict[str, Any], timeout: Any = ..., version: Optional[Any] = ...) -> List[Any]: ...
+    def delete_many(self, keys: Iterable[Any], version: Optional[Any] = ...) -> None: ...
     def clear(self) -> None: ...
     def validate_key(self, key: str) -> None: ...
     def incr_version(self, key: str, delta: int = ..., version: Optional[int] = ...) -> int: ...

django-stubs/core/cache/backends/db.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Dict
 
 from django.core.cache.backends.base import BaseCache
 
@@ -16,24 +16,7 @@ class Options:
     def __init__(self, table: str) -> None: ...
 
 class BaseDatabaseCache(BaseCache):
-    default_timeout: int
-    key_func: Callable
-    key_prefix: str
-    version: int
     cache_model_class: Any = ...
-    def __init__(self, table: str, params: Dict[str, Union[Callable, Dict[str, int], int, str]]) -> None: ...
+    def __init__(self, table: str, params: Dict[str, Any]) -> None: ...
 
-class DatabaseCache(BaseDatabaseCache):
-    default_timeout: int
-    key_func: Callable
-    key_prefix: str
-    version: int
-    def get(self, key: str, default: Optional[Union[int, str]] = ..., version: Optional[int] = ...) -> Any: ...
-    def set(self, key: str, value: Any, timeout: Any = ..., version: Optional[int] = ...) -> None: ...
-    def add(
-        self, key: str, value: Union[Dict[str, int], bytes, int, str], timeout: Any = ..., version: Optional[int] = ...
-    ) -> bool: ...
-    def touch(self, key: str, timeout: Any = ..., version: None = ...) -> bool: ...
-    def delete(self, key: str, version: Optional[int] = ...) -> None: ...
-    def has_key(self, key: str, version: Optional[int] = ...) -> Any: ...
-    def clear(self) -> None: ...
+class DatabaseCache(BaseDatabaseCache): ...

django-stubs/core/cache/backends/dummy.pyi

@@ -1,19 +1,6 @@
-from typing import Any, Dict, Optional, Union, Callable
+from typing import Any
 
 from django.core.cache.backends.base import BaseCache
 
 class DummyCache(BaseCache):
-    default_timeout: int
-    key_func: Callable
-    key_prefix: str
-    version: int
     def __init__(self, host: str, *args: Any, **kwargs: Any) -> None: ...
-    def add(self, key: str, value: str, timeout: Any = ..., version: None = ...) -> bool: ...
-    def get(self, key: str, default: Optional[str] = ..., version: Optional[int] = ...) -> Optional[str]: ...
-    def set(
-        self, key: str, value: Union[Dict[str, Any], int, str], timeout: Any = ..., version: Optional[str] = ...
-    ) -> None: ...
-    def touch(self, key: str, timeout: Any = ..., version: None = ...) -> bool: ...
-    def delete(self, key: str, version: None = ...) -> None: ...
-    def has_key(self, key: str, version: None = ...) -> bool: ...
-    def clear(self) -> None: ...

django-stubs/core/cache/backends/filebased.pyi

@@ -1,22 +1,7 @@
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Dict
 
 from django.core.cache.backends.base import BaseCache
 
 class FileBasedCache(BaseCache):
-    default_timeout: int
-    key_func: Callable
-    key_prefix: str
-    version: int
     cache_suffix: str = ...
-    def __init__(self, dir: str, params: Dict[str, Union[Callable, Dict[str, int], int, str]]) -> None: ...
-    def add(
-        self, key: str, value: Union[Dict[str, int], bytes, int, str], timeout: Any = ..., version: Optional[int] = ...
-    ) -> bool: ...
-    def get(
-        self, key: str, default: Optional[Union[int, str]] = ..., version: Optional[int] = ...
-    ) -> Optional[str]: ...
-    def set(self, key: str, value: Any, timeout: Any = ..., version: Optional[int] = ...) -> None: ...
-    def touch(self, key: str, timeout: Any = ..., version: None = ...) -> bool: ...
-    def delete(self, key: str, version: Optional[int] = ...) -> None: ...
-    def has_key(self, key: str, version: Optional[int] = ...) -> bool: ...
-    def clear(self) -> None: ...
+    def __init__(self, dir: str, params: Dict[str, Any]) -> None: ...

django-stubs/core/files/locks.pyi

@@ -1,17 +1,15 @@
-from ctypes import Structure, c_int64, c_ulong, c_void_p
-from io import BufferedRandom, TextIOWrapper
-from typing import Union
+from ctypes import Structure, Union
+from typing import Any
 
 LOCK_SH: int
 LOCK_NB: int
 LOCK_EX: int
-ULONG_PTR = c_int64
-ULONG_PTR = c_ulong
-PVOID = c_void_p
+ULONG_PTR: Any = ...
+PVOID: Any = ...
 
 class _OFFSET(Structure): ...
 class _OFFSET_UNION(Union): ...
 class OVERLAPPED(Structure): ...
 
-def lock(f: Union[BufferedRandom, TextIOWrapper, int], flags: int) -> bool: ...
-def unlock(f: Union[BufferedRandom, int]) -> bool: ...
+def lock(f: Any, flags: int) -> bool: ...
+def unlock(f: Any) -> bool: ...

django-stubs/core/mail/__init__.pyi

@@ -1,6 +1,5 @@
 from typing import Any, List, Optional, Tuple
 
-from .backends.base import BaseEmailBackend
 from .message import (
     BadHeaderError as BadHeaderError,
     DEFAULT_ATTACHMENT_MIME_TYPE as DEFAULT_ATTACHMENT_MIME_TYPE,
@@ -12,7 +11,7 @@ from .message import (
 )
 from .utils import CachedDnsName as CachedDnsName, DNS_NAME as DNS_NAME
 
-def get_connection(backend: Optional[str] = ..., fail_silently: bool = ..., **kwds: Any) -> BaseEmailBackend: ...
+def get_connection(backend: Optional[str] = ..., fail_silently: bool = ..., **kwds: Any) -> Any: ...
 def send_mail(
     subject: str,
     message: str,
@@ -21,7 +20,7 @@ def send_mail(
     fail_silently: bool = ...,
     auth_user: Optional[str] = ...,
     auth_password: Optional[str] = ...,
-    connection: Optional[BaseEmailBackend] = ...,
+    connection: Optional[Any] = ...,
     html_message: Optional[str] = ...,
 ) -> int: ...
 def send_mass_mail(
@@ -29,20 +28,20 @@ def send_mass_mail(
     fail_silently: bool = ...,
     auth_user: Optional[str] = ...,
     auth_password: Optional[str] = ...,
-    connection: Optional[BaseEmailBackend] = ...,
+    connection: Optional[Any] = ...,
 ) -> int: ...
 def mail_admins(
     subject: str,
     message: str,
     fail_silently: bool = ...,
-    connection: Optional[BaseEmailBackend] = ...,
+    connection: Optional[Any] = ...,
     html_message: Optional[str] = ...,
 ) -> None: ...
 def mail_managers(
     subject: str,
     message: str,
     fail_silently: bool = ...,
-    connection: Optional[BaseEmailBackend] = ...,
+    connection: Optional[Any] = ...,
     html_message: Optional[str] = ...,
 ) -> None: ...
 

django-stubs/core/mail/message.pyi

@@ -1,11 +1,8 @@
-from email._policybase import Policy
+from email._policybase import Policy  # type: ignore
 from email.mime.message import MIMEMessage
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
-from typing import Any, Dict, List, Optional, Tuple, Union, Sequence
-
-from django.core.mail.backends.base import BaseEmailBackend
-from django.utils.safestring import SafeText
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 utf8_charset: Any
 utf8_charset_qp: Any
@@ -20,16 +17,13 @@ def forbid_multi_line_headers(name: str, val: str, encoding: str) -> Tuple[str,
 def split_addr(addr: str, encoding: str) -> Tuple[str, str]: ...
 def sanitize_address(addr: Union[Tuple[str, str], str], encoding: str) -> str: ...
 
-class MIMEMixin:
-    def as_string(self, unixfrom: bool = ..., linesep: str = ...) -> str: ...
-    def as_bytes(self, unixfrom: bool = ..., linesep: str = ...) -> bytes: ...
+class MIMEMixin: ...
 
 class SafeMIMEMessage(MIMEMixin, MIMEMessage):
     defects: List[Any]
     epilogue: None
     policy: Policy
     preamble: None
-    def __setitem__(self, name: str, val: str) -> None: ...
 
 class SafeMIMEText(MIMEMixin, MIMEText):
     defects: List[Any]
@@ -38,8 +32,6 @@ class SafeMIMEText(MIMEMixin, MIMEText):
     preamble: None
     encoding: str = ...
     def __init__(self, _text: str, _subtype: str = ..., _charset: str = ...) -> None: ...
-    def __setitem__(self, name: str, val: str) -> None: ...
-    def set_payload(self, payload: str, charset: str = ...) -> None: ...
 
 class SafeMIMEMultipart(MIMEMixin, MIMEMultipart):
     defects: List[Any]
@@ -50,7 +42,6 @@ class SafeMIMEMultipart(MIMEMixin, MIMEMultipart):
     def __init__(
         self, _subtype: str = ..., boundary: None = ..., _subparts: None = ..., encoding: str = ..., **_params: Any
     ) -> None: ...
-    def __setitem__(self, name: str, val: str) -> None: ...
 
 class EmailMessage:
     content_subtype: str = ...
@@ -65,7 +56,7 @@ class EmailMessage:
     body: str = ...
     attachments: List[Any] = ...
     extra_headers: Dict[Any, Any] = ...
-    connection: None = ...
+    connection: Any = ...
     def __init__(
         self,
         subject: str = ...,
@@ -73,13 +64,13 @@ class EmailMessage:
         from_email: Optional[str] = ...,
         to: Optional[Union[Sequence[str], str]] = ...,
         bcc: Optional[Union[Sequence[str], str]] = ...,
-        connection: Optional[BaseEmailBackend] = ...,
+        connection: Optional[Any] = ...,
         attachments: Optional[Union[List[Tuple[str, str]], List[MIMEText]]] = ...,
         headers: Optional[Dict[str, str]] = ...,
         cc: Optional[Union[Sequence[str], str]] = ...,
         reply_to: Optional[Union[List[Optional[str]], str]] = ...,
     ) -> None: ...
-    def get_connection(self, fail_silently: bool = ...) -> BaseEmailBackend: ...
+    def get_connection(self, fail_silently: bool = ...) -> Any: ...
     def message(self) -> MIMEMixin: ...
     def recipients(self) -> List[str]: ...
     def send(self, fail_silently: bool = ...) -> int: ...
@@ -92,16 +83,6 @@ class EmailMessage:
     def attach_file(self, path: str, mimetype: Optional[str] = ...) -> None: ...
 
 class EmailMultiAlternatives(EmailMessage):
-    attachments: List[Any]
-    bcc: List[Any]
-    body: SafeText
-    cc: List[Any]
-    connection: None
-    extra_headers: Dict[Any, Any]
-    from_email: str
-    reply_to: List[Any]
-    subject: str
-    to: List[str]
     alternative_subtype: str = ...
     alternatives: Any = ...
     def __init__(
@@ -111,7 +92,7 @@ class EmailMultiAlternatives(EmailMessage):
         from_email: Optional[str] = ...,
         to: Optional[List[str]] = ...,
         bcc: Optional[List[str]] = ...,
-        connection: Optional[BaseEmailBackend] = ...,
+        connection: Optional[Any] = ...,
         attachments: None = ...,
         headers: Optional[Dict[str, str]] = ...,
         alternatives: Optional[List[Tuple[str, str]]] = ...,

django-stubs/core/management/templates.pyi

@@ -1,16 +1,13 @@
-from typing import Any, Optional
+from typing import Any
 
-from django.core.management.base import BaseCommand, CommandParser
+from django.core.management.base import BaseCommand
 
 class TemplateCommand(BaseCommand):
-    requires_system_checks: bool = ...
     url_schemes: Any = ...
     rewrite_template_suffixes: Any = ...
-    def add_arguments(self, parser: CommandParser) -> None: ...
     app_or_project: Any = ...
     paths_to_remove: Any = ...
     verbosity: Any = ...
-    def handle(self, app_or_project: Any, name: Any, target: Optional[Any] = ..., **options: Any): ...
     def handle_template(self, template: Any, subdir: Any): ...
     def validate_name(self, name: Any, app_or_project: Any) -> None: ...
     def download(self, url: Any): ...

django-stubs/core/serializers/__init__.pyi

@@ -1,5 +1,4 @@
-from collections import OrderedDict
-from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Type, Union
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Type, Union, Iterable
 
 from django.apps.config import AppConfig
 from django.db.models.base import Model
@@ -33,5 +32,5 @@ def serialize(
 ) -> Optional[Union[bytes, str]]: ...
 def deserialize(format: str, stream_or_string: Any, **options: Any) -> Union[Iterator[Any], Deserializer]: ...
 def sort_dependencies(
-    app_list: Union[List[Tuple[AppConfig, None]], List[Tuple[str, List[Type[Model]]]]]
+    app_list: Union[Iterable[Tuple[AppConfig, None]], Iterable[Tuple[str, Iterable[Type[Model]]]]]
 ) -> List[Type[Model]]: ...

django-stubs/core/validators.pyi

@@ -1,7 +1,7 @@
 from datetime import datetime
 from decimal import Decimal
 from re import RegexFlag
-from typing import Any, Dict, List, Optional, Union, Pattern
+from typing import Any, Dict, List, Optional, Union, Pattern, Collection
 from uuid import UUID
 
 from django.core.files.base import File
@@ -38,7 +38,7 @@ class URLValidator(RegexValidator):
     tld_re: Any = ...
     host_re: Any = ...
     schemes: Any = ...
-    def __init__(self, schemes: Optional[List[str]] = ..., **kwargs: Any) -> None: ...
+    def __init__(self, schemes: Optional[Collection[str]] = ..., **kwargs: Any) -> None: ...
 
 integer_validator: Any
 
@@ -52,7 +52,7 @@ class EmailValidator:
     literal_regex: Any = ...
     domain_whitelist: Any = ...
     def __init__(
-        self, message: Optional[str] = ..., code: Optional[str] = ..., whitelist: Optional[List[str]] = ...
+        self, message: Optional[str] = ..., code: Optional[str] = ..., whitelist: Optional[Collection[str]] = ...
     ) -> None: ...
     def __call__(self, value: Optional[str]) -> None: ...
     def validate_domain_part(self, domain_part: str) -> bool: ...
@@ -119,7 +119,10 @@ class FileExtensionValidator:
     code: str = ...
     allowed_extensions: List[str] = ...
     def __init__(
-        self, allowed_extensions: Optional[List[str]] = ..., message: Optional[str] = ..., code: Optional[str] = ...
+        self,
+        allowed_extensions: Optional[Collection[str]] = ...,
+        message: Optional[str] = ...,
+        code: Optional[str] = ...,
     ) -> None: ...
     def __call__(self, value: File) -> None: ...
 

django-stubs/db/backends/base/base.pyi

@@ -1,9 +1,16 @@
 from typing import Any, Callable, Dict, Iterator, List, Optional
 
+from django.db.backends.base.client import BaseDatabaseClient
+from django.db.backends.base.creation import BaseDatabaseCreation
+from django.db.backends.base.validation import BaseDatabaseValidation
 from django.db.backends.utils import CursorDebugWrapper, CursorWrapper
 
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
 
+from django.db.backends.base.features import BaseDatabaseFeatures
+
+from django.db.backends.base.introspection import BaseDatabaseIntrospection
+
 NO_DB_ALIAS: str
 
 class BaseDatabaseWrapper:
@@ -23,7 +30,7 @@ class BaseDatabaseWrapper:
     queries_limit: int = ...
     connection: Any = ...
     settings_dict: Any = ...
-    alias: Any = ...
+    alias: str = ...
     queries_log: Any = ...
     force_debug_cursor: bool = ...
     autocommit: bool = ...
@@ -32,18 +39,18 @@ class BaseDatabaseWrapper:
     savepoint_ids: Any = ...
     commit_on_exit: bool = ...
     needs_rollback: bool = ...
-    close_at: Any = ...
+    close_at: Optional[Any] = ...
     closed_in_transaction: bool = ...
     errors_occurred: bool = ...
-    allow_thread_sharing: Any = ...
-    run_on_commit: Any = ...
+    allow_thread_sharing: bool = ...
+    run_on_commit: List[Any] = ...
     run_commit_hooks_on_set_autocommit_on: bool = ...
-    execute_wrappers: Any = ...
-    client: Any = ...
-    creation: Any = ...
-    features: Any = ...
-    introspection: Any = ...
-    validation: Any = ...
+    execute_wrappers: List[Any] = ...
+    client: BaseDatabaseClient = ...
+    creation: BaseDatabaseCreation = ...
+    features: BaseDatabaseFeatures = ...
+    introspection: BaseDatabaseIntrospection = ...
+    validation: BaseDatabaseValidation = ...
     def __init__(
         self, settings_dict: Dict[str, Dict[str, str]], alias: str = ..., allow_thread_sharing: bool = ...
     ) -> None: ...

django-stubs/db/backends/base/schema.pyi

@@ -1,13 +1,14 @@
-from typing import Any, List, Optional, Tuple, Type, Union
+from typing import Any, ContextManager, List, Optional, Sequence, Tuple, Type, Union
 
 from django.db.backends.ddl_references import Statement
 from django.db.models.base import Model
-from django.db.models.fields import Field
 from django.db.models.indexes import Index
 
+from django.db.models.fields import Field
+
 logger: Any
 
-class BaseDatabaseSchemaEditor:
+class BaseDatabaseSchemaEditor(ContextManager[Any]):
     sql_create_table: str = ...
     sql_rename_table: str = ...
     sql_retablespace_table: str = ...
@@ -27,7 +28,7 @@ class BaseDatabaseSchemaEditor:
     sql_create_unique: str = ...
     sql_delete_unique: str = ...
     sql_create_fk: str = ...
-    sql_create_inline_fk: Any = ...
+    sql_create_inline_fk: str = ...
     sql_delete_fk: str = ...
     sql_create_index: str = ...
     sql_delete_index: str = ...
@@ -35,14 +36,14 @@ class BaseDatabaseSchemaEditor:
     sql_delete_pk: str = ...
     sql_delete_procedure: str = ...
     connection: Any = ...
-    collect_sql: Any = ...
+    collect_sql: bool = ...
     collected_sql: Any = ...
     atomic_migration: Any = ...
     def __init__(self, connection: Any, collect_sql: bool = ..., atomic: bool = ...) -> None: ...
     deferred_sql: Any = ...
     atomic: Any = ...
     def __enter__(self) -> BaseDatabaseSchemaEditor: ...
-    def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None: ...
     def execute(self, sql: Union[Statement, str], params: Optional[Union[List[int], Tuple]] = ...) -> None: ...
     def quote_name(self, name: str) -> str: ...
     def column_sql(
@@ -59,14 +60,14 @@ class BaseDatabaseSchemaEditor:
     def alter_unique_together(
         self,
         model: Type[Model],
-        old_unique_together: Union[List[List[str]], Tuple[Tuple[str, str]]],
-        new_unique_together: Union[List[List[str]], Tuple[Tuple[str, str]]],
+        old_unique_together: Sequence[Sequence[str]],
+        new_unique_together: Sequence[Sequence[str]],
     ) -> None: ...
     def alter_index_together(
         self,
         model: Type[Model],
-        old_index_together: Union[List[List[str]], List[Tuple[str, str]]],
-        new_index_together: Union[List[List[str]], List[Tuple[str, str]]],
+        old_index_together: Sequence[Sequence[str]],
+        new_index_together: Sequence[Sequence[str]],
     ) -> None: ...
     def alter_db_table(self, model: Type[Model], old_db_table: str, new_db_table: str) -> None: ...
     def alter_db_tablespace(self, model: Any, old_db_tablespace: Any, new_db_tablespace: Any) -> None: ...

django-stubs/db/backends/dummy/base.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.db.backends.base.client import BaseDatabaseClient
@@ -10,20 +10,16 @@ def complain(*args: Any, **kwargs: Any) -> Any: ...
 def ignore(*args: Any, **kwargs: Any) -> None: ...
 
 class DatabaseOperations(BaseDatabaseOperations):
-    connection: django.db.backends.dummy.base.DatabaseWrapper
     quote_name: Any = ...
 
 class DatabaseClient(BaseDatabaseClient):
-    connection: django.db.backends.dummy.base.DatabaseWrapper
     runshell: Any = ...
 
 class DatabaseCreation(BaseDatabaseCreation):
-    connection: django.db.backends.dummy.base.DatabaseWrapper
     create_test_db: Any = ...
     destroy_test_db: Any = ...
 
 class DatabaseIntrospection(BaseDatabaseIntrospection):
-    connection: django.db.backends.dummy.base.DatabaseWrapper
     get_table_list: Any = ...
     get_table_description: Any = ...
     get_relations: Any = ...
@@ -31,35 +27,5 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
     get_key_columns: Any = ...
 
 class DatabaseWrapper(BaseDatabaseWrapper):
-    alias: str
-    allow_thread_sharing: bool
-    autocommit: bool
-    client: django.db.backends.dummy.base.DatabaseClient
-    close_at: None
-    closed_in_transaction: bool
-    commit_on_exit: bool
-    connection: None
-    creation: django.db.backends.dummy.base.DatabaseCreation
-    errors_occurred: bool
-    execute_wrappers: List[Any]
-    features: django.db.backends.dummy.features.DummyDatabaseFeatures
-    force_debug_cursor: bool
-    in_atomic_block: bool
-    introspection: django.db.backends.dummy.base.DatabaseIntrospection
-    needs_rollback: bool
-    ops: django.db.backends.dummy.base.DatabaseOperations
-    queries_log: collections.deque
-    run_commit_hooks_on_set_autocommit_on: bool
-    run_on_commit: List[Any]
-    savepoint_ids: List[Any]
-    savepoint_state: int
-    settings_dict: Dict[str, Optional[Union[Dict[str, None], int, str]]]
-    validation: django.db.backends.base.validation.BaseDatabaseValidation
     operators: Any = ...
     ensure_connection: Any = ...
-    client_class: Any = ...
-    creation_class: Any = ...
-    features_class: Any = ...
-    introspection_class: Any = ...
-    ops_class: Any = ...
-    def is_usable(self): ...

django-stubs/db/backends/sqlite3/schema.pyi

@@ -1,25 +1,3 @@
-from typing import Any, Optional, Type, Union
-
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
-from django.db.models.base import Model
-from django.db.models.fields import Field
 
-class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
-    atomic_migration: bool
-    collect_sql: bool
-    connection: Any
-    sql_delete_table: str = ...
-    sql_create_fk: Any = ...
-    sql_create_inline_fk: str = ...
-    sql_create_unique: str = ...
-    sql_delete_unique: str = ...
-    def __enter__(self) -> DatabaseSchemaEditor: ...
-    def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
-    def quote_value(self, value: Optional[Union[int, str]]) -> str: ...
-    def alter_db_table(
-        self, model: Type[Model], old_db_table: str, new_db_table: str, disable_constraints: bool = ...
-    ) -> None: ...
-    def alter_field(self, model: Type[Model], old_field: Field, new_field: Field, strict: bool = ...) -> None: ...
-    def delete_model(self, model: Type[Model], handle_autom2m: bool = ...) -> None: ...
-    def add_field(self, model: Type[Model], field: Field) -> None: ...
-    def remove_field(self, model: Type[Model], field: Field) -> None: ...
+class DatabaseSchemaEditor(BaseDatabaseSchemaEditor): ...

django-stubs/db/migrations/loader.pyi

@@ -1,11 +1,8 @@
 from typing import Any, Dict, Optional, Sequence, Set, Tuple, Union
 
-from django.db.backends.base.base import BaseDatabaseWrapper
-from django.db.migrations.migration import Migration, SwappableTuple
+from django.db.migrations.migration import Migration
 from django.db.migrations.state import ProjectState
 
-from django.db import DefaultConnectionProxy
-
 MIGRATIONS_MODULE_NAME: str
 
 class MigrationLoader:
@@ -13,12 +10,7 @@ class MigrationLoader:
     disk_migrations: Dict[Tuple[str, str], Migration] = ...
     applied_migrations: None = ...
     ignore_no_migrations: bool = ...
-    def __init__(
-        self,
-        connection: Optional[Union[DefaultConnectionProxy, BaseDatabaseWrapper]],
-        load: bool = ...,
-        ignore_no_migrations: bool = ...,
-    ) -> None: ...
+    def __init__(self, connection: Any, load: bool = ..., ignore_no_migrations: bool = ...) -> None: ...
     @classmethod
     def migrations_module(cls, app_label: str) -> Tuple[Optional[str], bool]: ...
     unmigrated_apps: Set[str] = ...
@@ -26,7 +18,7 @@ class MigrationLoader:
     def load_disk(self) -> None: ...
     def get_migration(self, app_label: str, name_prefix: str) -> Migration: ...
     def get_migration_by_prefix(self, app_label: str, name_prefix: str) -> Migration: ...
-    def check_key(self, key: Union[Tuple[str, str], SwappableTuple], current_app: str) -> Optional[Tuple[str, str]]: ...
+    def check_key(self, key: Tuple[str, str], current_app: str) -> Optional[Tuple[str, str]]: ...
     def add_internal_dependencies(self, key: Tuple[str, str], migration: Migration) -> None: ...
     def add_external_dependencies(self, key: Tuple[str, str], migration: Migration) -> None: ...
     graph: Any = ...
@@ -35,5 +27,5 @@ class MigrationLoader:
     def check_consistent_history(self, connection: Any) -> None: ...
     def detect_conflicts(self) -> Dict[str, Set[str]]: ...
     def project_state(
-        self, nodes: Optional[Tuple[str, str], Sequence[Tuple[str, str]]] = ..., at_end: bool = ...
+        self, nodes: Optional[Union[Tuple[str, str], Sequence[Tuple[str, str]]]] = ..., at_end: bool = ...
     ) -> ProjectState: ...

django-stubs/db/migrations/migration.pyi

@@ -21,7 +21,7 @@ class Migration:
         self, project_state: ProjectState, schema_editor: BaseDatabaseSchemaEditor, collect_sql: bool = ...
     ) -> ProjectState: ...
 
-class SwappableTuple(tuple):
+class SwappableTuple(Tuple[str, str]):
     setting: str = ...
     def __new__(cls, value: Tuple[str, str], setting: str) -> SwappableTuple: ...
 

django-stubs/db/models/base.pyi

@@ -8,6 +8,7 @@ _Self = TypeVar("_Self", bound="Model")
 
 class Model(metaclass=ModelBase):
     class DoesNotExist(Exception): ...
+    class MultipleObjectsReturned(Exception): ...
     class Meta: ...
     _meta: Any
     _default_manager: Manager[Model]
@@ -15,6 +16,7 @@ class Model(metaclass=ModelBase):
     def __init__(self: _Self, *args, **kwargs) -> None: ...
     def delete(self, using: Any = ..., keep_parents: bool = ...) -> Tuple[int, Dict[str, int]]: ...
     def full_clean(self, exclude: Optional[List[str]] = ..., validate_unique: bool = ...) -> None: ...
+    def clean(self) -> None: ...
     def clean_fields(self, exclude: List[str] = ...) -> None: ...
     def validate_unique(self, exclude: List[str] = ...) -> None: ...
     def save(
@@ -34,6 +36,7 @@ class Model(metaclass=ModelBase):
     ): ...
     def refresh_from_db(self: _Self, using: Optional[str] = ..., fields: Optional[List[str]] = ...) -> _Self: ...
     def get_deferred_fields(self) -> Set[str]: ...
+    def __getstate__(self) -> dict: ...
 
 class ModelStateFieldsCacheDescriptor: ...
 

django-stubs/db/models/expressions.pyi

@@ -1,20 +1,18 @@
-from collections import OrderedDict
 from datetime import datetime, timedelta
-from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union, TypeVar
+from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union
 
 from django.db.models.lookups import Lookup
 from django.db.models.sql.compiler import SQLCompiler
 
 from django.db.models import Q, QuerySet
-from django.db.models.fields import Field, FloatField
-from django.db.models.sql import Query
+from django.db.models.fields import Field
 
 _OutputField = Union[Field, str]
 
 class SQLiteNumericMixin:
     def as_sqlite(self, compiler: SQLCompiler, connection: Any, **extra_context: Any) -> Tuple[str, List[float]]: ...
 
-_SelfCombinable = TypeVar("_SelfCombinable", bound="Combinable")
+_Self = TypeVar("_Self")
 
 class Combinable:
     ADD: str = ...
@@ -27,22 +25,20 @@ class Combinable:
     BITOR: str = ...
     BITLEFTSHIFT: str = ...
     BITRIGHTSHIFT: str = ...
-    def __neg__(self: _SelfCombinable) -> _SelfCombinable: ...
-    def __add__(
-        self: _SelfCombinable, other: Optional[Union[timedelta, Combinable, float, str]]
-    ) -> _SelfCombinable: ...
-    def __sub__(self: _SelfCombinable, other: Union[timedelta, Combinable, float]) -> _SelfCombinable: ...
-    def __mul__(self: _SelfCombinable, other: Union[timedelta, Combinable, float]) -> _SelfCombinable: ...
-    def __truediv__(self: _SelfCombinable, other: Union[Combinable, float]) -> _SelfCombinable: ...
-    def __itruediv__(self: _SelfCombinable, other: Union[Combinable, float]) -> _SelfCombinable: ...
-    def __mod__(self: _SelfCombinable, other: Union[int, Combinable]) -> _SelfCombinable: ...
-    def __pow__(self: _SelfCombinable, other: Union[float, Combinable]) -> _SelfCombinable: ...
-    def __and__(self: _SelfCombinable, other: Combinable) -> _SelfCombinable: ...
-    def bitand(self: _SelfCombinable, other: int) -> _SelfCombinable: ...
-    def bitleftshift(self: _SelfCombinable, other: int) -> _SelfCombinable: ...
-    def bitrightshift(self: _SelfCombinable, other: int) -> _SelfCombinable: ...
-    def __or__(self: _SelfCombinable, other: Combinable) -> _SelfCombinable: ...
-    def bitor(self: _SelfCombinable, other: int) -> _SelfCombinable: ...
+    def __neg__(self: _Self) -> _Self: ...
+    def __add__(self: _Self, other: Optional[Union[timedelta, Combinable, float, str]]) -> _Self: ...
+    def __sub__(self: _Self, other: Union[timedelta, Combinable, float]) -> _Self: ...
+    def __mul__(self: _Self, other: Union[timedelta, Combinable, float]) -> _Self: ...
+    def __truediv__(self: _Self, other: Union[Combinable, float]) -> _Self: ...
+    def __itruediv__(self: _Self, other: Union[Combinable, float]) -> _Self: ...
+    def __mod__(self: _Self, other: Union[int, Combinable]) -> _Self: ...
+    def __pow__(self: _Self, other: Union[float, Combinable]) -> _Self: ...
+    def __and__(self: _Self, other: Combinable) -> _Self: ...
+    def bitand(self: _Self, other: int) -> _Self: ...
+    def bitleftshift(self: _Self, other: int) -> _Self: ...
+    def bitrightshift(self: _Self, other: int) -> _Self: ...
+    def __or__(self: _Self, other: Combinable) -> _Self: ...
+    def bitor(self: _Self, other: int) -> _Self: ...
     def __radd__(self, other: Optional[Union[datetime, float, Combinable]]) -> Combinable: ...
     def __rsub__(self, other: Union[float, Combinable]) -> Combinable: ...
     def __rmul__(self, other: Union[float, Combinable]) -> Combinable: ...
@@ -52,43 +48,45 @@ class Combinable:
     def __rand__(self, other: Any) -> Combinable: ...
     def __ror__(self, other: Any) -> Combinable: ...
 
-_SelfBaseExpression = TypeVar("_SelfBaseExpression", bound="BaseExpression")
-
 class BaseExpression:
     is_summary: bool = ...
     filterable: bool = ...
     window_compatible: bool = ...
+    output_field: Any
     def __init__(self, output_field: Optional[_OutputField] = ...) -> None: ...
     def get_db_converters(self, connection: Any) -> List[Callable]: ...
     def get_source_expressions(self) -> List[Any]: ...
-    def set_source_expressions(self, exprs: List[Any]) -> None: ...
+    def set_source_expressions(self, exprs: Sequence[Combinable]) -> None: ...
+    @property
     def contains_aggregate(self) -> bool: ...
+    @property
     def contains_over_clause(self) -> bool: ...
+    @property
     def contains_column_references(self) -> bool: ...
     def resolve_expression(
-        self,
+        self: _Self,
         query: Any = ...,
         allow_joins: bool = ...,
         reuse: Optional[Set[str]] = ...,
         summarize: bool = ...,
         for_save: bool = ...,
-    ) -> BaseExpression: ...
+    ) -> _Self: ...
     @property
     def field(self) -> Field: ...
     @property
     def output_field(self) -> Field: ...
+    @property
     def convert_value(self) -> Callable: ...
     def get_lookup(self, lookup: str) -> Optional[Type[Lookup]]: ...
     def get_transform(self, name: str) -> Optional[Type[Expression]]: ...
     def relabeled_clone(self, change_map: Dict[Optional[str], str]) -> Expression: ...
     def copy(self) -> BaseExpression: ...
-    def get_group_by_cols(self: _SelfBaseExpression) -> List[_SelfBaseExpression]: ...
+    def get_group_by_cols(self: _Self) -> List[_Self]: ...
     def get_source_fields(self) -> List[Optional[Field]]: ...
     def asc(self, **kwargs: Any) -> Expression: ...
     def desc(self, **kwargs: Any) -> Expression: ...
     def reverse_ordering(self): ...
     def flatten(self) -> Iterator[Expression]: ...
-    def __hash__(self) -> int: ...
     def deconstruct(self) -> Any: ...
     def as_sqlite(self, compiler: SQLCompiler, connection: Any) -> Any: ...
     def as_sql(self, compiler: SQLCompiler, connection: Any, **extra_context: Any) -> Any: ...
@@ -105,28 +103,18 @@ class CombinedExpression(SQLiteNumericMixin, Expression):
     def __init__(
         self, lhs: Combinable, connector: str, rhs: Combinable, output_field: Optional[_OutputField] = ...
     ) -> None: ...
-    def get_source_expressions(self) -> Union[List[Combinable], List[SQLiteNumericMixin]]: ...
-    def set_source_expressions(self, exprs: List[Combinable]) -> None: ...
-    def resolve_expression(
-        self,
-        query: Any = ...,
-        allow_joins: bool = ...,
-        reuse: Optional[Set[str]] = ...,
-        summarize: bool = ...,
-        for_save: bool = ...,
-    ) -> CombinedExpression: ...
 
 class F(Combinable):
     name: str
     def __init__(self, name: str): ...
     def resolve_expression(
-        self,
+        self: _Self,
         query: Any = ...,
         allow_joins: bool = ...,
         reuse: Optional[Set[str]] = ...,
         summarize: bool = ...,
         for_save: bool = ...,
-    ) -> Expression: ...
+    ) -> _Self: ...
     def asc(self, **kwargs) -> OrderBy: ...
     def desc(self, **kwargs) -> OrderBy: ...
     def deconstruct(self) -> Any: ...
@@ -141,8 +129,6 @@ class Subquery(Expression):
     def __init__(self, queryset: QuerySet, output_field: Optional[_OutputField] = ..., **extra: Any) -> None: ...
 
 class Exists(Subquery):
-    extra: Dict[Any, Any]
-    template: str = ...
     negated: bool = ...
     def __init__(self, *args: Any, negated: bool = ..., **kwargs: Any) -> None: ...
     def __invert__(self) -> Exists: ...
@@ -162,30 +148,19 @@ class Value(Expression):
     def __init__(self, value: Any, output_field: Optional[_OutputField] = ...) -> None: ...
 
 class RawSQL(Expression):
-    output_field: Field
     params: List[Any]
     sql: str
     def __init__(self, sql: str, params: Sequence[Any], output_field: Optional[_OutputField] = ...) -> None: ...
 
 class Func(SQLiteNumericMixin, Expression):
     function: str = ...
+    name: str = ...
     template: str = ...
     arg_joiner: str = ...
     arity: int = ...
-    source_expressions: List[Expression] = ...
+    source_expressions: List[Combinable] = ...
     extra: Dict[Any, Any] = ...
     def __init__(self, *expressions: Any, output_field: Optional[_OutputField] = ..., **extra: Any) -> None: ...
-    def get_source_expressions(self) -> List[Combinable]: ...
-    def set_source_expressions(self, exprs: List[Expression]) -> None: ...
-    def resolve_expression(
-        self,
-        query: Query = ...,
-        allow_joins: bool = ...,
-        reuse: Optional[Set[Any]] = ...,
-        summarize: bool = ...,
-        for_save: bool = ...,
-    ) -> Func: ...
-    def copy(self) -> Func: ...
 
 class When(Expression):
     template: str = ...
@@ -205,8 +180,6 @@ class Case(Expression):
 
 class ExpressionWrapper(Expression):
     def __init__(self, expression: Union[Q, Combinable], output_field: _OutputField): ...
-    def set_source_expressions(self, exprs: Sequence[Expression]) -> None: ...
-    def get_source_expressions(self) -> List[Expression]: ...
 
 class Col(Expression):
     def __init__(self, alias: str, target: str, output_field: Optional[_OutputField] = ...): ...
@@ -214,8 +187,7 @@ class Col(Expression):
 class ExpressionList(Func):
     def __init__(self, *expressions: Union[BaseExpression, Combinable], **extra: Any) -> None: ...
 
-class Random(Expression):
-    output_field: FloatField
+class Random(Expression): ...
 
 class Ref(Expression):
     def __init__(self, refs: str, source: Expression): ...

django-stubs/db/models/functions/comparison.pyi

@@ -1,51 +1,11 @@
-from datetime import date
-from decimal import Decimal
-from typing import Any, Callable, Dict, List, Union
-
-from django.db.models.expressions import Combinable, Expression
+from typing import Any, Union
 
 from django.db.models import Func
 from django.db.models.fields import Field
 
 class Cast(Func):
-    contains_aggregate: bool
-    convert_value: Callable
-    extra: Dict[Any, Any]
-    is_summary: bool
-    output_field: Field
-    source_expressions: List[Combinable]
-    function: str = ...
-    template: str = ...
-    def __init__(self, expression: Union[date, Decimal, Expression, str], output_field: Union[str, Field]) -> None: ...
+    def __init__(self, expression: Any, output_field: Union[str, Field]) -> None: ...
 
-class Coalesce(Func):
-    contains_aggregate: bool
-    convert_value: Callable
-    extra: Dict[Any, Any]
-    is_summary: bool
-    output_field: Field
-    source_expressions: List[Combinable]
-    function: str = ...
-    def __init__(self, *expressions: Any, **extra: Any) -> None: ...
-
-class Greatest(Func):
-    contains_aggregate: bool
-    contains_over_clause: bool
-    convert_value: Callable
-    extra: Dict[Any, Any]
-    is_summary: bool
-    output_field: Field
-    source_expressions: List[Combinable]
-    function: str = ...
-    def __init__(self, *expressions: Any, **extra: Any) -> None: ...
-
-class Least(Func):
-    contains_aggregate: bool
-    contains_over_clause: bool
-    convert_value: Callable
-    extra: Dict[Any, Any]
-    is_summary: bool
-    output_field: Field
-    source_expressions: List[Combinable]
-    function: str = ...
-    def __init__(self, *expressions: Any, **extra: Any) -> None: ...
+class Coalesce(Func): ...
+class Greatest(Func): ...
+class Least(Func): ...

django-stubs/db/models/functions/text.pyi

@@ -1,105 +1,47 @@
-from typing import Any, List, Optional, Tuple, Union, Callable
+from typing import Any, List, Optional, Tuple, Union
 
 from django.db.backends.sqlite3.base import DatabaseWrapper
 from django.db.models.expressions import Combinable, Expression, Value
 from django.db.models.sql.compiler import SQLCompiler
 
 from django.db.models import Func, Transform
-from django.db.models.fields import Field
 
-class BytesToCharFieldConversionMixin:
-    def convert_value(
-        self, value: str, expression: BytesToCharFieldConversionMixin, connection: DatabaseWrapper
-    ) -> str: ...
-
-class Chr(Transform):
-    contains_aggregate: bool
-    lookup_name: str = ...
+class BytesToCharFieldConversionMixin: ...
+class Chr(Transform): ...
 
 class ConcatPair(Func):
-    contains_aggregate: bool
     def coalesce(self) -> ConcatPair: ...
 
-class Concat(Func):
-    contains_aggregate: bool
-    convert_value: Callable
+class Concat(Func): ...
 
 class Left(Func):
-    contains_aggregate: bool
-    contains_over_clause: bool
-    convert_value: Callable
-    output_field: Field
     def __init__(self, expression: str, length: Union[Value, int], **extra: Any) -> None: ...
     def get_substr(self) -> Substr: ...
     def use_substr(
         self, compiler: SQLCompiler, connection: DatabaseWrapper, **extra_context: Any
     ) -> Tuple[str, List[int]]: ...
-    as_oracle: Any = ...
-    as_sqlite: Any = ...
 
-class Length(Transform):
-    contains_aggregate: bool
-    convert_value: Callable
-    lookup_name: str = ...
-
-class Lower(Transform):
-    contains_aggregate: bool
-    contains_column_references: bool
-    contains_over_clause: bool
-    convert_value: Callable
-    lookup_name: str = ...
+class Length(Transform): ...
+class Lower(Transform): ...
 
 class LPad(BytesToCharFieldConversionMixin, Func):
-    contains_aggregate: bool
-    convert_value: Callable
     def __init__(self, expression: str, length: Union[Length, int], fill_text: Value = ..., **extra: Any) -> None: ...
 
-class LTrim(Transform):
-    contains_aggregate: bool
-    convert_value: Callable
-    lookup_name: str = ...
-
-class Ord(Transform):
-    contains_aggregate: bool
-    convert_value: Callable
-    lookup_name: str = ...
-    def as_mysql(self, compiler: Any, connection: Any, **extra_context: Any): ...
+class LTrim(Transform): ...
+class Ord(Transform): ...
 
 class Repeat(BytesToCharFieldConversionMixin, Func):
-    contains_aggregate: bool
-    convert_value: Callable
-    output_field: django.db.models.fields.CharField
     def __init__(self, expression: Union[Value, str], number: Union[Length, int], **extra: Any) -> None: ...
-    def as_oracle(self, compiler: Any, connection: Any, **extra_context: Any): ...
 
 class Replace(Func):
-    contains_aggregate: bool
-    contains_over_clause: bool
-    convert_value: Callable
-    output_field: Field
     def __init__(self, expression: Combinable, text: Value, replacement: Value = ..., **extra: Any) -> None: ...
 
 class Right(Left): ...
-
-class RPad(LPad):
-    output_field: Field
-
-class RTrim(Transform):
-    contains_aggregate: bool
-    convert_value: Callable
-    lookup_name: str = ...
-
-class StrIndex(Func):
-    contains_aggregate: bool
-    convert_value: Callable
-    output_field: Any = ...
-    def as_postgresql(self, compiler: Any, connection: Any): ...
+class RPad(LPad): ...
+class RTrim(Transform): ...
+class StrIndex(Func): ...
 
 class Substr(Func):
-    contains_aggregate: bool
-    contains_over_clause: bool
-    convert_value: Callable
-    output_field: Field
     def __init__(
         self,
         expression: Union[Expression, str],
@@ -108,13 +50,5 @@ class Substr(Func):
         **extra: Any
     ) -> None: ...
 
-class Trim(Transform):
-    contains_aggregate: bool
-    convert_value: Callable
-    lookup_name: str = ...
-
-class Upper(Transform):
-    contains_aggregate: bool
-    contains_over_clause: bool
-    convert_value: Callable
-    lookup_name: str = ...
+class Trim(Transform): ...
+class Upper(Transform): ...

django-stubs/db/models/functions/window.pyi

@@ -1,69 +1,26 @@
-from typing import Any, Optional, Dict, List
+from typing import Any, Optional
 
 from django.db.models import Func
 
-class CumeDist(Func):
-    function: str = ...
-    name: str = ...
-    output_field: Any = ...
-    window_compatible: bool = ...
-
-class DenseRank(Func):
-    name: str = ...
-    output_field: Any = ...
-    window_compatible: bool = ...
-
-class FirstValue(Func):
-    name: str = ...
-    window_compatible: bool = ...
+class CumeDist(Func): ...
+class DenseRank(Func): ...
+class FirstValue(Func): ...
 
 class LagLeadFunction(Func):
-    window_compatible: bool = ...
     def __init__(
         self, expression: Optional[str], offset: int = ..., default: Optional[int] = ..., **extra: Any
     ) -> None: ...
 
-class Lag(LagLeadFunction):
-    function: str = ...
-    name: str = ...
-
-class LastValue(Func):
-    arity: int = ...
-    function: str = ...
-    name: str = ...
-    window_compatible: bool = ...
-
-class Lead(LagLeadFunction):
-    function: str = ...
-    name: str = ...
+class Lag(LagLeadFunction): ...
+class LastValue(Func): ...
+class Lead(LagLeadFunction): ...
 
 class NthValue(Func):
-    function: str = ...
-    name: str = ...
-    window_compatible: bool = ...
-    def __init__(self, expression: Optional[str], nth: int = ..., **extra: Any) -> Any: ...
+    def __init__(self, expression: Optional[str], nth: int = ..., **extra: Any) -> None: ...
 
 class Ntile(Func):
-    function: str = ...
-    name: str = ...
-    output_field: Any = ...
-    window_compatible: bool = ...
-    def __init__(self, num_buckets: int = ..., **extra: Any) -> Any: ...
+    def __init__(self, num_buckets: int = ..., **extra: Any) -> None: ...
 
-class PercentRank(Func):
-    function: str = ...
-    name: str = ...
-    output_field: Any = ...
-    window_compatible: bool = ...
-
-class Rank(Func):
-    function: str = ...
-    name: str = ...
-    output_field: Any = ...
-    window_compatible: bool = ...
-
-class RowNumber(Func):
-    function: str = ...
-    name: str = ...
-    output_field: Any = ...
-    window_compatible: bool = ...
+class PercentRank(Func): ...
+class Rank(Func): ...
+class RowNumber(Func): ...

django-stubs/db/models/manager.pyi

@@ -5,7 +5,7 @@ from django.db.models.query import QuerySet
 
 _T = TypeVar("_T", bound=Model, covariant=True)
 
-class BaseManager(QuerySet[_T]):
+class BaseManager(QuerySet[_T, _T]):
     creation_counter: int = ...
     auto_created: bool = ...
     use_in_migrations: bool = ...
@@ -21,7 +21,7 @@ class BaseManager(QuerySet[_T]):
     def _get_queryset_methods(cls, queryset_class: type) -> Dict[str, Any]: ...
     def contribute_to_class(self, model: Type[Model], name: str) -> None: ...
     def db_manager(self, using: Optional[str] = ..., hints: Optional[Dict[str, Model]] = ...) -> Manager: ...
-    def get_queryset(self) -> QuerySet[_T]: ...
+    def get_queryset(self) -> QuerySet[_T, _T]: ...
 
 class Manager(BaseManager[_T]): ...
 

django-stubs/db/models/query.pyi

@@ -1,3 +1,4 @@
+import datetime
 from typing import (
     Any,
     Dict,
@@ -13,12 +14,14 @@ from typing import (
     TypeVar,
     Union,
     overload,
+    Generic,
+    NamedTuple,
+    Collection,
 )
 
 from django.db.models.base import Model
 from django.db.models.expressions import Combinable as Combinable, F as F
 from django.db.models.sql.query import Query, RawQuery
-from typing_extensions import Literal
 
 from django.db import models
 from django.db.models import Manager
@@ -46,7 +49,7 @@ class FlatValuesListIterable(BaseIterable):
 
 _T = TypeVar("_T", bound=models.Model, covariant=True)
 
-class QuerySet(Iterable[_T], Sized):
+class QuerySet(Generic[_T, _Row], Collection[_Row], Sized):
     query: Query
     def __init__(
         self,
@@ -58,32 +61,33 @@ class QuerySet(Iterable[_T], Sized):
     @classmethod
     def as_manager(cls) -> Manager[Any]: ...
     def __len__(self) -> int: ...
-    def __iter__(self) -> Iterator[_T]: ...
+    def __iter__(self) -> Iterator[_Row]: ...
+    def __contains__(self, x: object) -> bool: ...
+    @overload
+    def __getitem__(self, i: int) -> _Row: ...
+    @overload
+    def __getitem__(self, s: slice) -> QuerySet[_T, _Row]: ...
     def __bool__(self) -> bool: ...
     def __class_getitem__(cls, item: Type[_T]):
         pass
     def __getstate__(self) -> Dict[str, Any]: ...
-    @overload
-    def __getitem__(self, k: int) -> _T: ...
-    @overload
-    def __getitem__(self, k: str) -> Any: ...
-    @overload
-    def __getitem__(self, k: slice) -> QuerySet[_T]: ...
-    def __and__(self, other: QuerySet) -> QuerySet: ...
-    def __or__(self, other: QuerySet) -> QuerySet: ...
-    def iterator(self, chunk_size: int = ...) -> Iterator[_T]: ...
+    # __and__ and __or__ ignore the other QuerySet's _Row type parameter because they use the same row type as the self QuerySet.
+    # Technically, the other QuerySet must be of the same type _T, but _T is covariant
+    def __and__(self, other: QuerySet[_T, Any]) -> QuerySet[_T, _Row]: ...
+    def __or__(self, other: QuerySet[_T, Any]) -> QuerySet[_T, _Row]: ...
+    def iterator(self, chunk_size: int = ...) -> Iterator[_Row]: ...
     def aggregate(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: ...
-    def get(self, *args: Any, **kwargs: Any) -> _T: ...
+    def get(self, *args: Any, **kwargs: Any) -> _Row: ...
     def create(self, **kwargs: Any) -> _T: ...
     def bulk_create(self, objs: Iterable[Model], batch_size: Optional[int] = ...) -> List[_T]: ...
     def get_or_create(self, defaults: Optional[MutableMapping[str, Any]] = ..., **kwargs: Any) -> Tuple[_T, bool]: ...
     def update_or_create(
         self, defaults: Optional[MutableMapping[str, Any]] = ..., **kwargs: Any
     ) -> Tuple[_T, bool]: ...
-    def earliest(self, *fields: Any, field_name: Optional[Any] = ...) -> _T: ...
-    def latest(self, *fields: Any, field_name: Optional[Any] = ...) -> _T: ...
-    def first(self) -> Optional[_T]: ...
-    def last(self) -> Optional[_T]: ...
+    def earliest(self, *fields: Any, field_name: Optional[Any] = ...) -> _Row: ...
+    def latest(self, *fields: Any, field_name: Optional[Any] = ...) -> _Row: ...
+    def first(self) -> Optional[_Row]: ...
+    def last(self) -> Optional[_Row]: ...
     def in_bulk(self, id_list: Iterable[Any] = ..., *, field_name: str = ...) -> Dict[Any, _T]: ...
     def delete(self) -> Tuple[int, Dict[str, int]]: ...
     def update(self, **kwargs: Any) -> int: ...
@@ -93,31 +97,31 @@ class QuerySet(Iterable[_T], Sized):
     def raw(
         self, raw_query: str, params: Any = ..., translations: Optional[Dict[str, str]] = ..., using: None = ...
     ) -> RawQuerySet: ...
-    def values(self, *fields: Union[str, Combinable], **expressions: Any) -> QuerySet: ...
-    def values_list(self, *fields: Union[str, Combinable], flat: bool = ..., named: bool = ...) -> QuerySet: ...
-    # @overload
-    # def values_list(self, *fields: Union[str, Combinable], named: Literal[True]) -> NamedValuesListIterable: ...
-    # @overload
-    # def values_list(self, *fields: Union[str, Combinable], flat: Literal[True]) -> FlatValuesListIterable: ...
-    # @overload
-    # def values_list(self, *fields: Union[str, Combinable]) -> ValuesListIterable: ...
-    def dates(self, field_name: str, kind: str, order: str = ...) -> QuerySet: ...
-    def datetimes(self, field_name: str, kind: str, order: str = ..., tzinfo: None = ...) -> QuerySet: ...
-    def none(self) -> QuerySet[_T]: ...
-    def all(self) -> QuerySet[_T]: ...
-    def filter(self, *args: Any, **kwargs: Any) -> QuerySet[_T]: ...
-    def exclude(self, *args: Any, **kwargs: Any) -> QuerySet[_T]: ...
-    def complex_filter(self, filter_obj: Any) -> QuerySet[_T]: ...
+    # The type of values may be overridden to be more specific in the mypy plugin, depending on the fields param
+    def values(self, *fields: Union[str, Combinable], **expressions: Any) -> QuerySet[_T, Dict[str, Any]]: ...
+    # The type of values_list may be overridden to be more specific in the mypy plugin, depending on the fields param
+    def values_list(
+        self, *fields: Union[str, Combinable], flat: bool = ..., named: bool = ...
+    ) -> QuerySet[_T, Any]: ...
+    def dates(self, field_name: str, kind: str, order: str = ...) -> QuerySet[_T, datetime.date]: ...
+    def datetimes(
+        self, field_name: str, kind: str, order: str = ..., tzinfo: None = ...
+    ) -> QuerySet[_T, datetime.datetime]: ...
+    def none(self) -> QuerySet[_T, _Row]: ...
+    def all(self) -> QuerySet[_T, _Row]: ...
+    def filter(self, *args: Any, **kwargs: Any) -> QuerySet[_T, _Row]: ...
+    def exclude(self, *args: Any, **kwargs: Any) -> QuerySet[_T, _Row]: ...
+    def complex_filter(self, filter_obj: Any) -> QuerySet[_T, _Row]: ...
     def count(self) -> int: ...
-    def union(self, *other_qs: Any, all: bool = ...) -> QuerySet[_T]: ...
-    def intersection(self, *other_qs: Any) -> QuerySet[_T]: ...
-    def difference(self, *other_qs: Any) -> QuerySet[_T]: ...
-    def select_for_update(self, nowait: bool = ..., skip_locked: bool = ..., of: Tuple = ...) -> QuerySet: ...
-    def select_related(self, *fields: Any) -> QuerySet[_T]: ...
-    def prefetch_related(self, *lookups: Any) -> QuerySet[_T]: ...
-    def annotate(self, *args: Any, **kwargs: Any) -> QuerySet[_T]: ...
-    def order_by(self, *field_names: Any) -> QuerySet[_T]: ...
-    def distinct(self, *field_names: Any) -> QuerySet[_T]: ...
+    def union(self, *other_qs: Any, all: bool = ...) -> QuerySet[_T, _Row]: ...
+    def intersection(self, *other_qs: Any) -> QuerySet[_T, _Row]: ...
+    def difference(self, *other_qs: Any) -> QuerySet[_T, _Row]: ...
+    def select_for_update(self, nowait: bool = ..., skip_locked: bool = ..., of: Tuple = ...) -> QuerySet[_T, _Row]: ...
+    def select_related(self, *fields: Any) -> QuerySet[_T, _Row]: ...
+    def prefetch_related(self, *lookups: Any) -> QuerySet[_T, _Row]: ...
+    def annotate(self, *args: Any, **kwargs: Any) -> QuerySet[_T, _Row]: ...
+    def order_by(self, *field_names: Any) -> QuerySet[_T, _Row]: ...
+    def distinct(self, *field_names: Any) -> QuerySet[_T, _Row]: ...
     def extra(
         self,
         select: Optional[Dict[str, Any]] = ...,
@@ -126,11 +130,11 @@ class QuerySet(Iterable[_T], Sized):
         tables: Optional[List[str]] = ...,
         order_by: Optional[Sequence[str]] = ...,
         select_params: Optional[Sequence[Any]] = ...,
-    ) -> QuerySet[_T]: ...
-    def reverse(self) -> QuerySet[_T]: ...
-    def defer(self, *fields: Any) -> QuerySet[_T]: ...
-    def only(self, *fields: Any) -> QuerySet[_T]: ...
-    def using(self, alias: Optional[str]) -> QuerySet[_T]: ...
+    ) -> QuerySet[_T, _Row]: ...
+    def reverse(self) -> QuerySet[_T, _Row]: ...
+    def defer(self, *fields: Any) -> QuerySet[_T, _Row]: ...
+    def only(self, *fields: Any) -> QuerySet[_T, _Row]: ...
+    def using(self, alias: Optional[str]) -> QuerySet[_T, _Row]: ...
     @property
     def ordered(self) -> bool: ...
     @property
@@ -159,7 +163,7 @@ class RawQuerySet(Iterable[_T], Sized):
     @overload
     def __getitem__(self, k: str) -> Any: ...
     @overload
-    def __getitem__(self, k: slice) -> QuerySet[_T]: ...
+    def __getitem__(self, k: slice) -> RawQuerySet[_T]: ...
     @property
     def columns(self) -> List[str]: ...
     @property

django-stubs/forms/__init__.pyi

@@ -6,6 +6,18 @@ from .models import (
     ModelForm as ModelForm,
     ModelChoiceField as ModelChoiceField,
     ModelMultipleChoiceField as ModelMultipleChoiceField,
+    model_to_dict as model_to_dict,
+    BaseModelForm as BaseModelForm,
+    BaseInlineFormSet as BaseInlineFormSet,
+    BaseModelFormSet as BaseModelFormSet,
+    fields_for_model as fields_for_model,
+    inlineformset_factory as inlineformset_factory,
+    modelform_factory as modelform_factory,
+    InlineForeignKeyField as InlineForeignKeyField,
+    ModelChoiceIterator as ModelChoiceIterator,
+    ModelFormMetaclass as ModelFormMetaclass,
+    ModelFormOptions as ModelFormOptions,
+    modelformset_factory as modelformset_factory,
 )
 
 from .widgets import (
@@ -68,3 +80,5 @@ from .fields import (
     TypedChoiceField as TypedChoiceField,
     TypedMultipleChoiceField as TypedMultipleChoiceField,
 )
+
+from .boundfield import BoundField as BoundField, BoundWidget as BoundWidget

django-stubs/forms/forms.pyi

@@ -21,7 +21,7 @@ class BaseForm:
     is_bound: bool = ...
     data: Dict[str, Any] = ...
     files: Optional[Dict[str, Any]] = ...
-    auto_id: Any = ...
+    auto_id: str = ...
     initial: Dict[str, Any] = ...
     error_class: Type[ErrorList] = ...
     prefix: str = ...
@@ -59,7 +59,7 @@ class BaseForm:
     def add_error(self, field: Optional[str], error: Union[ValidationError, str]) -> None: ...
     def has_error(self, field: Any, code: Optional[Any] = ...): ...
     def full_clean(self) -> None: ...
-    def clean(self) -> Dict[str, Optional[Union[datetime, SimpleUploadedFile, QuerySet, str]]]: ...
+    def clean(self) -> Dict[str, Any]: ...
     def has_changed(self) -> bool: ...
     def changed_data(self) -> List[str]: ...
     @property

django-stubs/forms/models.pyi

@@ -1,12 +1,9 @@
-from collections import OrderedDict
-from datetime import date, datetime
-from typing import Any, Callable, Dict, Iterator, List, MutableMapping, Optional, Sequence, Tuple, Type, Union, Mapping
+from datetime import datetime
+from typing import Any, Callable, Dict, Iterator, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Type, Union
 from unittest.mock import MagicMock
 from uuid import UUID
 
 from django.core.files.base import File
-from django.db import models
-from django.db.models import ForeignKey
 from django.db.models.base import Model
 from django.db.models.manager import Manager
 from django.db.models.query import QuerySet
@@ -18,6 +15,9 @@ from django.forms.utils import ErrorList
 from django.forms.widgets import Input, Widget
 from typing_extensions import Literal
 
+from django.db import models
+from django.db.models import ForeignKey
+
 ALL_FIELDS: str
 
 _Fields = Union[List[Union[Callable, str]], Sequence[str], Literal["__all__"]]

django-stubs/forms/widgets.pyi

@@ -1,15 +1,12 @@
-from datetime import time
 from decimal import Decimal
 from itertools import chain
-from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union
+from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Sequence, Set, Tuple, Type, Union
 
 from django.core.files.base import File
-from django.db.models.fields.files import FieldFile
 from django.forms.renderers import EngineMixin
-from django.utils.datastructures import MultiValueDict
 from django.utils.safestring import SafeText
 
-_OptAttrs = Dict[str, str]
+_OptAttrs = Dict[str, Any]
 
 class MediaOrderConflictWarning(RuntimeWarning): ...
 
@@ -38,31 +35,21 @@ class Widget:
     is_localized: bool = ...
     is_required: bool = ...
     supports_microseconds: bool = ...
-    attrs: Dict[str, Any] = ...
-    def __init__(self, attrs: Optional[Dict[str, Any]] = ...) -> None: ...
+    attrs: _OptAttrs = ...
+    def __init__(self, attrs: Optional[_OptAttrs] = ...) -> None: ...
     @property
     def is_hidden(self) -> bool: ...
-    def subwidgets(
-        self, name: str, value: Optional[List[str]], attrs: Dict[str, bool] = ...
-    ) -> Iterator[Dict[str, Any]]: ...
+    def subwidgets(self, name: str, value: Optional[List[str]], attrs: _OptAttrs = ...) -> Iterator[Dict[str, Any]]: ...
     def format_value(self, value: Any) -> Optional[str]: ...
-    def get_context(self, name: str, value: Any, attrs: Optional[Dict[str, Union[bool, str]]]) -> Dict[str, Any]: ...
+    def get_context(self, name: str, value: Any, attrs: Optional[_OptAttrs]) -> Dict[str, Any]: ...
     def render(
-        self,
-        name: str,
-        value: Any,
-        attrs: Optional[Dict[str, Union[bool, str]]] = ...,
-        renderer: Optional[EngineMixin] = ...,
+        self, name: str, value: Any, attrs: Optional[_OptAttrs] = ..., renderer: Optional[EngineMixin] = ...
     ) -> SafeText: ...
     def build_attrs(
-        self, base_attrs: Dict[str, Union[float, str]], extra_attrs: Optional[Dict[str, Union[bool, str]]] = ...
+        self, base_attrs: _OptAttrs, extra_attrs: Optional[_OptAttrs] = ...
     ) -> Dict[str, Union[Decimal, float, str]]: ...
-    def value_from_datadict(
-        self, data: dict, files: Union[Dict[str, Iterable[Any]], MultiValueDict], name: str
-    ) -> Any: ...
-    def value_omitted_from_data(
-        self, data: Dict[str, Any], files: Union[Dict[str, Iterable[Any]], MultiValueDict], name: str
-    ) -> bool: ...
+    def value_from_datadict(self, data: Dict[str, Any], files: Mapping[str, Iterable[Any]], name: str) -> Any: ...
+    def value_omitted_from_data(self, data: Dict[str, Any], files: Mapping[str, Iterable[Any]], name: str) -> bool: ...
     def id_for_label(self, id_: str) -> str: ...
     def use_required_attribute(self, initial: Any) -> bool: ...
 
@@ -94,14 +81,12 @@ class ClearableFileInput(FileInput):
     def clear_checkbox_name(self, name: str) -> str: ...
     def clear_checkbox_id(self, name: str) -> str: ...
     def is_initial(self, value: Optional[Union[File, str]]) -> bool: ...
-    def use_required_attribute(self, initial: Optional[Union[FieldFile, str]]) -> bool: ...
 
 class Textarea(Widget):
     template_name: str = ...
 
 class DateTimeBaseInput(TextInput):
     format_key: str = ...
-    supports_microseconds: bool = ...
     format: Optional[str] = ...
     def __init__(self, attrs: Optional[_OptAttrs] = ..., format: Optional[str] = ...): ...
 
@@ -128,7 +113,7 @@ class ChoiceWidget(Widget):
     def create_option(
         self,
         name: str,
-        value: Union[time, int, str],
+        value: Any,
         label: Union[int, str],
         selected: Union[Set[str], bool],
         index: int,
@@ -137,13 +122,7 @@ class ChoiceWidget(Widget):
     ) -> Dict[str, Any]: ...
     def id_for_label(self, id_: str, index: str = ...) -> str: ...
 
-class Select(ChoiceWidget):
-    option_template_name: str = ...
-    add_id_index: bool = ...
-    checked_attribute: Any = ...
-    option_inherits_attrs: bool = ...
-    def use_required_attribute(self, initial: Any) -> bool: ...
-
+class Select(ChoiceWidget): ...
 class NullBooleanSelect(Select): ...
 
 class SelectMultiple(Select):
@@ -154,40 +133,26 @@ class RadioSelect(ChoiceWidget):
     option_template_name: str = ...
 
 class CheckboxSelectMultiple(ChoiceWidget):
-    allow_multiple_selected: bool = ...
-    option_template_name: str = ...
-    def use_required_attribute(self, initial: Optional[List[str]]) -> bool: ...
     def id_for_label(self, id_: str, index: Optional[str] = ...) -> str: ...
 
 class MultiWidget(Widget):
     template_name: str = ...
     widgets: List[Widget] = ...
     def __init__(self, widgets: Sequence[Union[Widget, Type[Widget]]], attrs: Optional[_OptAttrs] = ...) -> None: ...
-    @property
-    def is_hidden(self) -> bool: ...
     def decompress(self, value: Any) -> Optional[Any]: ...
     media: Any = ...
 
 class SplitDateTimeWidget(MultiWidget):
-    supports_microseconds: bool = ...
     def __init__(
         self,
-        attrs: Optional[Dict[str, str]] = ...,
+        attrs: Optional[_OptAttrs] = ...,
         date_format: Optional[str] = ...,
         time_format: Optional[str] = ...,
         date_attrs: Optional[Dict[str, str]] = ...,
         time_attrs: Optional[Dict[str, str]] = ...,
     ) -> None: ...
 
-class SplitHiddenDateTimeWidget(SplitDateTimeWidget):
-    def __init__(
-        self,
-        attrs: Optional[Dict[str, str]] = ...,
-        date_format: None = ...,
-        time_format: None = ...,
-        date_attrs: Optional[Dict[str, str]] = ...,
-        time_attrs: Optional[Dict[str, str]] = ...,
-    ) -> None: ...
+class SplitHiddenDateTimeWidget(SplitDateTimeWidget): ...
 
 class SelectDateWidget(Widget):
     none_value: Any = ...

django-stubs/shortcuts.pyi

@@ -31,6 +31,6 @@ def redirect(
 
 _T = TypeVar("_T", bound=Model)
 
-def get_object_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T]], *args: Any, **kwargs: Any) -> _T: ...
-def get_list_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T]], *args: Any, **kwargs: Any) -> List[_T]: ...
+def get_object_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T, _T]], *args: Any, **kwargs: Any) -> _T: ...
+def get_list_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T, _T]], *args: Any, **kwargs: Any) -> List[_T]: ...
 def resolve_url(to: Union[Callable, Model, str], *args: Any, **kwargs: Any) -> str: ...

django-stubs/template/backends/base.pyi

@@ -1,15 +1,16 @@
-from typing import Any, Dict, Iterator, List, Tuple, Union
+from typing import Any, Iterator, List, Mapping, Optional, Tuple
 
 from django.template.base import Template
 
 class BaseEngine:
-    name: Any = ...
-    dirs: Any = ...
-    app_dirs: Any = ...
-    def __init__(self, params: Dict[str, Union[List[str], bool, str]]) -> None: ...
+    name: str = ...
+    dirs: List[str] = ...
+    app_dirs: bool = ...
+    def __init__(self, params: Mapping[str, Any]) -> None: ...
+    @property
+    def app_dirname(self) -> Optional[str]: ...
+    def from_string(self, template_code: str) -> Template: ...
+    def get_template(self, template_name: str) -> Optional[Template]: ...
     @property
-    def app_dirname(self) -> None: ...
-    def from_string(self, template_code: Any) -> Template: ...
-    def get_template(self, template_name: Any) -> None: ...
     def template_dirs(self) -> Tuple[str]: ...
     def iter_template_filenames(self, template_name: str) -> Iterator[str]: ...

django-stubs/template/backends/django.pyi

@@ -1,20 +1,13 @@
-from typing import Any, Dict, Iterator, Optional, List
-
-from django.template.base import Template as Template
-from django.template.exceptions import TemplateDoesNotExist
+from typing import Any, Dict, Iterator, Optional
 
 from django.template.engine import Engine
+from django.template.exceptions import TemplateDoesNotExist
+
 from .base import BaseEngine
 
 class DjangoTemplates(BaseEngine):
-    app_dirs: bool
-    dirs: List[str]
-    name: str
-    app_dirname: str = ...
     engine: Engine = ...
     def __init__(self, params: Dict[str, Any]) -> None: ...
-    def from_string(self, template_code: str) -> Template: ...
-    def get_template(self, template_name: str) -> Template: ...
     def get_templatetag_libraries(self, custom_libraries: Dict[str, str]) -> Dict[str, str]: ...
 
 def copy_exception(exc: TemplateDoesNotExist, backend: Optional[DjangoTemplates] = ...) -> TemplateDoesNotExist: ...

django-stubs/template/backends/dummy.pyi

@@ -1,19 +1,13 @@
 import string
-from typing import Any, Dict, List, Optional, Union, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from django.http.request import HttpRequest
 
 from .base import BaseEngine
 
 class TemplateStrings(BaseEngine):
-    app_dirs: bool
-    dirs: List[Any]
-    name: str
     template_dirs: Tuple[str]
-    app_dirname: str = ...
     def __init__(self, params: Dict[str, Union[Dict[Any, Any], List[Any], bool, str]]) -> None: ...
-    def from_string(self, template_code: str) -> Template: ...
-    def get_template(self, template_name: str) -> Template: ...
 
 class Template(string.Template):
     template: str

django-stubs/template/backends/jinja2.pyi

@@ -1,21 +1,14 @@
-from typing import Callable, Dict, List, Optional, Tuple, Any
+from typing import Any, Callable, Dict, List, Optional
 
-from django.template.base import Template as Template
 from django.template.exceptions import TemplateSyntaxError
 
 from .base import BaseEngine
 
 class Jinja2(BaseEngine):
-    app_dirs: bool
-    dirs: List[str]
-    name: str
-    template_context_processors: List[Callable]
-    template_dirs: Tuple[str]
-    app_dirname: str = ...
     context_processors: List[str] = ...
     def __init__(self, params: Dict[str, Any]) -> None: ...
-    def from_string(self, template_code: str) -> Template: ...
-    def get_template(self, template_name: str) -> Template: ...
+    @property
+    def template_context_processors(self) -> List[Callable]: ...
 
 class Origin:
     name: str = ...

django-stubs/template/base.pyi

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Tuple, Type, Union
+from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple, Type, Union
 
 from django.http.request import HttpRequest
 from django.template.context import Context as Context
@@ -126,12 +126,12 @@ filter_re: Any
 
 class FilterExpression:
     token: str = ...
-    filters: List[Tuple[Callable, List[Tuple[bool, Union[Variable, SafeText]]]]] = ...
-    var: Union[Variable, SafeText] = ...
+    filters: List[Any] = ...
+    var: Any = ...
     def __init__(self, token: str, parser: Parser) -> None: ...
-    def resolve(self, context: Union[Dict[str, Dict[str, str]], Context], ignore_failures: bool = ...) -> Any: ...
+    def resolve(self, context: Mapping[str, Any], ignore_failures: bool = ...) -> Any: ...
     @staticmethod
-    def args_check(name: str, func: Callable, provided: List[Tuple[bool, Union[Variable, SafeText]]]) -> bool: ...
+    def args_check(name: str, func: Callable, provided: List[Tuple[bool, Any]]) -> bool: ...
 
 class Variable:
     var: Union[Dict[Any, Any], str] = ...
@@ -152,27 +152,21 @@ class Node:
     def __iter__(self) -> None: ...
     def get_nodes_by_type(self, nodetype: Type[Node]) -> List[Node]: ...
 
-class NodeList(list):
+class NodeList(List[Node]):
     contains_nontext: bool = ...
     def render(self, context: Context) -> SafeText: ...
     def get_nodes_by_type(self, nodetype: Type[Node]) -> List[Node]: ...
 
 class TextNode(Node):
-    origin: Origin
-    token: Token
     s: str = ...
     def __init__(self, s: str) -> None: ...
-    def render(self, context: Context) -> str: ...
 
 def render_value_in_context(value: Any, context: Context) -> str: ...
 
 class VariableNode(Node):
-    origin: Origin
-    token: Token
     filter_expression: FilterExpression = ...
     def __init__(self, filter_expression: FilterExpression) -> None: ...
-    def render(self, context: Context) -> str: ...
 
 kwarg_re: Any
 
-def token_kwargs(bits: List[str], parser: Parser, support_legacy: bool = ...) -> Dict[str, FilterExpression]: ...
+def token_kwargs(bits: Sequence[str], parser: Parser, support_legacy: bool = ...) -> Dict[str, FilterExpression]: ...

django-stubs/template/loaders/app_directories.pyi

@@ -1,10 +1,3 @@
-from typing import Optional, Tuple
-
-from django.template import Engine
-
 from .filesystem import Loader as FilesystemLoader
 
-class Loader(FilesystemLoader):
-    dirs: None
-    engine: Engine
-    def get_dirs(self) -> Tuple: ...
+class Loader(FilesystemLoader): ...

django-stubs/template/loaders/base.pyi

@@ -4,9 +4,9 @@ from django.template.base import Origin, Template
 from django.template.engine import Engine
 
 class Loader:
-    engine: Any = ...
+    engine: Engine = ...
     get_template_cache: Dict[str, Any] = ...
     def __init__(self, engine: Engine) -> None: ...
     def get_template(self, template_name: str, skip: Optional[List[Origin]] = ...) -> Template: ...
-    def get_template_sources(self, template_name: Any) -> None: ...
+    def get_template_sources(self, template_name: str) -> None: ...
     def reset(self) -> None: ...

django-stubs/template/loaders/cached.pyi

@@ -1,19 +1,14 @@
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Sequence
 
-from django.template.base import Origin, Template
+from django.template.base import Origin
 from django.template.engine import Engine
 
 from .base import Loader as BaseLoader
 
 class Loader(BaseLoader):
-    engine: Engine
-    template_cache: Dict[Any, Any] = ...
-    get_template_cache: Dict[str, django.template.exceptions.TemplateDoesNotExist] = ...
-    loaders: List[django.template.loaders.base.Loader] = ...
-    def __init__(self, engine: Engine, loaders: Union[List[Tuple[str, Dict[str, str]]], List[str]]) -> None: ...
+    template_cache: Dict[str, Any] = ...
+    loaders: List[BaseLoader] = ...
+    def __init__(self, engine: Engine, loaders: Sequence[Any]) -> None: ...
     def get_contents(self, origin: Origin) -> str: ...
-    def get_template(self, template_name: str, skip: Optional[List[Origin]] = ...) -> Template: ...
-    def get_template_sources(self, template_name: str) -> None: ...
     def cache_key(self, template_name: str, skip: Optional[List[Origin]] = ...) -> str: ...
     def generate_hash(self, values: List[str]) -> str: ...
-    def reset(self) -> None: ...

django-stubs/template/loaders/filesystem.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Iterator, List, Optional, Union
+from typing import Any, List, Optional, Union
 
 from django.template.base import Origin
 from django.template.engine import Engine
@@ -6,9 +6,7 @@ from django.template.engine import Engine
 from .base import Loader as BaseLoader
 
 class Loader(BaseLoader):
-    engine: Engine
     dirs: Optional[List[str]] = ...
     def __init__(self, engine: Engine, dirs: Optional[List[str]] = ...) -> None: ...
     def get_dirs(self) -> Union[List[bytes], List[str]]: ...
     def get_contents(self, origin: Origin) -> Any: ...
-    def get_template_sources(self, template_name: Union[bytes, str]) -> Iterator[Origin]: ...

django-stubs/template/loaders/locmem.pyi

@@ -1,4 +1,4 @@
-from typing import Dict, Iterator
+from typing import Dict
 
 from django.template.base import Origin
 from django.template.engine import Engine
@@ -6,8 +6,6 @@ from django.template.engine import Engine
 from .base import Loader as BaseLoader
 
 class Loader(BaseLoader):
-    engine: Engine
     templates_dict: Dict[str, str] = ...
     def __init__(self, engine: Engine, templates_dict: Dict[str, str]) -> None: ...
     def get_contents(self, origin: Origin) -> str: ...
-    def get_template_sources(self, template_name: str) -> Iterator[Origin]: ...

django-stubs/templatetags/cache.pyi

@@ -1,15 +1,12 @@
 from typing import Any, List, Optional
 
-from django.template import Node
 from django.template.base import FilterExpression, NodeList, Parser, Token
-from django.template.context import Context
-from django.utils.safestring import SafeText
+
+from django.template import Node
 
 register: Any
 
 class CacheNode(Node):
-    origin: Origin
-    token: Token
     nodelist: NodeList = ...
     expire_time_var: FilterExpression = ...
     fragment_name: str = ...
@@ -23,6 +20,5 @@ class CacheNode(Node):
         vary_on: List[FilterExpression],
         cache_name: Optional[FilterExpression],
     ) -> None: ...
-    def render(self, context: Context) -> SafeText: ...
 
 def do_cache(parser: Parser, token: Token) -> CacheNode: ...

django-stubs/templatetags/i18n.pyi

@@ -1,53 +1,35 @@
 from typing import Any, Dict, List, Optional, Tuple
 
-from django.template import Node
 from django.template.base import FilterExpression, NodeList, Parser, Token
-from django.template.context import Context, RequestContext
-from django.utils.safestring import SafeText
+
+from django.template import Node
 
 register: Any
 
 class GetAvailableLanguagesNode(Node):
-    origin: Origin
-    token: Token
     variable: str = ...
     def __init__(self, variable: str) -> None: ...
-    def render(self, context: Context) -> str: ...
 
 class GetLanguageInfoNode(Node):
-    origin: Origin
-    token: Token
     lang_code: FilterExpression = ...
     variable: str = ...
     def __init__(self, lang_code: FilterExpression, variable: str) -> None: ...
-    def render(self, context: Context) -> str: ...
 
 class GetLanguageInfoListNode(Node):
-    origin: Origin
-    token: Token
     languages: FilterExpression = ...
     variable: str = ...
     def __init__(self, languages: FilterExpression, variable: str) -> None: ...
     def get_language_info(self, language: Any): ...
-    def render(self, context: Context) -> str: ...
 
 class GetCurrentLanguageNode(Node):
-    origin: Origin
-    token: Token
     variable: str = ...
     def __init__(self, variable: str) -> None: ...
-    def render(self, context: RequestContext) -> str: ...
 
 class GetCurrentLanguageBidiNode(Node):
-    origin: Origin
-    token: Token
     variable: str = ...
     def __init__(self, variable: str) -> None: ...
-    def render(self, context: RequestContext) -> str: ...
 
 class TranslateNode(Node):
-    origin: Origin
-    token: Token
     noop: bool = ...
     asvar: Optional[str] = ...
     message_context: Optional[FilterExpression] = ...
@@ -59,11 +41,8 @@ class TranslateNode(Node):
         asvar: Optional[str] = ...,
         message_context: Optional[FilterExpression] = ...,
     ) -> None: ...
-    def render(self, context: Context) -> str: ...
 
 class BlockTranslateNode(Node):
-    origin: Origin
-    token: Token
     extra_context: Dict[str, FilterExpression] = ...
     singular: List[Token] = ...
     plural: List[Token] = ...
@@ -84,15 +63,11 @@ class BlockTranslateNode(Node):
         asvar: Optional[str] = ...,
     ) -> None: ...
     def render_token_list(self, tokens: List[Token]) -> Tuple[str, List[str]]: ...
-    def render(self, context: Context, nested: bool = ...) -> str: ...
 
 class LanguageNode(Node):
-    origin: Origin
-    token: Token
     nodelist: NodeList = ...
     language: FilterExpression = ...
     def __init__(self, nodelist: NodeList, language: FilterExpression) -> None: ...
-    def render(self, context: Context) -> SafeText: ...
 
 def do_get_available_languages(parser: Parser, token: Token) -> GetAvailableLanguagesNode: ...
 def do_get_language_info(parser: Parser, token: Token) -> GetLanguageInfoNode: ...

django-stubs/templatetags/l10n.pyi

@@ -1,22 +1,17 @@
-from datetime import date
-from typing import Any, List, Optional, Union
+from typing import Any, List
+
+from django.template.base import Parser, Token
 
 from django.template import Node
-from django.template.base import NodeList, Parser, Token
-from django.template.context import Context
-from django.utils.safestring import SafeText
 
 register: Any
 
-def localize(value: Union[date, float]) -> str: ...
-def unlocalize(value: Union[date, float]) -> str: ...
+def localize(value: Any) -> str: ...
+def unlocalize(value: Any) -> str: ...
 
 class LocalizeNode(Node):
-    origin: Origin
-    token: Token
-    nodelist: Union[List[Any], NodeList] = ...
+    nodelist: List[Node] = ...
     use_l10n: bool = ...
-    def __init__(self, nodelist: Union[List[Any], NodeList], use_l10n: bool) -> None: ...
-    def render(self, context: Context) -> SafeText: ...
+    def __init__(self, nodelist: List[Node], use_l10n: bool) -> None: ...
 
 def localize_tag(parser: Parser, token: Token) -> LocalizeNode: ...

django-stubs/templatetags/static.pyi

@@ -1,14 +1,13 @@
 from typing import Any, Optional
 
-from django import template
 from django.template.base import FilterExpression, Parser, Token
 from django.template.context import Context
 
+from django import template
+
 register: Any
 
 class PrefixNode(template.Node):
-    origin: Origin
-    token: Token
     varname: Optional[str] = ...
     name: str = ...
     def __init__(self, varname: Optional[str] = ..., name: str = ...) -> None: ...
@@ -16,19 +15,15 @@ class PrefixNode(template.Node):
     def handle_token(cls, parser: Parser, token: Token, name: str) -> PrefixNode: ...
     @classmethod
     def handle_simple(cls, name: str) -> str: ...
-    def render(self, context: Context) -> str: ...
 
 def get_static_prefix(parser: Parser, token: Token) -> PrefixNode: ...
 def get_media_prefix(parser: Parser, token: Token) -> PrefixNode: ...
 
 class StaticNode(template.Node):
-    origin: Origin
-    token: Token
     path: FilterExpression = ...
     varname: Optional[str] = ...
     def __init__(self, varname: Optional[str] = ..., path: FilterExpression = ...) -> None: ...
     def url(self, context: Context) -> str: ...
-    def render(self, context: Context) -> str: ...
     @classmethod
     def handle_simple(cls, path: str) -> str: ...
     @classmethod

django-stubs/templatetags/tz.pyi

@@ -1,44 +1,32 @@
 from datetime import datetime
 from typing import Any, Optional, Union
 
-from django.template import Node
 from django.template.base import FilterExpression, NodeList, Parser, Token
-from django.template.context import Context
-from django.utils.safestring import SafeText
 from django.utils.timezone import FixedOffset
 
+from django.template import Node
+
 register: Any
 
 class datetimeobject(datetime): ...
 
-def localtime(value: Optional[Union[datetime, str]]) -> Union[datetimeobject, str]: ...
-def utc(value: Optional[Union[datetime, str]]) -> Union[datetimeobject, str]: ...
-def do_timezone(
-    value: Optional[Union[datetime, str]], arg: Optional[Union[FixedOffset, str]]
-) -> Union[datetimeobject, str]: ...
+def localtime(value: Optional[Union[datetime, str]]) -> Any: ...
+def utc(value: Optional[Union[datetime, str]]) -> Any: ...
+def do_timezone(value: Optional[Union[datetime, str]], arg: Optional[Union[FixedOffset, str]]) -> Any: ...
 
 class LocalTimeNode(Node):
-    origin: Origin
-    token: Token
     nodelist: NodeList = ...
     use_tz: bool = ...
     def __init__(self, nodelist: NodeList, use_tz: bool) -> None: ...
-    def render(self, context: Context) -> SafeText: ...
 
 class TimezoneNode(Node):
-    origin: Origin
-    token: Token
     nodelist: NodeList = ...
     tz: FilterExpression = ...
     def __init__(self, nodelist: NodeList, tz: FilterExpression) -> None: ...
-    def render(self, context: Context) -> SafeText: ...
 
 class GetCurrentTimezoneNode(Node):
-    origin: Origin
-    token: Token
     variable: str = ...
     def __init__(self, variable: str) -> None: ...
-    def render(self, context: Context) -> str: ...
 
 def localtime_tag(parser: Parser, token: Token) -> LocalTimeNode: ...
 def timezone_tag(parser: Parser, token: Token) -> TimezoneNode: ...

django-stubs/test/html.pyi

@@ -31,15 +31,8 @@ class Parser(HTMLParser):
     open_tags: Any = ...
     element_positions: Any = ...
     def __init__(self) -> None: ...
-    def error(self, msg: str) -> Any: ...
-    def format_position(self, position: None = ..., element: None = ...) -> str: ...
+    def format_position(self, position: Any = ..., element: Any = ...) -> str: ...
     @property
     def current(self) -> Element: ...
-    def handle_startendtag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ...
-    def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ...
-    def handle_endtag(self, tag: str) -> None: ...
-    def handle_data(self, data: str) -> None: ...
-    def handle_charref(self, name: str) -> None: ...
-    def handle_entityref(self, name: str) -> None: ...
 
 def parse_html(html: str) -> Element: ...

django-stubs/utils/archive.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Iterator, List, Optional, Tuple, Union
+from typing import Any, Dict, Iterable, Sequence, Type
 
 class ArchiveException(Exception): ...
 class UnrecognizedArchiveFormat(ArchiveException): ...
@@ -14,21 +14,17 @@ class Archive:
     def close(self) -> None: ...
 
 class BaseArchive:
-    def split_leading_dir(self, path: str) -> Union[List[str], Tuple[str, str]]: ...
-    def has_leading_dir(self, paths: Union[Iterator[Any], List[str]]) -> bool: ...
-    def extract(self) -> None: ...
-    def list(self) -> None: ...
+    def split_leading_dir(self, path: str) -> Sequence[str]: ...
+    def has_leading_dir(self, paths: Iterable[str]) -> bool: ...
+    def extract(self, to_path: str) -> None: ...
+    def list(self, *args: Any, **kwargs: Any) -> None: ...
 
 class TarArchive(BaseArchive):
     def __init__(self, file: str) -> None: ...
-    def list(self, *args: Any, **kwargs: Any) -> None: ...
-    def extract(self, to_path: str) -> None: ...
     def close(self) -> None: ...
 
 class ZipArchive(BaseArchive):
     def __init__(self, file: str) -> None: ...
-    def list(self, *args: Any, **kwargs: Any) -> None: ...
-    def extract(self, to_path: str) -> None: ...
     def close(self) -> None: ...
 
-extension_map: Any
+extension_map: Dict[str, Type[BaseArchive]]

django-stubs/utils/datetime_safe.pyi

@@ -1,17 +1,8 @@
-from datetime import date as real_date
-from datetime import datetime as real_datetime
-from datetime import time as real_time
-from typing import Any, Optional, Union
-
-class date(real_date):
-    def strftime(self, fmt: str) -> str: ...
-
-class datetime(real_datetime):
-    def strftime(self, fmt: str) -> str: ...
-    @classmethod
-    def combine(cls, date: Any, time: Any): ...
-    def date(self): ...
+from datetime import date as real_date, datetime as real_datetime, time as real_time
+from typing import Union
 
+class date(real_date): ...
+class datetime(real_datetime): ...
 class time(real_time): ...
 
 def new_date(d: date) -> date: ...

django-stubs/utils/decorators.pyi

@@ -1,23 +1,13 @@
 from typing import Any, Callable, Optional, Set, Tuple, Type, Union
 
-from django.contrib.auth.mixins import AccessMixin
-from django.contrib.messages.views import SuccessMessageMixin
-from django.middleware.cache import CacheMiddleware
-from django.test.testcases import LiveServerTestCase
 from django.utils.deprecation import MiddlewareMixin
-from django.views.generic.base import TemplateResponseMixin, View
 
-class classonlymethod(classmethod):
-    def __get__(
-        self,
-        instance: Optional[View],
-        cls: Type[Union[AccessMixin, SuccessMessageMixin, TemplateResponseMixin, View]] = ...,
-    ) -> Callable: ...
+class classonlymethod(classmethod): ...
 
 def method_decorator(
     decorator: Union[Callable, Set[Callable], Tuple[Callable, Callable]], name: str = ...
 ) -> Callable: ...
-def decorator_from_middleware_with_args(middleware_class: Type[CacheMiddleware]) -> Callable: ...
+def decorator_from_middleware_with_args(middleware_class: Type[MiddlewareMixin]) -> Callable: ...
 def decorator_from_middleware(middleware_class: Type[MiddlewareMixin]) -> Callable: ...
 def available_attrs(fn: Any): ...
 def make_middleware_decorator(middleware_class: Type[MiddlewareMixin]) -> Callable: ...
@@ -25,5 +15,5 @@ def make_middleware_decorator(middleware_class: Type[MiddlewareMixin]) -> Callab
 class classproperty:
     fget: Optional[Callable] = ...
     def __init__(self, method: Optional[Callable] = ...) -> None: ...
-    def __get__(self, instance: Optional[LiveServerTestCase], cls: Type[LiveServerTestCase] = ...) -> str: ...
+    def __get__(self, instance: Any, cls: Optional[type] = ...) -> Any: ...
     def getter(self, method: Callable) -> classproperty: ...

django-stubs/utils/feedgenerator.pyi

@@ -1,17 +1,14 @@
 from datetime import date, datetime
-from io import StringIO
 from typing import Any, Dict, List, Optional, Tuple, Union
-
-from django.http.response import HttpResponse
-from django.utils.xmlutils import SimplerXMLGenerator
+from xml.sax import ContentHandler  # type: ignore
 
 def rfc2822_date(date: date) -> str: ...
 def rfc3339_date(date: date) -> str: ...
 def get_tag_uri(url: str, date: Optional[date]) -> str: ...
 
 class SyndicationFeed:
-    feed: Any = ...
-    items: Any = ...
+    feed: Dict[str, Any] = ...
+    items: List[Dict[str, Any]] = ...
     def __init__(
         self,
         title: str,
@@ -50,58 +47,30 @@ class SyndicationFeed:
     ) -> None: ...
     def num_items(self): ...
     def root_attributes(self) -> Dict[Any, Any]: ...
-    def add_root_elements(self, handler: Any) -> None: ...
+    def add_root_elements(self, handler: ContentHandler) -> None: ...
     def item_attributes(self, item: Dict[str, Any]) -> Dict[Any, Any]: ...
-    def add_item_elements(self, handler: Any, item: Any) -> None: ...
+    def add_item_elements(self, handler: ContentHandler, item: Dict[str, Any]) -> None: ...
     def write(self, outfile: Any, encoding: Any) -> None: ...
     def writeString(self, encoding: str) -> str: ...
     def latest_post_date(self) -> datetime: ...
 
 class Enclosure:
-    length: Union[int, str]
+    length: Any
     mime_type: str
     url: str = ...
     def __init__(self, url: str, length: Union[int, str], mime_type: str) -> None: ...
 
 class RssFeed(SyndicationFeed):
     content_type: str = ...
-    def write(self, outfile: Union[StringIO, HttpResponse], encoding: str) -> None: ...
-    def rss_attributes(self) -> Dict[str, str]: ...
-    def write_items(self, handler: SimplerXMLGenerator) -> None: ...
-    def add_root_elements(self, handler: SimplerXMLGenerator) -> None: ...
-    def endChannelElement(self, handler: SimplerXMLGenerator) -> None: ...
+    def write_items(self, handler: ContentHandler) -> None: ...
+    def endChannelElement(self, handler: ContentHandler) -> None: ...
 
-class RssUserland091Feed(RssFeed):
-    feed: Dict[str, Optional[Union[List[str], str]]]
-    items: List[Dict[str, Optional[Union[List[str], Tuple, datetime.datetime, str]]]]
-    def add_item_elements(
-        self, handler: SimplerXMLGenerator, item: Dict[str, Optional[Union[List[str], Tuple, datetime, str]]]
-    ) -> None: ...
-
-class Rss201rev2Feed(RssFeed):
-    feed: Dict[str, Optional[Union[List[str], Tuple, str]]]
-    items: Union[
-        List[Dict[str, Any]],
-        List[Dict[str, Optional[Union[List[django.utils.feedgenerator.Enclosure], List[str], datetime.datetime, str]]]],
-    ]
-    def add_item_elements(self, handler: SimplerXMLGenerator, item: Dict[str, Any]) -> None: ...
+class RssUserland091Feed(RssFeed): ...
+class Rss201rev2Feed(RssFeed): ...
 
 class Atom1Feed(SyndicationFeed):
-    feed: Dict[str, Optional[Union[List[str], Tuple, str]]]
-    items: Union[
-        List[Dict[str, Optional[Union[List[django.utils.feedgenerator.Enclosure], List[str], datetime.datetime, str]]]],
-        List[Dict[str, Optional[Union[List[str], Tuple, datetime.datetime, str]]]],
-    ]
     content_type: str = ...
     ns: str = ...
-    def write(self, outfile: Union[StringIO, HttpResponse], encoding: str) -> None: ...
-    def root_attributes(self) -> Dict[str, str]: ...
-    def add_root_elements(self, handler: SimplerXMLGenerator) -> None: ...
-    def write_items(self, handler: SimplerXMLGenerator) -> None: ...
-    def add_item_elements(
-        self,
-        handler: SimplerXMLGenerator,
-        item: Dict[str, Optional[Union[List[Enclosure], List[str], Tuple, datetime, str]]],
-    ) -> None: ...
+    def write_items(self, handler: ContentHandler) -> None: ...
 
 DefaultFeed = Rss201rev2Feed

django-stubs/utils/itercompat.pyi

@@ -1,18 +1,3 @@
-from tempfile import _TemporaryFileWrapper
-from typing import Any, List, Optional, Tuple, Union
+from typing import Any
 
-from django.core.checks.messages import CheckMessage
-
-def is_iterable(
-    x: Optional[
-        Union[
-            List[List[Union[List[List[Union[List[List[str]], str]]], str]]],
-            List[Tuple[Optional[Union[int, str]], Union[int, str]]],
-            List[CheckMessage],
-            List[int],
-            List[str],
-            Tuple[Union[Tuple[str, str], _TemporaryFileWrapper]],
-            int,
-        ]
-    ]
-) -> bool: ...
+def is_iterable(x: Any) -> bool: ...

django-stubs/utils/log.pyi

@@ -2,7 +2,6 @@ import logging.config
 from logging import LogRecord
 from typing import Any, Callable, Dict, Optional, Union
 
-from django.core.mail.backends.locmem import EmailBackend
 from django.core.management.color import Style
 
 request_logger: Any
@@ -15,7 +14,7 @@ class AdminEmailHandler(logging.Handler):
     email_backend: Optional[str] = ...
     def __init__(self, include_html: bool = ..., email_backend: Optional[str] = ...) -> None: ...
     def send_mail(self, subject: str, message: str, *args: Any, **kwargs: Any) -> None: ...
-    def connection(self) -> EmailBackend: ...
+    def connection(self) -> Any: ...
     def format_subject(self, subject: str) -> str: ...
 
 class CallbackFilter(logging.Filter):

django-stubs/utils/six.pyi

@@ -1,144 +1,106 @@
-import types
-from typing import Any, Optional
+from __future__ import print_function
 
-PY2: Any
-PY3: Any
-PY34: Any
-string_types: Any
-integer_types: Any
-class_types: Any
+import types
+import typing
+import unittest
+from typing import (
+    Any,
+    AnyStr,
+    Callable,
+    Dict,
+    ItemsView,
+    Iterable,
+    KeysView,
+    Mapping,
+    NoReturn,
+    Optional,
+    Pattern,
+    Text,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    ValuesView,
+    overload,
+)
+
+# Exports
+
+_T = TypeVar("_T")
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+# TODO make constant, then move this stub to 2and3
+# https://github.com/python/typeshed/issues/17
+PY2 = False
+PY3 = True
+PY34 = ...  # type: bool
+
+string_types = (str,)
+integer_types = (int,)
+class_types = (type,)
 text_type = str
 binary_type = bytes
-MAXSIZE: Any
-text_type = unicode
-binary_type = str
 
-class X:
-    def __len__(self): ...
+MAXSIZE = ...  # type: int
 
-class _LazyDescr:
-    name: Any = ...
-    def __init__(self, name: Any) -> None: ...
-    def __get__(self, obj: Any, tp: Any): ...
+# def add_move
+# def remove_move
 
-class MovedModule(_LazyDescr):
-    mod: Any = ...
-    def __init__(self, name: Any, old: Any, new: Optional[Any] = ...) -> None: ...
-    def __getattr__(self, attr: Any): ...
-
-class _LazyModule(types.ModuleType):
-    __doc__: Any = ...
-    def __init__(self, name: Any) -> None: ...
-    def __dir__(self): ...
-
-class MovedAttribute(_LazyDescr):
-    mod: Any = ...
-    attr: Any = ...
-    def __init__(
-        self, name: Any, old_mod: Any, new_mod: Any, old_attr: Optional[Any] = ..., new_attr: Optional[Any] = ...
-    ) -> None: ...
-
-class _SixMetaPathImporter:
-    name: Any = ...
-    known_modules: Any = ...
-    def __init__(self, six_module_name: Any) -> None: ...
-    def find_module(self, fullname: Any, path: Optional[Any] = ...): ...
-    def load_module(self, fullname: Any): ...
-    def is_package(self, fullname: Any): ...
-    def get_code(self, fullname: Any): ...
-    get_source: Any = ...
-
-class _MovedItems(_LazyModule):
-    __path__: Any = ...
-
-moves: Any
-
-class Module_six_moves_urllib_parse(_LazyModule): ...
-class Module_six_moves_urllib_error(_LazyModule): ...
-class Module_six_moves_urllib_request(_LazyModule): ...
-class Module_six_moves_urllib_response(_LazyModule): ...
-class Module_six_moves_urllib_robotparser(_LazyModule): ...
-
-class Module_six_moves_urllib(types.ModuleType):
-    __path__: Any = ...
-    parse: Any = ...
-    error: Any = ...
-    request: Any = ...
-    response: Any = ...
-    robotparser: Any = ...
-    def __dir__(self): ...
-
-def add_move(move: Any) -> None: ...
-def remove_move(name: Any) -> None: ...
-
-advance_iterator = next
-next = advance_iterator
-callable = callable
-
-def get_unbound_function(unbound: Any): ...
-
-create_bound_method: Any
-
-def create_unbound_method(func: Any, cls: Any): ...
+def callable(obj: object) -> bool: ...
+def get_unbound_function(unbound: types.FunctionType) -> types.FunctionType: ...
+def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ...
+def create_unbound_method(func: types.FunctionType, cls: type) -> types.FunctionType: ...
 
 Iterator = object
 
-class Iterator:
-    def next(self): ...
+def get_method_function(meth: types.MethodType) -> types.FunctionType: ...
+def get_method_self(meth: types.MethodType) -> Optional[object]: ...
+def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ...
+def get_function_code(fun: types.FunctionType) -> types.CodeType: ...
+def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ...
+def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ...
+def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ...
+def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ...
+def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ...
 
-callable = callable
-get_method_function: Any
-get_method_self: Any
-get_function_closure: Any
-get_function_code: Any
-get_function_defaults: Any
-get_function_globals: Any
+# def iterlists
 
-def iterkeys(d: Any, **kw: Any): ...
-def itervalues(d: Any, **kw: Any): ...
-def iteritems(d: Any, **kw: Any): ...
-def iterlists(d: Any, **kw: Any): ...
-
-viewkeys: Any
-viewvalues: Any
-viewitems: Any
-
-def b(s: Any): ...
-def u(s: Any): ...
+def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ...
+def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ...
+def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ...
+def b(s: str) -> binary_type: ...
+def u(s: str) -> text_type: ...
 
 unichr = chr
-int2byte: Any
-byte2int: Any
-indexbytes: Any
-iterbytes = iter
-StringIO: Any
-BytesIO: Any
-unichr = unichr
-int2byte = chr
 
-def assertCountEqual(self, *args: Any, **kwargs: Any): ...
-def assertRaisesRegex(self, *args: Any, **kwargs: Any): ...
-def assertRegex(self, *args: Any, **kwargs: Any): ...
+def int2byte(i: int) -> bytes: ...
+def byte2int(bs: binary_type) -> int: ...
+def indexbytes(buf: binary_type, i: int) -> int: ...
+def iterbytes(buf: binary_type) -> typing.Iterator[int]: ...
+def assertCountEqual(
+    self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: Optional[str] = ...
+) -> None: ...
+@overload
+def assertRaisesRegex(self: unittest.TestCase, msg: Optional[str] = ...) -> Any: ...
+@overload
+def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ...
+def assertRegex(
+    self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Optional[str] = ...
+) -> None: ...
 
-exec_: Any
+exec_ = exec
 
-def reraise(tp: Any, value: Any, tb: Optional[Any] = ...) -> None: ...
-def raise_from(value: Any, from_value: Any) -> None: ...
+def reraise(
+    tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ...
+) -> NoReturn: ...
+def raise_from(value: Union[BaseException, Type[BaseException]], from_value: Optional[BaseException]) -> NoReturn: ...
 
-print_: Any
-_print = print_
+print_ = print
 
-def wraps(wrapped: Any, assigned: Any = ..., updated: Any = ...): ...
-
-wraps: Any
-
-def with_metaclass(meta: Any, *bases: Any): ...
-def add_metaclass(metaclass: Any): ...
-def python_2_unicode_compatible(klass: Any): ...
-
-__path__: Any
-__package__ = __name__
-memoryview = memoryview
-buffer_types: Any
-memoryview = memoryview
-memoryview = buffer
+def with_metaclass(meta: type, *bases: type) -> type: ...
+def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ...
+def ensure_binary(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> bytes: ...
+def ensure_str(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> str: ...
+def ensure_text(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> Text: ...
+def python_2_unicode_compatible(klass: _T) -> _T: ...

django-stubs/utils/text.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Iterator, List, Optional, Union
+from typing import Any, Iterable, Iterator, List, Optional, Union
 
 from django.db.models.base import Model
 from django.utils.functional import SimpleLazyObject
@@ -34,7 +34,7 @@ class StreamingBuffer:
     def flush(self): ...
     def close(self): ...
 
-def compress_sequence(sequence: Union[List[bytes], map]) -> Iterator[bytes]: ...
+def compress_sequence(sequence: Iterable[bytes]) -> Iterator[bytes]: ...
 
 smart_split_re: Any
 

django-stubs/utils/timezone.pyi

@@ -1,8 +1,8 @@
-# Stubs for django.utils.timezone (Python 3.5)
-
-from typing import Any, Optional, Union
-from datetime import tzinfo as tzinfo, datetime as datetime, timedelta as timedelta
 from contextlib import ContextDecorator
+from datetime import datetime as datetime, time, timedelta as timedelta, tzinfo as tzinfo
+from typing import Optional, Union
+
+_AnyTime = Union[time, datetime]
 
 class UTC(tzinfo):
     def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
@@ -16,9 +16,9 @@ class FixedOffset(tzinfo):
     def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
 
 class ReferenceLocalTimezone(tzinfo):
-    STDOFFSET = ...  # type: timedelta
-    DSTOFFSET = ...  # type: timedelta
-    DSTDIFF = ...  # type: timedelta
+    STDOFFSET: timedelta = ...
+    DSTOFFSET: timedelta = ...
+    DSTDIFF: timedelta = ...
     def __init__(self) -> None: ...
     def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
     def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
@@ -27,7 +27,7 @@ class ReferenceLocalTimezone(tzinfo):
 class LocalTimezone(ReferenceLocalTimezone):
     def tzname(self, dt: Optional[datetime]) -> str: ...
 
-utc = ...  # type: UTC
+utc: UTC = ...
 
 def get_fixed_timezone(offset: Union[timedelta, int]) -> tzinfo: ...
 def get_default_timezone() -> tzinfo: ...
@@ -38,15 +38,15 @@ def activate(timezone: tzinfo) -> None: ...
 def deactivate() -> None: ...
 
 class override(ContextDecorator):
-    timezone = ...  # type: tzinfo
-    old_timezone = ...  # type: tzinfo
+    timezone: tzinfo = ...
+    old_timezone: tzinfo = ...
     def __init__(self, timezone: tzinfo) -> None: ...
     def __enter__(self) -> None: ...
     def __exit__(self, exc_type: object, exc_value: object, traceback: object) -> None: ...
 
-def localtime(value: datetime, timezone: tzinfo = None) -> datetime: ...
+def localtime(value: _AnyTime, timezone: Optional[tzinfo] = None) -> datetime: ...
 def now() -> datetime: ...
-def is_aware(value: datetime) -> bool: ...
-def is_naive(value: datetime) -> bool: ...
-def make_aware(value: datetime, timezone: tzinfo = None, is_dst: bool = None) -> datetime: ...
-def make_naive(value: datetime, timezone: tzinfo = None) -> datetime: ...
+def is_aware(value: _AnyTime) -> bool: ...
+def is_naive(value: _AnyTime) -> bool: ...
+def make_aware(value: _AnyTime, timezone: Optional[tzinfo] = None, is_dst: Optional[bool] = None) -> datetime: ...
+def make_naive(value: _AnyTime, timezone: Optional[tzinfo] = None) -> datetime: ...

django-stubs/views/decorators/gzip.pyi

@@ -0,0 +1,5 @@
+from typing import Callable, TypeVar
+
+_C = TypeVar("_C", bound=Callable)
+
+def gzip_page(view_func: _C) -> _C: ...

django-stubs/views/generic/list.pyi

@@ -11,7 +11,7 @@ class MultipleObjectMixin(ContextMixin):
     allow_empty: bool = ...
     queryset: Optional[QuerySet] = ...
     model: Optional[Type[Model]] = ...
-    paginate_by: Optional[int] = ...
+    paginate_by: int = ...
     paginate_orphans: int = ...
     context_object_name: Optional[str] = ...
     paginator_class: Type[Paginator] = ...

mypy_django_plugin/config.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass
 class Config:
     django_settings_module: Optional[str] = None
     ignore_missing_settings: bool = False
+    ignore_missing_model_attributes: bool = False
 
     @classmethod
     def from_config_file(cls, fpath: str) -> 'Config':
@@ -22,5 +23,9 @@ class Config:
             django_settings = django_settings.strip()
 
         return Config(django_settings_module=django_settings,
-                      ignore_missing_settings=bool(ini_config.get('mypy_django_plugin', 'ignore_missing_settings',
-                                                                  fallback=False)))
+                      ignore_missing_settings=bool(ini_config.get('mypy_django_plugin',
+                                                                  'ignore_missing_settings',
+                                                                  fallback=False)),
+                      ignore_missing_model_attributes=bool(ini_config.get('mypy_django_plugin',
+                                                                          'ignore_missing_model_attributes',
+                                                                          fallback=False)))

mypy_django_plugin/helpers.py

@@ -1,15 +1,20 @@
 import typing
-from typing import Dict, Optional
+from collections import OrderedDict
+from typing import Dict, Optional, cast
 
-from mypy.checker import TypeChecker
+from mypy.mro import calculate_mro
 from mypy.nodes import (
-    AssignmentStmt, ClassDef, Expression, ImportedName, Lvalue, MypyFile, NameExpr, SymbolNode, TypeInfo,
+    GDEF, MDEF, AssignmentStmt, Block, CallExpr, ClassDef, Expression, ImportedName, Lvalue, MypyFile, NameExpr,
+    SymbolNode, SymbolTable, SymbolTableNode, TypeInfo, Var,
 )
-from mypy.plugin import FunctionContext, MethodContext
+from mypy.plugin import CheckerPluginInterface, FunctionContext, MethodContext
 from mypy.types import (
-    AnyType, Instance, NoneTyp, Type, TypeOfAny, TypeVarType, UnionType,
+    AnyType, Instance, NoneTyp, TupleType, Type, TypedDictType, TypeOfAny, TypeVarType, UnionType,
 )
 
+if typing.TYPE_CHECKING:
+    from mypy.checker import TypeChecker
+
 MODEL_CLASS_FULLNAME = 'django.db.models.base.Model'
 FIELD_FULLNAME = 'django.db.models.fields.Field'
 CHAR_FIELD_FULLNAME = 'django.db.models.fields.CharField'
@@ -163,7 +168,7 @@ def get_argument_type_by_name(ctx: typing.Union[FunctionContext, MethodContext],
     return arg_types[0]
 
 
-def get_setting_expr(api: TypeChecker, setting_name: str) -> Optional[Expression]:
+def get_setting_expr(api: 'TypeChecker', setting_name: str) -> Optional[Expression]:
     try:
         settings_sym = api.modules['django.conf'].names['settings']
     except KeyError:
@@ -211,7 +216,8 @@ def extract_field_setter_type(tp: Instance) -> Optional[Type]:
     return None
 
 
-def extract_field_getter_type(tp: Instance) -> Optional[Type]:
+def extract_field_getter_type(tp: Type) -> Optional[Type]:
+    """ Extract return type of __get__ of subclass of Field"""
     if not isinstance(tp, Instance):
         return None
     if tp.type.has_base(FIELD_FULLNAME):
@@ -222,19 +228,26 @@ def extract_field_getter_type(tp: Instance) -> Optional[Type]:
     return None
 
 
-def get_django_metadata(model: TypeInfo) -> Dict[str, typing.Any]:
-    return model.metadata.setdefault('django', {})
+def get_django_metadata(model_info: TypeInfo) -> Dict[str, typing.Any]:
+    return model_info.metadata.setdefault('django', {})
 
 
 def get_related_field_primary_key_names(base_model: TypeInfo) -> typing.List[str]:
-    django_metadata = get_django_metadata(base_model)
-    return django_metadata.setdefault('related_field_primary_keys', [])
+    return get_django_metadata(base_model).setdefault('related_field_primary_keys', [])
 
 
 def get_fields_metadata(model: TypeInfo) -> Dict[str, typing.Any]:
     return get_django_metadata(model).setdefault('fields', {})
 
 
+def get_lookups_metadata(model: TypeInfo) -> Dict[str, typing.Any]:
+    return get_django_metadata(model).setdefault('lookups', {})
+
+
+def get_related_managers_metadata(model: TypeInfo) -> Dict[str, typing.Any]:
+    return get_django_metadata(model).setdefault('related_managers', {})
+
+
 def extract_explicit_set_type_of_model_primary_key(model: TypeInfo) -> Optional[Type]:
     """
     If field with primary_key=True is set on the model, extract its __set__ type.
@@ -296,3 +309,135 @@ def get_assigned_value_for_class(type_info: TypeInfo, name: str) -> Optional[Exp
         if isinstance(lvalue, NameExpr) and lvalue.name == name:
             return rvalue
     return None
+
+
+def is_field_nullable(model: TypeInfo, field_name: str) -> bool:
+    return get_fields_metadata(model).get(field_name, {}).get('null', False)
+
+
+def is_foreign_key_like(t: Type) -> bool:
+    if not isinstance(t, Instance):
+        return False
+    return has_any_of_bases(t.type, (FOREIGN_KEY_FULLNAME, ONETOONE_FIELD_FULLNAME))
+
+
+def build_class_with_annotated_fields(api: 'TypeChecker', base: Type, fields: 'OrderedDict[str, Type]',
+                                      name: str) -> Instance:
+    """Build an Instance with `name` that contains the specified `fields` as attributes and extends `base`."""
+    # Credit: This code is largely copied/modified from TypeChecker.intersect_instance_callable and
+    # NamedTupleAnalyzer.build_namedtuple_typeinfo
+    from mypy.checker import gen_unique_name
+
+    cur_module = cast(MypyFile, api.scope.stack[0])
+    gen_name = gen_unique_name(name, cur_module.names)
+
+    cdef = ClassDef(name, Block([]))
+    cdef.fullname = cur_module.fullname() + '.' + gen_name
+    info = TypeInfo(SymbolTable(), cdef, cur_module.fullname())
+    cdef.info = info
+    info.bases = [base]
+
+    def add_field(var: Var, is_initialized_in_class: bool = False,
+                  is_property: bool = False) -> None:
+        var.info = info
+        var.is_initialized_in_class = is_initialized_in_class
+        var.is_property = is_property
+        var._fullname = '%s.%s' % (info.fullname(), var.name())
+        info.names[var.name()] = SymbolTableNode(MDEF, var)
+
+    vars = [Var(item, typ) for item, typ in fields.items()]
+    for var in vars:
+        add_field(var, is_property=True)
+
+    calculate_mro(info)
+    info.calculate_metaclass_type()
+
+    cur_module.names[gen_name] = SymbolTableNode(GDEF, info, plugin_generated=True)
+    return Instance(info, [])
+
+
+def make_named_tuple(api: 'TypeChecker', fields: 'OrderedDict[str, Type]', name: str) -> Type:
+    if not fields:
+        # No fields specified, so fallback to a subclass of NamedTuple that allows
+        # __getattr__ / __setattr__ for any attribute name.
+        fallback = api.named_generic_type('django._NamedTupleAnyAttr', [])
+    else:
+        fallback = build_class_with_annotated_fields(
+            api=api,
+            base=api.named_generic_type('typing.NamedTuple', []),
+            fields=fields,
+            name=name
+        )
+    return TupleType(list(fields.values()), fallback=fallback)
+
+
+def make_typeddict(api: CheckerPluginInterface, fields: 'OrderedDict[str, Type]',
+                   required_keys: typing.Set[str]) -> TypedDictType:
+    object_type = api.named_generic_type('mypy_extensions._TypedDict', [])
+    typed_dict_type = TypedDictType(fields, required_keys=required_keys, fallback=object_type)
+    return typed_dict_type
+
+
+def make_tuple(api: 'TypeChecker', fields: typing.List[Type]) -> TupleType:
+    implicit_any = AnyType(TypeOfAny.special_form)
+    fallback = api.named_generic_type('builtins.tuple', [implicit_any])
+    return TupleType(fields, fallback=fallback)
+
+
+def get_private_descriptor_type(type_info: TypeInfo, private_field_name: str, is_nullable: bool) -> Type:
+    node = type_info.get(private_field_name).node
+    if isinstance(node, Var):
+        descriptor_type = node.type
+        if is_nullable:
+            descriptor_type = make_optional(descriptor_type)
+        return descriptor_type
+    return AnyType(TypeOfAny.unannotated)
+
+
+def iter_over_classdefs(module_file: MypyFile) -> typing.Iterator[ClassDef]:
+    for defn in module_file.defs:
+        if isinstance(defn, ClassDef):
+            yield defn
+
+
+def iter_call_assignments(klass: ClassDef) -> typing.Iterator[typing.Tuple[Lvalue, CallExpr]]:
+    for lvalue, rvalue in iter_over_assignments(klass):
+        if isinstance(rvalue, CallExpr):
+            yield lvalue, rvalue
+
+
+def get_related_manager_type_from_metadata(model_info: TypeInfo, related_manager_name: str,
+                                           api: CheckerPluginInterface) -> Optional[Instance]:
+    related_manager_metadata = get_related_managers_metadata(model_info)
+    if not related_manager_metadata:
+        return None
+
+    if related_manager_name not in related_manager_metadata:
+        return None
+
+    manager_class_name = related_manager_metadata[related_manager_name]['manager']
+    of = related_manager_metadata[related_manager_name]['of']
+    of_types = []
+    for of_type_name in of:
+        if of_type_name == 'any':
+            of_types.append(AnyType(TypeOfAny.implementation_artifact))
+        else:
+            try:
+                of_type = api.named_generic_type(of_type_name, [])
+            except AssertionError:
+                # Internal error: attempted lookup of unknown name
+                of_type = AnyType(TypeOfAny.implementation_artifact)
+
+            of_types.append(of_type)
+
+    return api.named_generic_type(manager_class_name, of_types)
+
+
+def get_primary_key_field_name(model_info: TypeInfo) -> Optional[str]:
+    for base in model_info.mro:
+        fields = get_fields_metadata(base)
+        for field_name, field_props in fields.items():
+            is_primary_key = field_props.get('primary_key', False)
+            if is_primary_key:
+                return field_name
+    return None