really drop universal

* Fix problem where Model instancess are not considered subtypes of each other due to fallback_to_any = True. Fixes #52.

- Added a stub for __getstate__ to Model.
- Added a stub for clean() to Model.
- Correct arg type for sort_dependencies so they are covariant (Iterable rather than List).

Test ignores:
- Added some test ignores in cases where a model inherits from 2 different base models.
- Added some test ignores for cases that MyPy flags as errors due to variable redefinitions or imports that are incompatible types.

* Address review comment.

.travis.yml

@@ -4,20 +4,34 @@ dist: xenial
 sudo: required
 jobs:
   include:
-    - name: Typecheck Django test suite
-      python: 3.7
-      script: 'python ./scripts/typecheck_tests.py'
-
     - name: Run plugin test suite with python 3.7
       python: 3.7
       script: |
         set -e
         pytest
 
+    - name: Run plugin test suite with python 3.6
+      python: 3.6
+      script: |
+        set -e
+        pytest
+
+    - name: Typecheck Django test suite
+      python: 3.7
+      script: 'python ./scripts/typecheck_tests.py'
+
     - name: Lint with black
       python: 3.7
       script: 'black --check --line-length=120 django-stubs/'
 
+    - name: Lint plugin code with flake8
+      python: 3.7
+      script: 'flake8'
+
+    - name: Lint plugin code with isort
+      python: 3.7
+      script: 'isort --check'
+
 before_install: |
   # Upgrade pip, setuptools, and wheel
   pip install -U pip setuptools wheel

dev-requirements.txt

@@ -1,3 +1,5 @@
 black
 pytest-mypy-plugins
+flake8
+isort==4.3.4
 -e .

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/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/options.pyi

@@ -1,5 +1,5 @@
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Type, Union, Iterator
+from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union
 
 from django.contrib.admin.filters import ListFilter
 from django.contrib.admin.models import LogEntry
@@ -8,7 +8,6 @@ from django.contrib.admin.views.main import ChangeList
 from django.contrib.auth.forms import AdminPasswordChangeForm
 from django.contrib.contenttypes.models import ContentType
 from django.core.checks.messages import Error
-from django.core.handlers.wsgi import WSGIRequest
 from django.core.paginator import Paginator
 from django.db.models.base import Model
 from django.db.models.fields.related import ForeignKey, ManyToManyField, RelatedField
@@ -17,12 +16,13 @@ from django.db.models.query import QuerySet
 from django.forms.fields import TypedChoiceField
 from django.forms.models import ModelChoiceField, ModelMultipleChoiceField
 from django.forms.widgets import Media
+from django.http.request import HttpRequest
 from django.http.response import HttpResponse, HttpResponseBase, HttpResponseRedirect, JsonResponse
+from django.template.response import TemplateResponse
 from django.urls.resolvers import URLPattern
 from django.utils.safestring import SafeText
 
 from django.db.models.fields import Field
-from django.template.response import TemplateResponse
 
 IS_POPUP_VAR: str
 TO_FIELD_VAR: str
@@ -58,40 +58,40 @@ class BaseModelAdmin:
     def check(self, **kwargs: Any) -> List[Union[str, Error]]: ...
     def __init__(self) -> None: ...
     def formfield_for_dbfield(
-        self, db_field: Field, request: Optional[WSGIRequest], **kwargs: Any
+        self, db_field: Field, request: Optional[HttpRequest], **kwargs: Any
     ) -> Optional[Field]: ...
     def formfield_for_choice_field(
-        self, db_field: Field, request: Optional[WSGIRequest], **kwargs: Any
+        self, db_field: Field, request: Optional[HttpRequest], **kwargs: Any
     ) -> TypedChoiceField: ...
     def get_field_queryset(
-        self, db: None, db_field: RelatedField, request: Optional[WSGIRequest]
+        self, db: None, db_field: RelatedField, request: Optional[HttpRequest]
     ) -> Optional[QuerySet]: ...
     def formfield_for_foreignkey(
-        self, db_field: ForeignKey, request: Optional[WSGIRequest], **kwargs: Any
+        self, db_field: ForeignKey, request: Optional[HttpRequest], **kwargs: Any
     ) -> Optional[ModelChoiceField]: ...
     def formfield_for_manytomany(
-        self, db_field: ManyToManyField, request: Optional[WSGIRequest], **kwargs: Any
+        self, db_field: ManyToManyField, request: Optional[HttpRequest], **kwargs: Any
     ) -> ModelMultipleChoiceField: ...
-    def get_autocomplete_fields(self, request: WSGIRequest) -> Tuple: ...
+    def get_autocomplete_fields(self, request: HttpRequest) -> Tuple: ...
     def get_view_on_site_url(self, obj: Optional[Model] = ...) -> Optional[str]: ...
     def get_empty_value_display(self) -> SafeText: ...
-    def get_exclude(self, request: WSGIRequest, obj: Optional[Model] = ...) -> Any: ...
-    def get_fields(self, request: WSGIRequest, obj: Optional[Model] = ...) -> Sequence[Union[Callable, str]]: ...
+    def get_exclude(self, request: HttpRequest, obj: Optional[Model] = ...) -> Any: ...
+    def get_fields(self, request: HttpRequest, obj: Optional[Model] = ...) -> Sequence[Union[Callable, str]]: ...
     def get_fieldsets(
-        self, request: WSGIRequest, obj: Optional[Model] = ...
+        self, request: HttpRequest, obj: Optional[Model] = ...
     ) -> List[Tuple[Optional[str], Dict[str, Any]]]: ...
-    def get_ordering(self, request: WSGIRequest) -> Union[List[str], Tuple]: ...
-    def get_readonly_fields(self, request: WSGIRequest, obj: Optional[Model] = ...) -> Union[List[str], Tuple]: ...
-    def get_prepopulated_fields(self, request: WSGIRequest, obj: Optional[Model] = ...) -> Dict[str, Tuple[str]]: ...
-    def get_queryset(self, request: WSGIRequest) -> QuerySet: ...
-    def get_sortable_by(self, request: WSGIRequest) -> Union[List[Callable], List[str], Tuple]: ...
+    def get_ordering(self, request: HttpRequest) -> Union[List[str], Tuple]: ...
+    def get_readonly_fields(self, request: HttpRequest, obj: Optional[Model] = ...) -> Union[List[str], Tuple]: ...
+    def get_prepopulated_fields(self, request: HttpRequest, obj: Optional[Model] = ...) -> Dict[str, Tuple[str]]: ...
+    def get_queryset(self, request: HttpRequest) -> QuerySet: ...
+    def get_sortable_by(self, request: HttpRequest) -> Union[List[Callable], List[str], Tuple]: ...
     def lookup_allowed(self, lookup: str, value: str) -> bool: ...
-    def to_field_allowed(self, request: WSGIRequest, to_field: str) -> bool: ...
-    def has_add_permission(self, request: WSGIRequest, obj: Optional[Model] = ...) -> bool: ...
-    def has_change_permission(self, request: WSGIRequest, obj: Optional[Model] = ...) -> bool: ...
-    def has_delete_permission(self, request: WSGIRequest, obj: Optional[Model] = ...) -> bool: ...
-    def has_view_permission(self, request: WSGIRequest, obj: Optional[Model] = ...) -> bool: ...
-    def has_module_permission(self, request: WSGIRequest) -> bool: ...
+    def to_field_allowed(self, request: HttpRequest, to_field: str) -> bool: ...
+    def has_add_permission(self, request: HttpRequest, obj: Optional[Model] = ...) -> bool: ...
+    def has_change_permission(self, request: HttpRequest, obj: Optional[Model] = ...) -> bool: ...
+    def has_delete_permission(self, request: HttpRequest, obj: Optional[Model] = ...) -> bool: ...
+    def has_view_permission(self, request: HttpRequest, obj: Optional[Model] = ...) -> bool: ...
+    def has_module_permission(self, request: HttpRequest) -> bool: ...
 
 class ModelAdmin(BaseModelAdmin):
     formfield_overrides: Any
@@ -127,54 +127,54 @@ class ModelAdmin(BaseModelAdmin):
     opts: Options = ...
     admin_site: AdminSite = ...
     def __init__(self, model: Type[Model], admin_site: Optional[AdminSite]) -> None: ...
-    def get_inline_instances(self, request: WSGIRequest, obj: Optional[Model] = ...) -> List[InlineModelAdmin]: ...
+    def get_inline_instances(self, request: HttpRequest, obj: Optional[Model] = ...) -> List[InlineModelAdmin]: ...
     def get_urls(self) -> List[URLPattern]: ...
     @property
     def urls(self) -> List[URLPattern]: ...
     @property
     def media(self) -> Media: ...
-    def get_model_perms(self, request: WSGIRequest) -> Dict[str, bool]: ...
+    def get_model_perms(self, request: HttpRequest) -> Dict[str, bool]: ...
     def get_form(self, request: Any, obj: Optional[Any] = ..., change: bool = ..., **kwargs: Any): ...
-    def get_changelist(self, request: WSGIRequest, **kwargs: Any) -> Type[ChangeList]: ...
-    def get_changelist_instance(self, request: WSGIRequest) -> ChangeList: ...
-    def get_object(self, request: WSGIRequest, object_id: str, from_field: None = ...) -> Optional[Model]: ...
+    def get_changelist(self, request: HttpRequest, **kwargs: Any) -> Type[ChangeList]: ...
+    def get_changelist_instance(self, request: HttpRequest) -> ChangeList: ...
+    def get_object(self, request: HttpRequest, object_id: str, from_field: None = ...) -> Optional[Model]: ...
     def get_changelist_form(self, request: Any, **kwargs: Any): ...
     def get_changelist_formset(self, request: Any, **kwargs: Any): ...
-    def get_formsets_with_inlines(self, request: WSGIRequest, obj: Optional[Model] = ...) -> Iterator[Any]: ...
+    def get_formsets_with_inlines(self, request: HttpRequest, obj: Optional[Model] = ...) -> Iterator[Any]: ...
     def get_paginator(
         self,
-        request: WSGIRequest,
+        request: HttpRequest,
         queryset: QuerySet,
         per_page: int,
         orphans: int = ...,
         allow_empty_first_page: bool = ...,
     ) -> Paginator: ...
-    def log_addition(self, request: WSGIRequest, object: Model, message: Any) -> LogEntry: ...
-    def log_change(self, request: WSGIRequest, object: Model, message: Any) -> LogEntry: ...
-    def log_deletion(self, request: WSGIRequest, object: Model, object_repr: str) -> LogEntry: ...
+    def log_addition(self, request: HttpRequest, object: Model, message: Any) -> LogEntry: ...
+    def log_change(self, request: HttpRequest, object: Model, message: Any) -> LogEntry: ...
+    def log_deletion(self, request: HttpRequest, object: Model, object_repr: str) -> LogEntry: ...
     def action_checkbox(self, obj: Model) -> SafeText: ...
-    def get_actions(self, request: WSGIRequest) -> OrderedDict: ...
+    def get_actions(self, request: HttpRequest) -> OrderedDict: ...
     def get_action_choices(
-        self, request: WSGIRequest, default_choices: List[Tuple[str, str]] = ...
+        self, request: HttpRequest, default_choices: List[Tuple[str, str]] = ...
     ) -> List[Tuple[str, str]]: ...
     def get_action(self, action: Union[Callable, str]) -> Tuple[Callable, str, str]: ...
-    def get_list_display(self, request: WSGIRequest) -> Sequence[str]: ...
-    def get_list_display_links(self, request: WSGIRequest, list_display: Sequence[str]) -> Optional[Sequence[str]]: ...
-    def get_list_filter(self, request: WSGIRequest) -> Sequence[str]: ...
-    def get_list_select_related(self, request: WSGIRequest) -> Sequence[str]: ...
-    def get_search_fields(self, request: WSGIRequest) -> List[str]: ...
+    def get_list_display(self, request: HttpRequest) -> Sequence[str]: ...
+    def get_list_display_links(self, request: HttpRequest, list_display: Sequence[str]) -> Optional[Sequence[str]]: ...
+    def get_list_filter(self, request: HttpRequest) -> Sequence[str]: ...
+    def get_list_select_related(self, request: HttpRequest) -> Sequence[str]: ...
+    def get_search_fields(self, request: HttpRequest) -> List[str]: ...
     def get_search_results(
-        self, request: WSGIRequest, queryset: QuerySet, search_term: str
+        self, request: HttpRequest, queryset: QuerySet, search_term: str
     ) -> Tuple[QuerySet, bool]: ...
-    def get_preserved_filters(self, request: WSGIRequest) -> str: ...
-    def _get_edited_object_pks(self, request: WSGIRequest, prefix: str) -> List[str]: ...
-    def _get_list_editable_queryset(self, request: WSGIRequest, prefix: str) -> QuerySet: ...
+    def get_preserved_filters(self, request: HttpRequest) -> str: ...
+    def _get_edited_object_pks(self, request: HttpRequest, prefix: str) -> List[str]: ...
+    def _get_list_editable_queryset(self, request: HttpRequest, prefix: str) -> QuerySet: ...
     def construct_change_message(
-        self, request: WSGIRequest, form: AdminPasswordChangeForm, formsets: None, add: bool = ...
+        self, request: HttpRequest, form: AdminPasswordChangeForm, formsets: None, add: bool = ...
     ) -> List[Dict[str, Dict[str, List[str]]]]: ...
     def message_user(
         self,
-        request: WSGIRequest,
+        request: HttpRequest,
         message: str,
         level: Union[int, str] = ...,
         extra_tags: str = ...,
@@ -182,8 +182,8 @@ class ModelAdmin(BaseModelAdmin):
     ) -> None: ...
     def save_form(self, request: Any, form: Any, change: Any): ...
     def save_model(self, request: Any, obj: Any, form: Any, change: Any) -> None: ...
-    def delete_model(self, request: WSGIRequest, obj: Model) -> None: ...
-    def delete_queryset(self, request: WSGIRequest, queryset: QuerySet) -> None: ...
+    def delete_model(self, request: HttpRequest, obj: Model) -> None: ...
+    def delete_queryset(self, request: HttpRequest, queryset: QuerySet) -> None: ...
     def save_formset(self, request: Any, form: Any, formset: Any, change: Any) -> None: ...
     def save_related(self, request: Any, form: Any, formsets: Any, change: Any) -> None: ...
     def render_change_form(
@@ -196,52 +196,51 @@ class ModelAdmin(BaseModelAdmin):
         obj: Optional[Any] = ...,
     ): ...
     def response_add(
-        self, request: WSGIRequest, obj: Model, post_url_continue: Optional[str] = ...
+        self, request: HttpRequest, obj: Model, post_url_continue: Optional[str] = ...
     ) -> HttpResponse: ...
-    def response_change(self, request: WSGIRequest, obj: Model) -> HttpResponse: ...
-    def response_post_save_add(self, request: WSGIRequest, obj: Model) -> HttpResponseRedirect: ...
-    def response_post_save_change(self, request: WSGIRequest, obj: Model) -> HttpResponseRedirect: ...
-    def response_action(self, request: WSGIRequest, queryset: QuerySet) -> Optional[HttpResponseBase]: ...
-    def response_delete(self, request: WSGIRequest, obj_display: str, obj_id: int) -> HttpResponse: ...
+    def response_change(self, request: HttpRequest, obj: Model) -> HttpResponse: ...
+    def response_post_save_add(self, request: HttpRequest, obj: Model) -> HttpResponseRedirect: ...
+    def response_post_save_change(self, request: HttpRequest, obj: Model) -> HttpResponseRedirect: ...
+    def response_action(self, request: HttpRequest, queryset: QuerySet) -> Optional[HttpResponseBase]: ...
+    def response_delete(self, request: HttpRequest, obj_display: str, obj_id: int) -> HttpResponse: ...
     def render_delete_form(self, request: Any, context: Any): ...
     def get_inline_formsets(
-        self, request: WSGIRequest, formsets: List[Any], inline_instances: List[Any], obj: Optional[Model] = ...
+        self, request: HttpRequest, formsets: List[Any], inline_instances: List[Any], obj: Optional[Model] = ...
     ) -> List[Any]: ...
-    def get_changeform_initial_data(self, request: WSGIRequest) -> Dict[str, str]: ...
+    def get_changeform_initial_data(self, request: HttpRequest) -> Dict[str, str]: ...
     def changeform_view(
         self,
-        request: WSGIRequest,
+        request: HttpRequest,
         object_id: Optional[str] = ...,
         form_url: str = ...,
         extra_context: Optional[Dict[str, bool]] = ...,
     ) -> Any: ...
-    def autocomplete_view(self, request: WSGIRequest) -> JsonResponse: ...
-    def add_view(self, request: WSGIRequest, form_url: str = ..., extra_context: None = ...) -> HttpResponse: ...
+    def autocomplete_view(self, request: HttpRequest) -> JsonResponse: ...
+    def add_view(self, request: HttpRequest, form_url: str = ..., extra_context: None = ...) -> HttpResponse: ...
     def change_view(
-        self, request: WSGIRequest, object_id: str, form_url: str = ..., extra_context: Optional[Dict[str, bool]] = ...
+        self, request: HttpRequest, object_id: str, form_url: str = ..., extra_context: Optional[Dict[str, bool]] = ...
     ) -> HttpResponse: ...
     def changelist_view(
-        self, request: WSGIRequest, extra_context: Optional[Dict[str, str]] = ...
+        self, request: HttpRequest, extra_context: Optional[Dict[str, str]] = ...
     ) -> TemplateResponse: ...
     def get_deleted_objects(
-        self, objs: QuerySet, request: WSGIRequest
+        self, objs: QuerySet, request: HttpRequest
     ) -> Tuple[List[Any], Dict[Any, Any], Set[Any], List[Any]]: ...
-    def delete_view(self, request: WSGIRequest, object_id: str, extra_context: None = ...) -> Any: ...
-    def history_view(self, request: WSGIRequest, object_id: str, extra_context: None = ...) -> HttpResponse: ...
+    def delete_view(self, request: HttpRequest, object_id: str, extra_context: None = ...) -> Any: ...
+    def history_view(self, request: HttpRequest, object_id: str, extra_context: None = ...) -> HttpResponse: ...
 
 class InlineModelAdmin(BaseModelAdmin):
     model: Any = ...
     fk_name: Any = ...
     formset: Any = ...
     extra: int = ...
-    min_num: Any = ...
-    max_num: Any = ...
-    template: Any = ...
-    verbose_name: Any = ...
-    verbose_name_plural: Any = ...
+    min_num: Optional[int] = ...
+    max_num: Optional[int] = ...
+    template: str = ...
+    verbose_name: Optional[str] = ...
+    verbose_name_plural: Optional[str] = ...
     can_delete: bool = ...
     show_change_link: bool = ...
-    checks_class: Any = ...
     classes: Any = ...
     admin_site: Any = ...
     parent_model: Any = ...
@@ -250,18 +249,10 @@ class InlineModelAdmin(BaseModelAdmin):
     def __init__(self, parent_model: Union[Type[Model], Model], admin_site: AdminSite) -> None: ...
     @property
     def media(self) -> Media: ...
-    def get_extra(self, request: WSGIRequest, obj: Optional[Model] = ..., **kwargs: Any) -> int: ...
-    def get_min_num(self, request: WSGIRequest, obj: Optional[Model] = ..., **kwargs: Any) -> None: ...
-    def get_max_num(self, request: WSGIRequest, obj: Optional[Model] = ..., **kwargs: Any) -> Optional[int]: ...
-    fields: Any = ...
+    def get_extra(self, request: HttpRequest, obj: Optional[Model] = ..., **kwargs: Any) -> int: ...
+    def get_min_num(self, request: HttpRequest, obj: Optional[Model] = ..., **kwargs: Any) -> Optional[int]: ...
+    def get_max_num(self, request: HttpRequest, obj: Optional[Model] = ..., **kwargs: Any) -> Optional[int]: ...
     def get_formset(self, request: Any, obj: Optional[Any] = ..., **kwargs: Any): ...
-    def get_queryset(self, request: WSGIRequest) -> QuerySet: ...
-    def has_change_permission(self, request: WSGIRequest, obj: Optional[Model] = ...) -> bool: ...
-    def has_delete_permission(self, request: WSGIRequest, obj: Optional[Model] = ...) -> bool: ...
-    def has_view_permission(self, request: WSGIRequest, obj: Optional[Model] = ...) -> bool: ...
 
-class StackedInline(InlineModelAdmin):
-    template: str = ...
-
-class TabularInline(InlineModelAdmin):
-    template: str = ...
+class StackedInline(InlineModelAdmin): ...
+class TabularInline(InlineModelAdmin): ...

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,76 +1,36 @@
-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 = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def clean_password2(self) -> str: ...
-    def save(self, commit: bool = ...) -> User: ...
 
 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 = ...
@@ -83,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] = ...,
@@ -117,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 = ...
@@ -135,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 = ...
@@ -168,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/redirects/middleware.pyi

@@ -1,10 +1,10 @@
 from typing import Any
 
-from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
 from django.http.response import HttpResponse
 from django.utils.deprecation import MiddlewareMixin
 
 class RedirectFallbackMiddleware(MiddlewareMixin):
     response_gone_class: Any = ...
     response_redirect_class: Any = ...
-    def process_response(self, request: WSGIRequest, response: HttpResponse) -> HttpResponse: ...
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ...

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/base_session.pyi

@@ -1,20 +1,19 @@
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Type
+
+from django.contrib.sessions.backends.base import SessionBase
 
 from django.db import models
 
 class BaseSessionManager(models.Manager):
-    creation_counter: int
-    model: None
-    name: None
     def encode(self, session_dict: Dict[str, int]) -> str: ...
     def save(self, session_key: str, session_dict: Dict[str, int], expire_date: datetime) -> AbstractBaseSession: ...
 
 class AbstractBaseSession(models.Model):
-    session_key: Any = ...
-    session_data: Any = ...
-    expire_date: Any = ...
+    expire_date: datetime
+    session_data: str
+    session_key: str
     objects: Any = ...
     @classmethod
-    def get_session_store_class(cls) -> None: ...
+    def get_session_store_class(cls) -> Optional[Type[SessionBase]]: ...
     def get_decoded(self) -> Dict[str, int]: ...

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/sessions/models.pyi

@@ -1,18 +1,4 @@
-from typing import Any, Optional, Type
-
-from django.contrib.sessions.backends.db import SessionStore
 from django.contrib.sessions.base_session import AbstractBaseSession, BaseSessionManager
 
-class SessionManager(BaseSessionManager):
-    creation_counter: int
-    model: None
-    name: None
-    use_in_migrations: bool = ...
-
-class Session(AbstractBaseSession):
-    expire_date: datetime.datetime
-    session_data: str
-    session_key: str
-    objects: Any = ...
-    @classmethod
-    def get_session_store_class(cls) -> Type[SessionStore]: ...
+class SessionManager(BaseSessionManager): ...
+class Session(AbstractBaseSession): ...

django-stubs/contrib/sessions/serializers.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Dict
 
 from django.core.signing import JSONSerializer as BaseJSONSerializer
 from django.db.models.base import Model

django-stubs/contrib/sitemaps/__init__.pyi

@@ -11,25 +11,24 @@ PING_URL: str
 
 class SitemapNotFound(Exception): ...
 
-def ping_google(sitemap_url: None = ..., ping_url: str = ...) -> None: ...
+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
     def paginator(self) -> Paginator: ...
     def get_urls(
         self, page: Union[int, str] = ..., site: Optional[Union[Site, RequestSite]] = ..., protocol: Optional[str] = ...
-    ) -> List[Dict[str, Optional[Union[datetime, Model, str]]]]: ...
+    ) -> List[Dict[str, Any]]: ...
 
 class GenericSitemap(Sitemap):
-    priority: None = ...
-    changefreq: None = ...
+    priority: Optional[float] = ...
+    changefreq: Optional[str] = ...
     queryset: QuerySet = ...
     date_field: None = ...
-    protocol: None = ...
     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/sitemaps/views.pyi

@@ -1,20 +1,21 @@
 from collections import OrderedDict
-from typing import Any, Callable, Dict, Optional, Type, Union
+from typing import Callable, Dict, Optional, Type, Union
+
+from django.http.request import HttpRequest
+from django.template.response import TemplateResponse
 
 from django.contrib.sitemaps import GenericSitemap, Sitemap
-from django.core.handlers.wsgi import WSGIRequest
-from django.template.response import TemplateResponse
 
 def x_robots_tag(func: Callable) -> Callable: ...
 def index(
-    request: WSGIRequest,
+    request: HttpRequest,
     sitemaps: Dict[str, Union[Type[Sitemap], Sitemap]],
     template_name: str = ...,
     content_type: str = ...,
     sitemap_url_name: str = ...,
 ) -> TemplateResponse: ...
 def sitemap(
-    request: WSGIRequest,
+    request: HttpRequest,
     sitemaps: Union[Dict[str, Type[Sitemap]], Dict[str, GenericSitemap], OrderedDict],
     section: Optional[str] = ...,
     template_name: 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/__init__.pyi

@@ -1,7 +1,7 @@
 from collections import OrderedDict
 from typing import Any, Callable, Dict, Union
 
-from django.core.cache.backends.base import BaseCache as BaseCache
+from .backends.base import BaseCache as BaseCache
 
 DEFAULT_CACHE_ALIAS: str
 

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/cache/utils.pyi

@@ -1,5 +1,5 @@
-from typing import Any, List, Optional, Union
+from typing import Any, Iterable, Optional
 
 TEMPLATE_FRAGMENT_KEY_TEMPLATE: str
 
-def make_template_fragment_key(fragment_name: str, vary_on: Optional[Union[List[int], List[str]]] = ...) -> str: ...
+def make_template_fragment_key(fragment_name: str, vary_on: Optional[Iterable[Any]] = ...) -> str: ...

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/files/storage.pyi

@@ -1,15 +1,12 @@
 from datetime import datetime
-from io import StringIO, TextIOWrapper
-from typing import Any, List, Optional, Tuple, Union
+from typing import Any, IO, List, Optional, Tuple
 
 from django.core.files.base import File
 from django.utils.functional import LazyObject
 
 class Storage:
     def open(self, name: str, mode: str = ...) -> File: ...
-    def save(
-        self, name: Optional[str], content: Union[StringIO, TextIOWrapper, File], max_length: Optional[int] = ...
-    ) -> str: ...
+    def save(self, name: Optional[str], content: IO[Any], max_length: Optional[int] = ...) -> str: ...
     def get_valid_name(self, name: str) -> str: ...
     def get_available_name(self, name: str, max_length: Optional[int] = ...) -> str: ...
     def generate_filename(self, filename: str) -> str: ...

django-stubs/core/handlers/base.pyi

@@ -1,6 +1,6 @@
 from typing import Any, Callable
 
-from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
 from django.http.response import HttpResponse, HttpResponseBase
 
 logger: Any
@@ -13,5 +13,5 @@ class BaseHandler:
     def load_middleware(self) -> None: ...
     def make_view_atomic(self, view: Callable) -> Callable: ...
     def get_exception_response(self, request: Any, resolver: Any, status_code: Any, exception: Any): ...
-    def get_response(self, request: WSGIRequest) -> HttpResponseBase: ...
-    def process_exception_by_middleware(self, exception: Exception, request: WSGIRequest) -> HttpResponse: ...
+    def get_response(self, request: HttpRequest) -> HttpResponseBase: ...
+    def process_exception_by_middleware(self, exception: Exception, request: HttpRequest) -> HttpResponse: ...

django-stubs/core/handlers/exception.pyi

@@ -1,12 +1,12 @@
 from typing import Any, Callable
 
-from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
 from django.http.response import HttpResponse
 from django.urls.resolvers import URLResolver
 
 def convert_exception_to_response(get_response: Callable) -> Callable: ...
-def response_for_exception(request: WSGIRequest, exc: Exception) -> HttpResponse: ...
+def response_for_exception(request: HttpRequest, exc: Exception) -> HttpResponse: ...
 def get_exception_response(
-    request: WSGIRequest, resolver: URLResolver, status_code: int, exception: Exception, sender: None = ...
+    request: HttpRequest, resolver: URLResolver, status_code: int, exception: Exception, sender: None = ...
 ) -> HttpResponse: ...
 def handle_uncaught_exception(request: Any, resolver: Any, exc_info: Any): ...

django-stubs/core/mail/__init__.pyi

@@ -1,48 +1,48 @@
 from typing import Any, List, Optional, Tuple
 
-from django.core.mail.backends.base import BaseEmailBackend
-from django.core.mail.message import DEFAULT_ATTACHMENT_MIME_TYPE as DEFAULT_ATTACHMENT_MIME_TYPE
-from django.core.mail.message import BadHeaderError as BadHeaderError
-from django.core.mail.message import EmailMessage as EmailMessage
-from django.core.mail.message import EmailMultiAlternatives as EmailMultiAlternatives
-from django.core.mail.message import SafeMIMEMultipart as SafeMIMEMultipart
-from django.core.mail.message import SafeMIMEText as SafeMIMEText
-from django.core.mail.message import forbid_multi_line_headers as forbid_multi_line_headers
-from django.core.mail.utils import DNS_NAME as DNS_NAME
-from django.core.mail.utils import CachedDnsName as CachedDnsName
+from .message import (
+    BadHeaderError as BadHeaderError,
+    DEFAULT_ATTACHMENT_MIME_TYPE as DEFAULT_ATTACHMENT_MIME_TYPE,
+    EmailMessage as EmailMessage,
+    EmailMultiAlternatives as EmailMultiAlternatives,
+    SafeMIMEMultipart as SafeMIMEMultipart,
+    SafeMIMEText as SafeMIMEText,
+    forbid_multi_line_headers as forbid_multi_line_headers,
+)
+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,
     from_email: Optional[str],
     recipient_list: List[str],
     fail_silently: bool = ...,
-    auth_user: None = ...,
-    auth_password: None = ...,
-    connection: Optional[BaseEmailBackend] = ...,
+    auth_user: Optional[str] = ...,
+    auth_password: Optional[str] = ...,
+    connection: Optional[Any] = ...,
     html_message: Optional[str] = ...,
 ) -> int: ...
 def send_mass_mail(
     datatuple: List[Tuple[str, str, str, List[str]]],
     fail_silently: bool = ...,
-    auth_user: None = ...,
-    auth_password: None = ...,
-    connection: BaseEmailBackend = ...,
+    auth_user: Optional[str] = ...,
+    auth_password: Optional[str] = ...,
+    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: ...
 
-outbox = [EmailMessage()]
+outbox: List[EmailMessage] = ...

django-stubs/core/mail/message.pyi

@@ -1,11 +1,8 @@
-import email
+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
-
-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,37 +17,31 @@ 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: email._policybase.Compat32
+    policy: Policy
     preamble: None
-    def __setitem__(self, name: str, val: str) -> None: ...
 
 class SafeMIMEText(MIMEMixin, MIMEText):
     defects: List[Any]
     epilogue: None
-    policy: email._policybase.Compat32
+    policy: Policy
     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]
     epilogue: None
-    policy: email._policybase.Compat32
+    policy: Policy
     preamble: None
     encoding: str = ...
     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,21 +56,21 @@ class EmailMessage:
     body: str = ...
     attachments: List[Any] = ...
     extra_headers: Dict[Any, Any] = ...
-    connection: None = ...
+    connection: Any = ...
     def __init__(
         self,
         subject: str = ...,
         body: Optional[str] = ...,
         from_email: Optional[str] = ...,
-        to: Optional[Union[List[str], Tuple[str, str], str]] = ...,
-        bcc: Optional[Union[List[str], Tuple[str], str]] = ...,
-        connection: Optional[BaseEmailBackend] = ...,
+        to: Optional[Union[Sequence[str], str]] = ...,
+        bcc: Optional[Union[Sequence[str], str]] = ...,
+        connection: Optional[Any] = ...,
         attachments: Optional[Union[List[Tuple[str, str]], List[MIMEText]]] = ...,
         headers: Optional[Dict[str, str]] = ...,
-        cc: Optional[Union[List[str], Tuple[str, 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/graph.pyi

@@ -11,7 +11,6 @@ class Node:
     parents: Set[Any] = ...
     def __init__(self, key: Tuple[str, str]) -> None: ...
     def __lt__(self, other: Union[Tuple[str, str], Node]) -> bool: ...
-    def __hash__(self) -> int: ...
     def __getitem__(self, item: int) -> str: ...
     def add_child(self, child: Node) -> None: ...
     def add_parent(self, parent: Node) -> None: ...
@@ -19,13 +18,9 @@ class Node:
     def descendants(self) -> List[Tuple[str, str]]: ...
 
 class DummyNode(Node):
-    children: Set[Any]
-    key: Tuple[str, str]
-    parents: Set[Any]
     origin: Any = ...
     error_message: Any = ...
     def __init__(self, key: Tuple[str, str], origin: Union[Migration, str], error_message: str) -> None: ...
-    __class__: Any = ...
     def promote(self) -> None: ...
     def raise_error(self) -> None: ...
 

django-stubs/db/migrations/loader.pyi

@@ -1,9 +1,6 @@
-from typing import Any, Dict, Optional, Set, Tuple, Union, Sequence
+from typing import Any, Dict, Optional, Sequence, Set, Tuple, Union
 
-from django.db import DefaultConnectionProxy
-from django.db.backends.base.base import BaseDatabaseWrapper
-from django.db.backends.sqlite3.base import DatabaseWrapper
-from django.db.migrations.migration import Migration, SwappableTuple
+from django.db.migrations.migration import Migration
 from django.db.migrations.state import ProjectState
 
 MIGRATIONS_MODULE_NAME: str
@@ -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

@@ -13,7 +13,6 @@ class Migration:
     name: str = ...
     app_label: str = ...
     def __init__(self, name: str, app_label: str) -> None: ...
-    def __hash__(self) -> int: ...
     def mutate_state(self, project_state: ProjectState, preserve: bool = ...) -> ProjectState: ...
     def apply(
         self, project_state: ProjectState, schema_editor: BaseDatabaseSchemaEditor, collect_sql: bool = ...
@@ -22,8 +21,8 @@ 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: Type[SwappableTuple], value: Tuple[str, str], setting: str) -> SwappableTuple: ...
+    def __new__(cls, value: Tuple[str, str], setting: str) -> SwappableTuple: ...
 
 def swappable_dependency(value: str) -> SwappableTuple: ...

django-stubs/db/migrations/operations/__init__.pyi

@@ -1,7 +1,3 @@
-# Stubs for django.db.migrations.operations (Python 3.6)
-#
-# NOTE: This dynamically typed stub was automatically generated by stubgen.
-
 from .fields import (
     AddField as AddField,
     AlterField as AlterField,

django-stubs/db/migrations/operations/base.pyi

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional, Type
+from typing import Any, List
 
 class Operation:
     reversible: bool = ...
@@ -6,7 +6,6 @@ class Operation:
     atomic: bool = ...
     elidable: bool = ...
     serialization_expand_args: Any = ...
-    def __new__(cls: Type[Operation], *args: Any, **kwargs: Any) -> Operation: ...
     def deconstruct(self): ...
     def state_forwards(self, app_label: Any, state: Any) -> None: ...
     def database_forwards(self, app_label: Any, schema_editor: Any, from_state: Any, to_state: Any) -> None: ...

django-stubs/db/migrations/operations/models.pyi

@@ -12,7 +12,6 @@ class ModelOperation(Operation):
     def name_lower(self) -> str: ...
 
 class CreateModel(ModelOperation):
-    serialization_expand_args: Any = ...
     fields: Sequence[Tuple[str, Field]] = ...
     options: Any = ...
     bases: Optional[Sequence[Union[type, str]]] = ...
@@ -63,7 +62,6 @@ class AlterModelOptions(ModelOptionOperation):
     def __init__(self, name: str, options: Dict[str, Any]) -> None: ...
 
 class AlterModelManagers(ModelOptionOperation):
-    serialization_expand_args: Any = ...
     managers: Any = ...
     def __init__(self, name: Any, managers: Any) -> None: ...
 

django-stubs/db/migrations/operations/special.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, Sequence, Dict
+from typing import Any, Callable, Dict, Optional, Sequence
 
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
 from django.db.migrations.state import StateApps
@@ -6,7 +6,6 @@ from django.db.migrations.state import StateApps
 from .base import Operation
 
 class SeparateDatabaseAndState(Operation):
-    serialization_expand_args: Any = ...
     database_operations: Sequence[Operation] = ...
     state_operations: Sequence[Operation] = ...
     def __init__(
@@ -19,7 +18,6 @@ class RunSQL(Operation):
     reverse_sql: Any = ...
     state_operations: Any = ...
     hints: Any = ...
-    elidable: Any = ...
     def __init__(
         self,
         sql: Any,
@@ -30,12 +28,9 @@ class RunSQL(Operation):
     ) -> None: ...
 
 class RunPython(Operation):
-    reduces_to_sql: bool = ...
-    atomic: bool = ...
     code: Callable = ...
     reverse_code: Optional[Callable] = ...
     hints: Optional[Dict[str, Any]] = ...
-    elidable: bool = ...
     def __init__(
         self,
         code: Callable,

django-stubs/db/migrations/operations/utils.pyi

@@ -1,6 +1,5 @@
-from typing import Any, Optional
-
 from django.db.migrations.state import ProjectState
+
 from django.db.models.fields import Field
 
 def is_referenced_by_foreign_key(state: ProjectState, model_name_lower: str, field: Field, field_name: str) -> bool: ...

django-stubs/db/migrations/optimizer.pyi

@@ -1,7 +1,7 @@
-from typing import Any, List, Optional
+from typing import List, Optional
 
 from django.db.migrations.operations.base import Operation
 
 class MigrationOptimizer:
-    def optimize(self, operations: List[Operation], app_label: str = ...) -> List[Operation]: ...
-    def optimize_inner(self, operations: List[Operation], app_label: str = ...) -> List[Operation]: ...
+    def optimize(self, operations: List[Operation], app_label: Optional[str] = ...) -> List[Operation]: ...
+    def optimize_inner(self, operations: List[Operation], app_label: Optional[str] = ...) -> List[Operation]: ...

django-stubs/db/migrations/questioner.pyi

@@ -1,14 +1,13 @@
 from typing import Any, Dict, Optional, Set
 
 from django.db.migrations.state import ModelState
+
 from django.db.models.fields import Field
 
-from .loader import MigrationLoader
-
 class MigrationQuestioner:
-    defaults: Dict[Any, Any] = ...
-    specified_apps: Set[Any] = ...
-    dry_run: None = ...
+    defaults: Dict[str, Any] = ...
+    specified_apps: Set[str] = ...
+    dry_run: Optional[bool] = ...
     def __init__(
         self,
         defaults: Optional[Dict[str, bool]] = ...,
@@ -23,21 +22,5 @@ class MigrationQuestioner:
     def ask_merge(self, app_label: str) -> bool: ...
     def ask_auto_now_add_addition(self, field_name: str, model_name: str) -> None: ...
 
-class InteractiveMigrationQuestioner(MigrationQuestioner):
-    defaults: Dict[Any, Any]
-    dry_run: bool
-    specified_apps: Set[str]
-    def ask_not_null_addition(self, field_name: str, model_name: str) -> None: ...
-    def ask_not_null_alteration(self, field_name: Any, model_name: Any): ...
-    def ask_rename(self, model_name: Any, old_name: Any, new_name: Any, field_instance: Any): ...
-    def ask_rename_model(self, old_model_state: Any, new_model_state: Any): ...
-    def ask_merge(self, app_label: str) -> bool: ...
-    def ask_auto_now_add_addition(self, field_name: str, model_name: str) -> int: ...
-
-class NonInteractiveMigrationQuestioner(MigrationQuestioner):
-    defaults: Dict[Any, Any]
-    dry_run: bool
-    specified_apps: Set[str]
-    def ask_not_null_addition(self, field_name: Any, model_name: Any) -> None: ...
-    def ask_not_null_alteration(self, field_name: Any, model_name: Any): ...
-    def ask_auto_now_add_addition(self, field_name: Any, model_name: Any) -> None: ...
+class InteractiveMigrationQuestioner(MigrationQuestioner): ...
+class NonInteractiveMigrationQuestioner(MigrationQuestioner): ...

django-stubs/db/migrations/recorder.pyi

@@ -1,9 +1,10 @@
-from typing import Any, Optional, Set, Tuple, Union
+from typing import Any, Optional, Set, Tuple
 
-from django.db import models
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.db.models.query import QuerySet
 
+from django.db import models
+
 class MigrationRecorder:
     class Migration(models.Model):
         app: Any = ...

django-stubs/db/migrations/serializer.pyi

@@ -1,88 +1,40 @@
 from typing import Any, Callable, Dict, List, Set, Tuple, Union
 
-from django.db.models.fields import Field
-
 class BaseSerializer:
     value: Any = ...
     def __init__(self, value: Any) -> None: ...
-    def serialize(self) -> None: ...
+    def serialize(self) -> Any: ...
 
-class BaseSequenceSerializer(BaseSerializer):
-    def serialize(self) -> Tuple[str, Set[str]]: ...
-
-class BaseSimpleSerializer(BaseSerializer):
-    value: str
-    def serialize(self) -> Tuple[str, Set[Any]]: ...
-
-class DatetimeSerializer(BaseSerializer):
-    value: Any = ...
-    def serialize(self): ...
-
-class DateSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class DecimalSerializer(BaseSerializer):
-    def serialize(self): ...
+class BaseSequenceSerializer(BaseSerializer): ...
+class BaseSimpleSerializer(BaseSerializer): ...
+class DatetimeSerializer(BaseSerializer): ...
+class DateSerializer(BaseSerializer): ...
+class DecimalSerializer(BaseSerializer): ...
 
 class DeconstructableSerializer(BaseSerializer):
     @staticmethod
     def serialize_deconstructed(
         path: str, args: List[Any], kwargs: Dict[str, Union[Callable, int, str]]
     ) -> Tuple[str, Set[str]]: ...
-    def serialize(self): ...
-
-class DictionarySerializer(BaseSerializer):
-    def serialize(self): ...
-
-class EnumSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class FloatSerializer(BaseSimpleSerializer):
-    def serialize(self): ...
 
+class DictionarySerializer(BaseSerializer): ...
+class EnumSerializer(BaseSerializer): ...
+class FloatSerializer(BaseSimpleSerializer): ...
 class FrozensetSerializer(BaseSequenceSerializer): ...
-
-class FunctionTypeSerializer(BaseSerializer):
-    value: Callable
-    def serialize(self) -> Tuple[str, Set[str]]: ...
-
-class FunctoolsPartialSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class IterableSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class ModelFieldSerializer(DeconstructableSerializer):
-    value: Field
-    def serialize(self) -> Tuple[str, Set[str]]: ...
-
-class ModelManagerSerializer(DeconstructableSerializer):
-    def serialize(self): ...
-
-class OperationSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class RegexSerializer(BaseSerializer):
-    def serialize(self): ...
-
+class FunctionTypeSerializer(BaseSerializer): ...
+class FunctoolsPartialSerializer(BaseSerializer): ...
+class IterableSerializer(BaseSerializer): ...
+class ModelFieldSerializer(DeconstructableSerializer): ...
+class ModelManagerSerializer(DeconstructableSerializer): ...
+class OperationSerializer(BaseSerializer): ...
+class RegexSerializer(BaseSerializer): ...
 class SequenceSerializer(BaseSequenceSerializer): ...
 class SetSerializer(BaseSequenceSerializer): ...
-
-class SettingsReferenceSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class TimedeltaSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class TimeSerializer(BaseSerializer):
-    def serialize(self): ...
-
+class SettingsReferenceSerializer(BaseSerializer): ...
+class TimedeltaSerializer(BaseSerializer): ...
+class TimeSerializer(BaseSerializer): ...
 class TupleSerializer(BaseSequenceSerializer): ...
-
-class TypeSerializer(BaseSerializer):
-    def serialize(self): ...
-
-class UUIDSerializer(BaseSerializer):
-    def serialize(self): ...
+class TypeSerializer(BaseSerializer): ...
+class UUIDSerializer(BaseSerializer): ...
 
 def serializer_factory(value: Any) -> BaseSerializer: ...

django-stubs/db/migrations/state.pyi

@@ -1,9 +1,8 @@
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, DefaultDict, Union, Sequence
+from typing import Any, DefaultDict, Dict, Iterator, List, Optional, Sequence, Tuple, Type, Union
 
 from django.apps.registry import Apps
 from django.db.models.base import Model
 from django.db.models.manager import Manager
-from django.utils.functional import cached_property
 
 from django.db.models.fields import Field
 

django-stubs/db/migrations/topological_sort.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Iterator, List, Optional, Set
+from typing import Dict, Iterator, List, Set
 
 from django.db.migrations.operations.base import Operation
 

django-stubs/db/migrations/utils.pyi

@@ -1,12 +1,10 @@
-from typing import Any, Optional
-
-from django.utils.functional import SimpleLazyObject
+from typing import Any
 
 COMPILED_REGEX_TYPE: Any
 
 class RegexObject:
     pattern: str = ...
     flags: int = ...
-    def __init__(self, obj: SimpleLazyObject) -> None: ...
+    def __init__(self, obj: Any) -> None: ...
 
 def get_migration_name_timestamp() -> str: ...

django-stubs/db/migrations/writer.pyi

@@ -1,13 +1,10 @@
-from typing import Any, Optional, Set, Tuple, Type, List, Union
+from typing import Any, List, Set, Tuple, Union
 
 from django.db.migrations.migration import Migration
 from django.db.migrations.operations.base import Operation
-
 from django.db.migrations.operations.models import CreateModel
 
 class SettingsReference(str):
-    def __new__(self: Type[SettingsReference], value: str, setting_name: str) -> SettingsReference: ...
-    setting_name: str = ...
     def __init__(self, value: str, setting_name: str) -> None: ...
 
 class OperationWriter:

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,35 +61,34 @@ 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 in_bulk(
-        self, id_list: Any = ..., *, field_name: str = ..., **kwargs: Any
-    ) -> Dict[Union[int, str], models.Model]: ...
+    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: ...
     def _update(self, values: Any) -> Optional[Any]: ...
@@ -95,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]] = ...,
@@ -128,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
@@ -161,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 = ...
@@ -29,6 +29,7 @@ class BaseForm:
     empty_permitted: bool = ...
     fields: Dict[str, Any] = ...
     renderer: BaseRenderer = ...
+    cleaned_data: Any = ...
     def __init__(
         self,
         data: Optional[Mapping[str, Any]] = ...,
@@ -57,9 +58,8 @@ class BaseForm:
     def non_field_errors(self) -> ErrorList: ...
     def add_error(self, field: Optional[str], error: Union[ValidationError, str]) -> None: ...
     def has_error(self, field: Any, code: Optional[Any] = ...): ...
-    cleaned_data: 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
+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,21 +15,22 @@ 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]], Tuple[str]]
+_Fields = Union[List[Union[Callable, str]], Sequence[str], Literal["__all__"]]
 _Labels = Dict[str, str]
 _ErrorMessages = Dict[str, Dict[str, str]]
 
 def model_to_dict(
-    instance: Model,
-    fields: Optional[_Fields] = ...,
-    exclude: Optional[Union[List[Union[Callable, str]], Tuple[str]]] = ...,
-) -> Dict[str, Optional[Union[bool, date, float]]]: ...
+    instance: Model, fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ...
+) -> Dict[str, Any]: ...
 def fields_for_model(
     model: Type[Model],
     fields: Optional[_Fields] = ...,
-    exclude: Optional[Union[List[Union[Callable, str]], Tuple]] = ...,
+    exclude: Optional[_Fields] = ...,
     widgets: Optional[Union[Dict[str, Type[Input]], Dict[str, Widget]]] = ...,
     formfield_callback: Optional[Union[Callable, str]] = ...,
     localized_fields: Optional[Union[Tuple[str], str]] = ...,
@@ -42,12 +40,12 @@ def fields_for_model(
     field_classes: Optional[Dict[str, Type[CharField]]] = ...,
     *,
     apply_limit_choices_to: bool = ...
-) -> OrderedDict: ...
+) -> Dict[str, Any]: ...
 
 class ModelFormOptions:
     model: Optional[Type[Model]] = ...
     fields: Optional[_Fields] = ...
-    exclude: Optional[Union[List[Union[Callable, str]], Tuple, str]] = ...
+    exclude: Optional[_Fields] = ...
     widgets: Optional[Dict[str, Union[Widget, Input]]] = ...
     localized_fields: Optional[Union[Tuple[str], str]] = ...
     labels: Optional[_Labels] = ...
@@ -57,14 +55,14 @@ class ModelFormOptions:
     def __init__(self, options: Optional[type] = ...) -> None: ...
 
 class ModelFormMetaclass(DeclarativeFieldsMetaclass):
-    def __new__(mcs, name: str, bases: Sequence[Type[ModelForm]], attrs: Dict[str, Any]) -> Type[ModelForm]: ...
+    def __new__(mcs, name: str, bases: Sequence[Type[Any]], attrs: Dict[str, Any]) -> Type[ModelForm]: ...
 
 class BaseModelForm(BaseForm):
     instance: Any = ...
     def __init__(
         self,
-        data: Optional[Dict[str, Any]] = ...,
-        files: Optional[Dict[str, File]] = ...,
+        data: Optional[Mapping[str, Any]] = ...,
+        files: Optional[Mapping[str, File]] = ...,
         auto_id: Union[bool, str] = ...,
         prefix: Optional[str] = ...,
         initial: Optional[Dict[str, Any]] = ...,
@@ -72,21 +70,21 @@ class BaseModelForm(BaseForm):
         label_suffix: Optional[str] = ...,
         empty_permitted: bool = ...,
         instance: Optional[Model] = ...,
-        use_required_attribute: None = ...,
+        use_required_attribute: Optional[bool] = ...,
         renderer: Any = ...,
     ) -> None: ...
     def clean(self) -> Dict[str, Any]: ...
     def validate_unique(self) -> None: ...
     save_m2m: Any = ...
-    def save(self, commit: bool = ...) -> Model: ...
+    def save(self, commit: bool = ...) -> Any: ...
 
 class ModelForm(BaseModelForm): ...
 
 def modelform_factory(
     model: Type[Model],
     form: Type[ModelForm] = ...,
-    fields: Optional[Union[Sequence[str], Literal["__all__"]]] = ...,
-    exclude: Optional[Sequence[str]] = ...,
+    fields: Optional[_Fields] = ...,
+    exclude: Optional[_Fields] = ...,
     formfield_callback: Optional[Union[str, Callable[[models.Field], Field]]] = ...,
     widgets: Optional[MutableMapping[str, Widget]] = ...,
     localized_fields: Optional[Sequence[str]] = ...,
@@ -142,8 +140,8 @@ def modelformset_factory(
     can_order: bool = ...,
     min_num: Optional[int] = ...,
     max_num: Optional[int] = ...,
-    fields: Optional[Union[str, Sequence[str]]] = ...,
-    exclude: Optional[Sequence[str]] = ...,
+    fields: Optional[_Fields] = ...,
+    exclude: Optional[_Fields] = ...,
     widgets: Optional[Dict[str, Any]] = ...,
     validate_max: bool = ...,
     localized_fields: Optional[Sequence[str]] = ...,
@@ -181,8 +179,8 @@ def inlineformset_factory(
     form: Type[ModelForm] = ...,
     formset: Type[BaseInlineFormSet] = ...,
     fk_name: Optional[str] = ...,
-    fields: Optional[Union[str, Sequence[str]]] = ...,
-    exclude: Optional[Sequence[str]] = ...,
+    fields: Optional[_Fields] = ...,
+    exclude: Optional[_Fields] = ...,
     extra: int = ...,
     can_order: bool = ...,
     can_delete: bool = ...,
@@ -239,7 +237,7 @@ class ModelChoiceField(ChoiceField):
         self,
         queryset: Optional[Union[Manager, QuerySet]],
         *,
-        empty_label: str = ...,
+        empty_label: Optional[str] = ...,
         required: bool = ...,
         widget: Optional[Any] = ...,
         label: Optional[Any] = ...,

django-stubs/forms/utils.pyi

@@ -1,6 +1,6 @@
 from collections import UserList
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union, Sequence
+from typing import Any, Dict, List, Optional, Sequence, Union
 
 from django.core.exceptions import ValidationError
 from django.utils.safestring import SafeText
@@ -28,9 +28,6 @@ class ErrorList(UserList):
     def as_json(self, escape_html: bool = ...) -> str: ...
     def as_ul(self) -> str: ...
     def as_text(self) -> str: ...
-    def __reduce_ex__(
-        self, *args: Any, **kwargs: Any
-    ) -> Tuple[Callable, Tuple[Type[ErrorList]], Dict[str, Union[List[ValidationError], str]], None, None]: ...
 
 def from_current_timezone(value: datetime) -> datetime: ...
 def to_current_timezone(value: datetime) -> datetime: ...

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/http/response.pyi

@@ -1,9 +1,8 @@
 import datetime
 from io import BytesIO
 from json import JSONEncoder
-from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Type, Union, overload, AnyStr, IO
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Type, Union, overload
 
-import six
 from django.core.handlers.wsgi import WSGIRequest
 from django.http.cookie import SimpleCookie
 from django.test.client import Client
@@ -13,7 +12,7 @@ from django.urls import ResolverMatch
 
 class BadHeaderError(ValueError): ...
 
-class HttpResponseBase(Iterable[AnyStr]):
+class HttpResponseBase(Iterable[Any]):
     status_code: int = ...
     cookies: SimpleCookie = ...
     reason_phrase: str = ...
@@ -60,7 +59,7 @@ class HttpResponseBase(Iterable[AnyStr]):
     def seekable(self) -> bool: ...
     def writable(self) -> bool: ...
     def writelines(self, lines: Iterable[object]): ...
-    def __iter__(self) -> Iterator[AnyStr]: ...
+    def __iter__(self) -> Iterator[Any]: ...
 
 class HttpResponse(HttpResponseBase):
     client: Client
@@ -70,7 +69,6 @@ class HttpResponse(HttpResponseBase):
     request: Dict[str, Any]
     resolver_match: ResolverMatch
     sameorigin: bool
-    status_code: int
     templates: List[Template]
     test_server_port: str
     test_was_secure_request: bool
@@ -88,21 +86,13 @@ class HttpResponse(HttpResponseBase):
     def json(self) -> Dict[str, Any]: ...
 
 class StreamingHttpResponse(HttpResponseBase):
-    def __init__(self, streaming_content: Iterable[AnyStr] = ..., *args: Any, **kwargs: Any) -> None: ...
-    @property
-    def content(self) -> AnyStr: ...
-    @content.setter
-    def content(self, value: AnyStr) -> None: ...
-    @property
-    def streaming_content(self) -> Iterator[AnyStr]: ...
-    @streaming_content.setter
-    def streaming_content(self, value: Iterable[AnyStr]) -> None: ...
-    def __iter__(self) -> Iterator[AnyStr]: ...
-    def getvalue(self) -> AnyStr: ...
+    content: Any
+    streaming_content: Iterator[Any]
+    def __init__(self, streaming_content: Iterable[Any] = ..., *args: Any, **kwargs: Any) -> None: ...
+    def getvalue(self) -> Any: ...
 
 class FileResponse(StreamingHttpResponse):
     client: Client
-    closed: bool
     context: None
     file_to_stream: Optional[BytesIO]
     request: Dict[str, str]
@@ -119,8 +109,6 @@ class FileResponse(StreamingHttpResponse):
 class HttpResponseRedirectBase(HttpResponse):
     allowed_schemes = ...  # type: List[str]
     def __init__(self, redirect_to: str, *args: Any, **kwargs: Any) -> None: ...
-    @property
-    def url(self) -> str: ...
 
 class HttpResponseRedirect(HttpResponseRedirectBase): ...
 class HttpResponsePermanentRedirect(HttpResponseRedirectBase): ...

django-stubs/middleware/cache.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Union
+from typing import Any, Optional, Union, Callable
 
 from django.http.request import HttpRequest
 from django.http.response import HttpResponse, HttpResponseBase
@@ -26,4 +26,6 @@ class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware):
     cache_alias: str = ...
     cache_timeout: float = ...
     cache: BaseCache = ...
-    def __init__(self, get_response: None = ..., cache_timeout: Optional[float] = ..., **kwargs: Any) -> None: ...
+    def __init__(
+        self, get_response: Optional[Callable] = ..., cache_timeout: Optional[float] = ..., **kwargs: Any
+    ) -> None: ...

django-stubs/middleware/gzip.pyi

@@ -1,10 +1,10 @@
 from typing import Any
 
-from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
 from django.http.response import HttpResponseBase
 from django.utils.deprecation import MiddlewareMixin
 
 re_accepts_gzip: Any
 
 class GZipMiddleware(MiddlewareMixin):
-    def process_response(self, request: WSGIRequest, response: HttpResponseBase) -> HttpResponseBase: ...
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...

django-stubs/middleware/http.pyi

@@ -1,7 +1,7 @@
-from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
 from django.http.response import HttpResponseBase
 from django.utils.deprecation import MiddlewareMixin
 
 class ConditionalGetMiddleware(MiddlewareMixin):
-    def process_response(self, request: WSGIRequest, response: HttpResponseBase) -> HttpResponseBase: ...
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...
     def needs_etag(self, response: HttpResponseBase) -> bool: ...

django-stubs/middleware/locale.pyi

@@ -1,10 +1,10 @@
 from typing import Any
 
-from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
 from django.http.response import HttpResponseBase
 from django.utils.deprecation import MiddlewareMixin
 
 class LocaleMiddleware(MiddlewareMixin):
     response_redirect_class: Any = ...
-    def process_request(self, request: WSGIRequest) -> None: ...
-    def process_response(self, request: WSGIRequest, response: HttpResponseBase) -> HttpResponseBase: ...
+    def process_request(self, request: HttpRequest) -> None: ...
+    def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ...

django-stubs/middleware/security.pyi

@@ -1,6 +1,6 @@
-from typing import Any, Optional, List
+from typing import Any, List, Optional
 
-from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
 from django.http.response import HttpResponse, HttpResponsePermanentRedirect
 from django.utils.deprecation import MiddlewareMixin
 
@@ -13,5 +13,5 @@ class SecurityMiddleware(MiddlewareMixin):
     redirect: bool = ...
     redirect_host: Optional[str] = ...
     redirect_exempt: List[Any] = ...
-    def process_request(self, request: WSGIRequest) -> Optional[HttpResponsePermanentRedirect]: ...
-    def process_response(self, request: WSGIRequest, response: HttpResponse) -> HttpResponse: ...
+    def process_request(self, request: HttpRequest) -> Optional[HttpResponsePermanentRedirect]: ...
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ...

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: ...