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

README.md

@@ -7,6 +7,10 @@
 
 This package contains type stubs and mypy plugin to provide more precise static types and type inference for Django framework. Django uses some Python "magic" that makes having precise types for some code patterns problematic. This is why we need to accompany the stubs with mypy plugins. The final goal is to be able to get precise types for most common patterns.
 
+Supports Python 3.6/3.7, and Django 2.1.x series.
+
+Could be run on earlier versions of Django, but expect some missing imports warnings.
+
 ## Installation
 
 ```
@@ -26,7 +30,7 @@ in your `mypy.ini` file.
 
 ## Configuration
 
-In order to specify config file, set `MYPY_DJANGO_CONFIG` environment variable with path to the config file.
+In order to specify config file, set `MYPY_DJANGO_CONFIG` environment variable with path to the config file. Default is `./mypy_django.ini`
 
 Config file format (.ini):
 ```

dev-requirements.txt

@@ -1,3 +1,5 @@
 black
--e git+https://github.com/mkurnikov/pytest-mypy-plugins.git#egg=pytest-mypy-plugins
+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/apps/config.pyi

@@ -12,7 +12,7 @@ class AppConfig:
     verbose_name: str = ...
     path: str = ...
     models_module: None = ...
-    models: Optional[Dict[str, Type[Model]]] = ...
+    models: Dict[str, Type[Model]] = ...
     def __init__(self, app_name: str, app_module: Optional[Any]) -> None: ...
     @classmethod
     def create(cls, entry: str) -> AppConfig: ...

django-stubs/conf/global_settings.pyi

@@ -5,7 +5,7 @@ by the DJANGO_SETTINGS_MODULE environment variable.
 
 # This is defined here as a do-nothing function because we can't import
 # django.utils.translation -- that module depends on the settings.
-from typing import Any, Dict, List, Optional, Pattern, Tuple, Protocol, Union, Callable, TYPE_CHECKING
+from typing import Any, Dict, List, Optional, Pattern, Tuple, Protocol, Union, Callable, TYPE_CHECKING, Sequence
 
 ####################
 # CORE             #
@@ -377,7 +377,7 @@ CACHE_MIDDLEWARE_ALIAS = "default"
 
 AUTH_USER_MODEL: str = ...
 
-AUTHENTICATION_BACKENDS: List[str] = ...
+AUTHENTICATION_BACKENDS: Sequence[str] = ...
 
 LOGIN_URL = "/accounts/login/"
 

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

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Iterator
 
 from django.contrib.admin.options import ModelAdmin
 from django.core.handlers.wsgi import WSGIRequest
@@ -16,7 +16,7 @@ class ListFilter:
         self, request: WSGIRequest, params: Dict[str, str], model: Type[Model], model_admin: ModelAdmin
     ) -> None: ...
     def has_output(self) -> bool: ...
-    def choices(self, changelist: Any) -> None: ...
+    def choices(self, changelist: Any) -> Optional[Iterator[Dict[str, Any]]]: ...
     def queryset(self, request: Any, queryset: QuerySet) -> Optional[QuerySet]: ...
     def expected_parameters(self) -> Optional[List[str]]: ...
 

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

@@ -25,7 +25,7 @@ class LogEntryManager(models.Manager["LogEntry"]):
 class LogEntry(models.Model):
     action_time: models.DateTimeField = ...
     user: models.ForeignKey = ...
-    content_type: models.ForeignKey[ContentType] = ...
+    content_type: models.ForeignKey = models.ForeignKey(ContentType, on_delete=models.CASCADE)
     object_id: models.TextField = ...
     object_repr: models.CharField = ...
     action_flag: models.PositiveSmallIntegerField = ...

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
@@ -57,40 +57,46 @@ class BaseModelAdmin:
     checks_class: Any = ...
     def check(self, **kwargs: Any) -> List[Union[str, Error]]: ...
     def __init__(self) -> None: ...
-    def formfield_for_dbfield(self, db_field: Field, request: WSGIRequest, **kwargs: Any) -> Optional[Field]: ...
-    def formfield_for_choice_field(self, db_field: Field, request: WSGIRequest, **kwargs: Any) -> TypedChoiceField: ...
-    def get_field_queryset(self, db: None, db_field: RelatedField, request: WSGIRequest) -> Optional[QuerySet]: ...
+    def formfield_for_dbfield(
+        self, db_field: Field, request: Optional[HttpRequest], **kwargs: Any
+    ) -> Optional[Field]: ...
+    def formfield_for_choice_field(
+        self, db_field: Field, request: Optional[HttpRequest], **kwargs: Any
+    ) -> TypedChoiceField: ...
+    def get_field_queryset(
+        self, db: None, db_field: RelatedField, request: Optional[HttpRequest]
+    ) -> Optional[QuerySet]: ...
     def formfield_for_foreignkey(
-        self, db_field: ForeignKey, request: WSGIRequest, **kwargs: Any
+        self, db_field: ForeignKey, request: Optional[HttpRequest], **kwargs: Any
     ) -> Optional[ModelChoiceField]: ...
     def formfield_for_manytomany(
-        self, db_field: ManyToManyField, request: 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
     list_display: Sequence[Union[str, Callable]] = ...
-    list_display_links: Sequence[Union[str, Callable]] = ...
+    list_display_links: Optional[Sequence[Union[str, Callable]]] = ...
     list_filter: Sequence[Union[str, Type[ListFilter], Tuple[str, Type[ListFilter]]]] = ...
     list_select_related: Union[bool, Sequence[str]] = ...
     list_per_page: int = ...
@@ -121,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 = ...,
@@ -176,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(
@@ -190,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 = ...
@@ -244,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/utils.pyi

@@ -43,7 +43,7 @@ class NestedObjects(Collector):
     def add_edge(self, source: Optional[Model], target: Model) -> None: ...
     def collect(
         self,
-        objs: Union[Sequence[Model], QuerySet],
+        objs: Union[Sequence[Optional[Model]], QuerySet],
         source: Optional[Type[Model]] = ...,
         source_attr: Optional[str] = ...,
         **kwargs: Any

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,54 +1,18 @@
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any
 
-from django.contrib.auth.models import User, Group
 from django.core.handlers.wsgi import WSGIRequest
-from django.db.models.fields.related import ManyToManyField
-from django.forms.models import ModelMultipleChoiceField
 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[Union[django.db.models.fields.DateTimeCheckMixin, Field]],
-        Dict[str, Type[Union[django.forms.fields.SplitDateTimeField, 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/base_user.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Tuple, List
+from typing import Any, Optional, Tuple, List, overload
 
 from django.db import models
 
@@ -30,4 +30,8 @@ class AbstractBaseUser(models.Model):
     @classmethod
     def get_email_field_name(cls) -> str: ...
     @classmethod
+    @overload
     def normalize_username(cls, username: str) -> str: ...
+    @classmethod
+    @overload
+    def normalize_username(cls, username: Any) -> Any: ...

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

@@ -1,6 +1,6 @@
 from typing import Any, Callable, List, Optional
 
-from django.core.handlers.wsgi import WSGIRequest
+from django import http
 from django.http.response import HttpResponse, HttpResponseRedirect
 
 class AccessMixin:
@@ -14,15 +14,15 @@ class AccessMixin:
     def handle_no_permission(self) -> HttpResponseRedirect: ...
 
 class LoginRequiredMixin(AccessMixin):
-    def dispatch(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
 
 class PermissionRequiredMixin(AccessMixin):
     permission_required: Any = ...
     def get_permission_required(self) -> List[str]: ...
     def has_permission(self) -> bool: ...
-    def dispatch(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
 
 class UserPassesTestMixin(AccessMixin):
     def test_func(self) -> None: ...
     def get_test_func(self) -> Callable: ...
-    def dispatch(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...

django-stubs/contrib/auth/models.pyi

@@ -15,7 +15,7 @@ class PermissionManager(models.Manager):
 class Permission(models.Model):
     content_type_id: int
     name: models.CharField = ...
-    content_type: models.ForeignKey[ContentType] = ...
+    content_type: models.ForeignKey = models.ForeignKey(ContentType, on_delete=models.CASCADE)
     codename: models.CharField = ...
     def natural_key(self) -> Tuple[str, str, str]: ...
 
@@ -24,7 +24,7 @@ class GroupManager(models.Manager):
 
 class Group(models.Model):
     name: models.CharField = ...
-    permissions: models.ManyToManyField[Permission] = ...
+    permissions: models.ManyToManyField = models.ManyToManyField(Permission)
     def natural_key(self): ...
 
 class UserManager(BaseUserManager):
@@ -37,8 +37,8 @@ class UserManager(BaseUserManager):
 
 class PermissionsMixin(models.Model):
     is_superuser: models.BooleanField = ...
-    groups: models.ManyToManyField[Group] = ...
-    user_permissions: models.ManyToManyField[Permission] = ...
+    groups: models.ManyToManyField = models.ManyToManyField(Group)
+    user_permissions: models.ManyToManyField = models.ManyToManyField(Permission)
     def get_group_permissions(self, obj: None = ...) -> Set[str]: ...
     def get_all_permissions(self, obj: Optional[str] = ...) -> Set[str]: ...
     def has_perm(self, perm: Union[Tuple[str, Any], str], obj: Optional[str] = ...) -> bool: ...

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

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union, Generic
 
 from django.contrib.contenttypes.models import ContentType
 from django.core.checks.messages import Error

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

@@ -4,12 +4,7 @@ from django.db import models
 from django.db.models.base import Model
 from django.db.models.query import QuerySet
 
-class ContentTypeManager(models.Manager):
-    creation_counter: int
-    model: None
-    name: None
-    use_in_migrations: bool = ...
-    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+class ContentTypeManager(models.Manager["ContentType"]):
     def get_by_natural_key(self, app_label: str, model: str) -> ContentType: ...
     def get_for_model(self, model: Union[Type[Model], Model], for_concrete_model: bool = ...) -> ContentType: ...
     def get_for_models(self, *models: Any, for_concrete_models: bool = ...) -> Dict[Type[Model], ContentType]: ...
@@ -18,9 +13,9 @@ class ContentTypeManager(models.Manager):
 
 class ContentType(models.Model):
     id: int
-    app_label: str = ...
-    model: str = ...
-    objects: Any = ...
+    app_label: models.CharField = ...
+    model: models.CharField = ...
+    objects: ContentTypeManager = ...
     @property
     def name(self) -> str: ...
     def model_class(self) -> Optional[Type[Model]]: ...

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

@@ -1,14 +1,13 @@
-from typing import Any, Optional
+from django.contrib.sites.models import Site
 
 from django.db import models
 
 class FlatPage(models.Model):
-    id: None
-    url: str = ...
-    title: str = ...
-    content: str = ...
-    enable_comments: bool = ...
-    template_name: str = ...
-    registration_required: bool = ...
-    sites: Any = ...
+    url: models.CharField = ...
+    title: models.CharField = ...
+    content: models.TextField = ...
+    enable_comments: models.BooleanField = ...
+    template_name: models.CharField = ...
+    registration_required: models.BooleanField = ...
+    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/postgres/fields/array.pyi

@@ -1,20 +1,51 @@
-from typing import Any, Generic, List, Optional, Sequence, TypeVar
+from typing import Any, Iterable, List, Optional, Sequence, TypeVar, Union
+
+from django.db.models.expressions import Combinable
+from django.db.models.fields import Field, _ErrorMessagesToOverride, _FieldChoices, _ValidatorCallable
 
-from django.db.models.fields import Field
 from .mixins import CheckFieldDefaultMixin
 
-_T = TypeVar("_T", bound=Field)
+# __set__ value type
+_ST = TypeVar("_ST")
+# __get__ return type
+_GT = TypeVar("_GT")
+
+class ArrayField(CheckFieldDefaultMixin, Field[_ST, _GT]):
+    _pyi_private_set_type: Union[Sequence[Any], Combinable]
+    _pyi_private_get_type: List[Any]
 
-class ArrayField(CheckFieldDefaultMixin, Field, Generic[_T]):
     empty_strings_allowed: bool = ...
     default_error_messages: Any = ...
     base_field: Any = ...
     size: Any = ...
     default_validators: Any = ...
     from_db_value: Any = ...
-    def __init__(self, base_field: _T, size: Optional[int] = ..., **kwargs: Any) -> None: ...
+    def __init__(
+        self,
+        base_field: Field,
+        size: Optional[int] = ...,
+        verbose_name: Optional[Union[str, bytes]] = ...,
+        name: Optional[str] = ...,
+        primary_key: bool = ...,
+        max_length: Optional[int] = ...,
+        unique: bool = ...,
+        blank: bool = ...,
+        null: bool = ...,
+        db_index: bool = ...,
+        default: Any = ...,
+        editable: bool = ...,
+        auto_created: bool = ...,
+        serialize: bool = ...,
+        unique_for_date: Optional[str] = ...,
+        unique_for_month: Optional[str] = ...,
+        unique_for_year: Optional[str] = ...,
+        choices: Optional[_FieldChoices] = ...,
+        help_text: str = ...,
+        db_column: Optional[str] = ...,
+        db_tablespace: Optional[str] = ...,
+        validators: Iterable[_ValidatorCallable] = ...,
+        error_messages: Optional[_ErrorMessagesToOverride] = ...,
+    ) -> None: ...
     @property
     def description(self): ...
     def get_transform(self, name: Any): ...
-    def __set__(self, instance, value: Sequence[_T]) -> None: ...
-    def __get__(self, instance, owner) -> List[_T]: ...

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

@@ -1,6 +1,5 @@
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, Union
+from typing import Any, Dict, Iterator, List, Mapping, Optional, Tuple, Union
 
-from django.db.models.base import Model
 from django.forms.utils import ErrorDict
 
 class FieldDoesNotExist(Exception): ...
@@ -31,20 +30,13 @@ class ValidationError(Exception):
     message: Any = ...
     code: Any = ...
     params: Any = ...
-    def __init__(
-        self,
-        message: Any,
-        code: Optional[str] = ...,
-        params: Optional[
-            Union[Dict[str, Union[Tuple[str], Type[Model], Model, str]], Dict[str, Union[int, str]]]
-        ] = ...,
-    ) -> None: ...
+    def __init__(self, message: Any, code: Optional[str] = ..., params: Optional[Mapping[str, Any]] = ...) -> None: ...
     @property
     def message_dict(self) -> Dict[str, List[str]]: ...
     @property
     def messages(self) -> List[str]: ...
     def update_error_dict(
-        self, error_dict: Union[Dict[str, List[ValidationError]], ErrorDict]
+        self, error_dict: Mapping[str, Any]
     ) -> Union[Dict[str, List[ValidationError]], ErrorDict]: ...
     def __iter__(self) -> Iterator[Union[Tuple[str, List[str]], 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/files/uploadedfile.pyi

@@ -1,45 +1,48 @@
-# Stubs for django.core.files.uploadedfile (Python 3.5)
-
 from typing import Any, Dict, IO, Iterator, Optional, Union
 from django.core.files import temp as tempfile
 from django.core.files.base import File
 
 class UploadedFile(File):
-    content_type = ...  # type: Optional[str]
-    charset = ...  # type: Optional[str]
-    content_type_extra = ...  # type: Optional[Dict[str, str]]
+    content_type: Optional[str] = ...
+    charset: Optional[str] = ...
+    content_type_extra: Optional[Dict[str, str]] = ...
     def __init__(
         self,
-        file: IO,
-        name: str = None,
-        content_type: str = None,
-        size: int = None,
-        charset: str = None,
-        content_type_extra: Dict[str, str] = None,
+        file: Optional[IO] = ...,
+        name: Optional[str] = ...,
+        content_type: Optional[str] = ...,
+        size: Optional[int] = ...,
+        charset: Optional[str] = ...,
+        content_type_extra: Optional[Dict[str, str]] = ...,
     ) -> None: ...
 
 class TemporaryUploadedFile(UploadedFile):
     def __init__(
-        self, name: str, content_type: str, size: int, charset: str, content_type_extra: Dict[str, str] = None
+        self,
+        name: Optional[str],
+        content_type: Optional[str],
+        size: Optional[int],
+        charset: Optional[str],
+        content_type_extra: Optional[Dict[str, str]] = ...,
     ) -> None: ...
     def temporary_file_path(self) -> str: ...
 
 class InMemoryUploadedFile(UploadedFile):
-    field_name = ...  # type: Optional[str]
+    field_name: Optional[str] = ...
     def __init__(
         self,
         file: IO,
         field_name: Optional[str],
-        name: str,
+        name: Optional[str],
         content_type: Optional[str],
-        size: int,
+        size: Optional[int],
         charset: Optional[str],
-        content_type_extra: Dict[str, str] = None,
+        content_type_extra: Dict[str, str] = ...,
     ) -> None: ...
-    def chunks(self, chunk_size: int = None) -> Iterator[bytes]: ...
-    def multiple_chunks(self, chunk_size: int = None) -> bool: ...
+    def chunks(self, chunk_size: Optional[int] = ...) -> Iterator[bytes]: ...
+    def multiple_chunks(self, chunk_size: Optional[int] = ...) -> bool: ...
 
 class SimpleUploadedFile(InMemoryUploadedFile):
-    def __init__(self, name: str, content: bytes, content_type: str = "") -> None: ...
+    def __init__(self, name: str, content: Optional[Union[bytes, str]], content_type: str = ...) -> None: ...
     @classmethod
     def from_dict(cls: Any, file_dict: Dict[str, Union[str, bytes]]) -> None: ...

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]]] = ...
@@ -46,12 +45,12 @@ class FieldRelatedOptionOperation(ModelOptionOperation): ...
 class AlterUniqueTogether(FieldRelatedOptionOperation):
     option_name: str = ...
     unique_together: Collection[Sequence[str]] = ...
-    def __init__(self, name: str, unique_together: Collection[Sequence[str]]) -> None: ...
+    def __init__(self, name: str, unique_together: Optional[Collection[Sequence[str]]]) -> None: ...
 
 class AlterIndexTogether(FieldRelatedOptionOperation):
     option_name: str = ...
     index_together: Collection[Sequence[str]] = ...
-    def __init__(self, name: str, index_together: Collection[Sequence[str]]) -> None: ...
+    def __init__(self, name: str, index_together: Optional[Collection[Sequence[str]]]) -> None: ...
 
 class AlterOrderWithRespectTo(FieldRelatedOptionOperation):
     order_with_respect_to: 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
 
@@ -22,9 +21,9 @@ class ModelState:
     name: str
     app_label: str
     fields: List[Tuple[str, Field]]
-    options: Optional[Dict[str, Any]] = ...
-    bases: Optional[Tuple[Type[Model]]] = ...
-    managers: Optional[List[Tuple[str, Manager]]] = ...
+    options: Dict[str, Any] = ...
+    bases: Tuple[Type[Model]] = ...
+    managers: List[Tuple[str, Manager]] = ...
     def __init__(
         self,
         app_label: str,

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: Any = ...
+    function: str = ...
+    name: str = ...
     template: str = ...
     arg_joiner: str = ...
-    arity: Any = ...
-    source_expressions: List[Expression] = ...
-    extra: Any = ...
+    arity: int = ...
+    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/fields/__init__.pyi

@@ -1,16 +1,14 @@
-import uuid
-from datetime import date, time, datetime, timedelta
-from typing import Any, Optional, Tuple, Iterable, Callable, Dict, Union, Type, TypeVar, Generic
 import decimal
-
-from typing_extensions import Literal
+import uuid
+from datetime import date, datetime, time, timedelta
+from typing import Any, Callable, Dict, Generic, Iterable, Optional, Tuple, Type, TypeVar, Union
 
 from django.db.models import Model
-from django.db.models.query_utils import RegisterLookupMixin
-
-from django.db.models.expressions import F, Combinable
 from django.core.exceptions import FieldDoesNotExist as FieldDoesNotExist
-from django.forms import Widget, Field as FormField
+from django.db.models.expressions import Combinable
+from django.db.models.query_utils import RegisterLookupMixin
+from django.forms import Field as FormField, Widget
+
 from .mixins import NOT_PROVIDED as NOT_PROVIDED
 
 _Choice = Tuple[Any, Any]
@@ -20,7 +18,15 @@ _FieldChoices = Iterable[Union[_Choice, _ChoiceNamedGroup]]
 _ValidatorCallable = Callable[..., None]
 _ErrorMessagesToOverride = Dict[str, Any]
 
-class Field(RegisterLookupMixin):
+# __set__ value type
+_ST = TypeVar("_ST")
+# __get__ return type
+_GT = TypeVar("_GT")
+
+class Field(RegisterLookupMixin, Generic[_ST, _GT]):
+    _pyi_private_set_type: Any
+    _pyi_private_get_type: Any
+
     widget: Widget
     help_text: str
     db_table: str
@@ -52,7 +58,8 @@ class Field(RegisterLookupMixin):
         validators: Iterable[_ValidatorCallable] = ...,
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
-    def __get__(self, instance, owner) -> Any: ...
+    def __set__(self, instance, value: _ST) -> None: ...
+    def __get__(self, instance, owner) -> _GT: ...
     def deconstruct(self) -> Any: ...
     def set_attributes_from_name(self, name: str) -> None: ...
     def db_type(self, connection: Any) -> str: ...
@@ -63,23 +70,25 @@ class Field(RegisterLookupMixin):
     def contribute_to_class(self, cls: Type[Model], name: str, private_only: bool = ...) -> None: ...
     def to_python(self, value: Any) -> Any: ...
 
-class IntegerField(Field):
-    def __set__(self, instance, value: Union[int, Combinable, Literal[""]]) -> None: ...
-    def __get__(self, instance, owner) -> int: ...
+class IntegerField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[float, int, str, Combinable]
+    _pyi_private_get_type: int
 
 class PositiveIntegerRelDbTypeMixin:
     def rel_db_type(self, connection: Any): ...
 
-class PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField): ...
-class PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField): ...
-class SmallIntegerField(IntegerField): ...
-class BigIntegerField(IntegerField): ...
+class PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField[_ST, _GT]): ...
+class PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField[_ST, _GT]): ...
+class SmallIntegerField(IntegerField[_ST, _GT]): ...
+class BigIntegerField(IntegerField[_ST, _GT]): ...
 
-class FloatField(Field):
-    def __set__(self, instance, value: Union[float, int, str, Combinable]) -> float: ...
-    def __get__(self, instance, owner) -> float: ...
+class FloatField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[float, int, str, Combinable]
+    _pyi_private_get_type: float
 
-class DecimalField(Field):
+class DecimalField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, float, decimal.Decimal, Combinable]
+    _pyi_private_get_type: decimal.Decimal
     def __init__(
         self,
         verbose_name: Optional[Union[str, bytes]] = ...,
@@ -102,13 +111,14 @@ class DecimalField(Field):
         validators: Iterable[_ValidatorCallable] = ...,
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
-    def __set__(self, instance, value: Union[str, float, decimal.Decimal, Combinable]) -> decimal.Decimal: ...
-    def __get__(self, instance, owner) -> decimal.Decimal: ...
 
-class AutoField(Field):
-    def __get__(self, instance, owner) -> int: ...
+class AutoField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[Combinable, int, str]
+    _pyi_private_get_type: int
 
-class CharField(Field):
+class CharField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, int, Combinable]
+    _pyi_private_get_type: str
     def __init__(
         self,
         verbose_name: Optional[Union[str, bytes]] = ...,
@@ -133,10 +143,8 @@ class CharField(Field):
         validators: Iterable[_ValidatorCallable] = ...,
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
-    def __set__(self, instance, value: Union[str, int, Combinable]) -> None: ...
-    def __get__(self, instance, owner) -> str: ...
 
-class SlugField(CharField):
+class SlugField(CharField[_ST, _GT]):
     def __init__(
         self,
         verbose_name: Optional[Union[str, bytes]] = ...,
@@ -163,25 +171,29 @@ class SlugField(CharField):
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
 
-class EmailField(CharField): ...
-class URLField(CharField): ...
+class EmailField(CharField[_ST, _GT]): ...
+class URLField(CharField[_ST, _GT]): ...
 
-class TextField(Field):
-    def __set__(self, instance, value: Union[str, Combinable]) -> None: ...
-    def __get__(self, instance, owner) -> str: ...
+class TextField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, Combinable]
+    _pyi_private_get_type: str
 
-class BooleanField(Field):
-    def __set__(self, instance, value: Union[bool, Combinable]) -> None: ...
-    def __get__(self, instance, owner) -> bool: ...
+class BooleanField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[bool, Combinable]
+    _pyi_private_get_type: bool
 
-class NullBooleanField(Field):
-    def __set__(self, instance, value: Optional[Union[bool, Combinable]]) -> None: ...
-    def __get__(self, instance, owner) -> Optional[bool]: ...
+class NullBooleanField(Field[_ST, _GT]):
+    _pyi_private_set_type: Optional[Union[bool, Combinable]]
+    _pyi_private_get_type: Optional[bool]
 
-class IPAddressField(Field):
-    def __get__(self, instance, owner) -> str: ...
+class IPAddressField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, Combinable]
+    _pyi_private_get_type: str
+
+class GenericIPAddressField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, int, Callable[..., Any], Combinable]
+    _pyi_private_get_type: str
 
-class GenericIPAddressField(Field):
     default_error_messages: Any = ...
     unpack_ipv4: Any = ...
     protocol: Any = ...
@@ -207,11 +219,12 @@ class GenericIPAddressField(Field):
         validators: Iterable[_ValidatorCallable] = ...,
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ) -> None: ...
-    def __get__(self, instance, owner) -> str: ...
 
 class DateTimeCheckMixin: ...
 
-class DateField(DateTimeCheckMixin, Field):
+class DateField(DateTimeCheckMixin, Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, date, Combinable]
+    _pyi_private_get_type: date
     def __init__(
         self,
         verbose_name: Optional[Union[str, bytes]] = ...,
@@ -235,10 +248,10 @@ class DateField(DateTimeCheckMixin, Field):
         validators: Iterable[_ValidatorCallable] = ...,
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
-    def __set__(self, instance, value: Union[str, date, Combinable]) -> None: ...
-    def __get__(self, instance, owner) -> date: ...
 
-class TimeField(DateTimeCheckMixin, Field):
+class TimeField(DateTimeCheckMixin, Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, time, datetime, Combinable]
+    _pyi_private_get_type: time
     def __init__(
         self,
         verbose_name: Optional[Union[str, bytes]] = ...,
@@ -261,18 +274,15 @@ class TimeField(DateTimeCheckMixin, Field):
         validators: Iterable[_ValidatorCallable] = ...,
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
-    def __set__(self, instance, value: Union[str, time, datetime, Combinable]) -> None: ...
-    def __get__(self, instance, owner) -> time: ...
 
-class DateTimeField(DateField):
-    def __set__(self, instance, value: Union[str, date, datetime, Combinable]) -> None: ...
-    def __get__(self, instance, owner) -> datetime: ...
+class DateTimeField(DateField[_ST, _GT]):
+    _pyi_private_get_type: datetime
 
-class UUIDField(Field):
-    def __set__(self, instance, value: Any) -> None: ...
-    def __get__(self, instance, owner) -> uuid.UUID: ...
+class UUIDField(Field[_ST, _GT]):
+    _pyi_private_set_type: Union[str, uuid.UUID]
+    _pyi_private_get_type: uuid.UUID
 
-class FilePathField(Field):
+class FilePathField(Field[_ST, _GT]):
     path: str = ...
     match: Optional[Any] = ...
     recursive: bool = ...
@@ -305,10 +315,10 @@ class FilePathField(Field):
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
 
-class BinaryField(Field): ...
+class BinaryField(Field[_ST, _GT]): ...
 
-class DurationField(Field):
-    def __get__(self, instance, owner) -> timedelta: ...
+class DurationField(Field[_ST, _GT]):
+    _pyi_private_get_type: timedelta
 
-class BigAutoField(AutoField): ...
-class CommaSeparatedIntegerField(CharField): ...
+class BigAutoField(AutoField[_ST, _GT]): ...
+class CommaSeparatedIntegerField(CharField[_ST, _GT]): ...

django-stubs/db/models/fields/related.pyi

@@ -33,7 +33,7 @@ from django.db.models.fields.reverse_related import (
 )
 from django.db.models.query_utils import PathInfo, Q
 
-from django.db.models.expressions import F
+from django.db.models.expressions import Combinable
 
 if TYPE_CHECKING:
     from django.db.models.manager import RelatedManager
@@ -49,7 +49,12 @@ _ErrorMessagesToOverride = Dict[str, Any]
 
 RECURSIVE_RELATIONSHIP_CONSTANT: str = ...
 
-class RelatedField(FieldCacheMixin, Field):
+# __set__ value type
+_ST = TypeVar("_ST")
+# __get__ return type
+_GT = TypeVar("_GT")
+
+class RelatedField(FieldCacheMixin, Field[_ST, _GT]):
     one_to_many: bool = ...
     one_to_one: bool = ...
     many_to_many: bool = ...
@@ -83,6 +88,7 @@ class ForeignObject(RelatedField):
         related_query_name: None = ...,
         limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ...,
         parent_link: bool = ...,
+        db_constraint: bool = ...,
         swappable: bool = ...,
         verbose_name: Optional[str] = ...,
         name: Optional[str] = ...,
@@ -103,16 +109,82 @@ class ForeignObject(RelatedField):
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
 
-class ForeignKey(RelatedField, Generic[_T]):
-    def __init__(self, to: Union[Type[_T], str], on_delete: Any, related_name: str = ..., **kwargs): ...
-    def __set__(self, instance, value: Union[Model, F]) -> None: ...
-    def __get__(self, instance, owner) -> _T: ...
+class ForeignKey(RelatedField[_ST, _GT]):
+    _pyi_private_set_type: Union[Any, Combinable]
+    _pyi_private_get_type: Any
+    def __init__(
+        self,
+        to: Union[Type[Model], str],
+        on_delete: Callable[..., None],
+        to_field: Optional[str] = ...,
+        related_name: str = ...,
+        related_query_name: Optional[str] = ...,
+        limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any], Q]] = ...,
+        parent_link: bool = ...,
+        db_constraint: bool = ...,
+        verbose_name: Optional[Union[str, bytes]] = ...,
+        name: Optional[str] = ...,
+        primary_key: bool = ...,
+        max_length: Optional[int] = ...,
+        unique: bool = ...,
+        blank: bool = ...,
+        null: bool = ...,
+        db_index: bool = ...,
+        default: Any = ...,
+        editable: bool = ...,
+        auto_created: bool = ...,
+        serialize: bool = ...,
+        unique_for_date: Optional[str] = ...,
+        unique_for_month: Optional[str] = ...,
+        unique_for_year: Optional[str] = ...,
+        choices: Optional[_FieldChoices] = ...,
+        help_text: str = ...,
+        db_column: Optional[str] = ...,
+        db_tablespace: Optional[str] = ...,
+        validators: Iterable[_ValidatorCallable] = ...,
+        error_messages: Optional[_ErrorMessagesToOverride] = ...,
+    ): ...
 
-class OneToOneField(RelatedField, Generic[_T]):
-    def __init__(self, to: Union[Type[_T], str], on_delete: Any, related_name: str = ..., **kwargs): ...
-    def __get__(self, instance, owner) -> _T: ...
+class OneToOneField(RelatedField[_ST, _GT]):
+    _pyi_private_set_type: Union[Any, Combinable]
+    _pyi_private_get_type: Any
+    def __init__(
+        self,
+        to: Union[Type[Model], str],
+        on_delete: Any,
+        to_field: Optional[str] = ...,
+        related_name: str = ...,
+        related_query_name: Optional[str] = ...,
+        limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any], Q]] = ...,
+        parent_link: bool = ...,
+        db_constraint: bool = ...,
+        verbose_name: Optional[Union[str, bytes]] = ...,
+        name: Optional[str] = ...,
+        primary_key: bool = ...,
+        max_length: Optional[int] = ...,
+        unique: bool = ...,
+        blank: bool = ...,
+        null: bool = ...,
+        db_index: bool = ...,
+        default: Any = ...,
+        editable: bool = ...,
+        auto_created: bool = ...,
+        serialize: bool = ...,
+        unique_for_date: Optional[str] = ...,
+        unique_for_month: Optional[str] = ...,
+        unique_for_year: Optional[str] = ...,
+        choices: Optional[_FieldChoices] = ...,
+        help_text: str = ...,
+        db_column: Optional[str] = ...,
+        db_tablespace: Optional[str] = ...,
+        validators: Iterable[_ValidatorCallable] = ...,
+        error_messages: Optional[_ErrorMessagesToOverride] = ...,
+    ): ...
+
+class ManyToManyField(RelatedField[_ST, _GT]):
+    _pyi_private_set_type: Sequence[Any]
+    _pyi_private_get_type: RelatedManager[Any]
 
-class ManyToManyField(RelatedField, Generic[_T]):
     many_to_many: bool = ...
     many_to_one: bool = ...
     one_to_many: bool = ...
@@ -126,17 +198,35 @@ class ManyToManyField(RelatedField, Generic[_T]):
         to: Union[Type[_T], str],
         related_name: Optional[str] = ...,
         related_query_name: Optional[str] = ...,
-        limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ...,
+        limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any], Q]] = ...,
         symmetrical: Optional[bool] = ...,
         through: Optional[Union[str, Type[Model]]] = ...,
         through_fields: Optional[Tuple[str, str]] = ...,
         db_constraint: bool = ...,
         db_table: Optional[str] = ...,
         swappable: bool = ...,
-        **kwargs: Any
+        verbose_name: Optional[Union[str, bytes]] = ...,
+        name: Optional[str] = ...,
+        primary_key: bool = ...,
+        max_length: Optional[int] = ...,
+        unique: bool = ...,
+        blank: bool = ...,
+        null: bool = ...,
+        db_index: bool = ...,
+        default: Any = ...,
+        editable: bool = ...,
+        auto_created: bool = ...,
+        serialize: bool = ...,
+        unique_for_date: Optional[str] = ...,
+        unique_for_month: Optional[str] = ...,
+        unique_for_year: Optional[str] = ...,
+        choices: Optional[_FieldChoices] = ...,
+        help_text: str = ...,
+        db_column: Optional[str] = ...,
+        db_tablespace: Optional[str] = ...,
+        validators: Iterable[_ValidatorCallable] = ...,
+        error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ) -> None: ...
-    def __set__(self, instance, value: Sequence[_T]) -> None: ...
-    def __get__(self, instance, owner) -> RelatedManager[_T]: ...
     def check(self, **kwargs: Any) -> List[Any]: ...
     def deconstruct(self) -> Tuple[Optional[str], str, List[Any], Dict[str, str]]: ...
     def get_path_info(self, filtered_relation: None = ...) -> List[PathInfo]: ...

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