Improves README with new example repo, python version matrix

.gitignore

@@ -8,7 +8,4 @@ out/
 build/
 dist/
 pip-wheel-metadata/
-.pytest_cache/
-/.envrc
-/.direnv
-django-sources/
+.pytest_cache/

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "django-sources"]
+	path = django-sources
+	url = https://github.com/django/django.git
+	branch = stable/2.2.x

.travis.yml

@@ -8,20 +8,13 @@ jobs:
       python: 3.7
       script: 'pytest'
 
-    - name: Typecheck Django 3.0 test suite with python 3.7
+    - name: Typecheck Django test suite with python 3.7
       python: 3.7
-      script: |
-        python ./scripts/typecheck_tests.py --django_version=3.0
+      script: 'python ./scripts/typecheck_tests.py'
 
-    - name: Typecheck Django 3.0 test suite with python 3.6
+    - name: Typecheck Django test suite with python 3.6
       python: 3.6
-      script: |
-        python ./scripts/typecheck_tests.py --django_version=3.0
-
-    - name: Typecheck Django 2.2 test suite with python 3.7
-      python: 3.7
-      script: |
-        python ./scripts/typecheck_tests.py --django_version=2.2
+      script: 'python ./scripts/typecheck_tests.py'
 
     - name: Mypy for plugin code
       python: 3.7
@@ -44,9 +37,8 @@ jobs:
       script: 'isort --check --diff'
 
 before_install: |
-  sudo add-apt-repository ppa:ubuntugis/ubuntugis-unstable -y
-  sudo apt-get update
-  sudo apt-get install -y binutils libproj-dev gdal-bin
+  sudo apt update
+  sudo apt install binutils libproj-dev gdal-bin
   pip install -U pip setuptools wheel
 install: |
   pip install -r ./dev-requirements.txt

README.md

@@ -2,7 +2,7 @@
 
 # pep484 stubs for Django framework
 
-[![Build Status](https://travis-ci.com/typeddjango/django-stubs.svg?branch=master)](https://travis-ci.com/typeddjango/django-stubs)
+[![Build Status](https://travis-ci.org/typeddjango/django-stubs.svg?branch=master)](https://travis-ci.org/typeddjango/django-stubs)
 [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
 [![Gitter](https://badges.gitter.im/mypy-django/Lobby.svg)](https://gitter.im/mypy-django/Lobby)
 
@@ -22,7 +22,6 @@ pip install django-stubs
 
 | django-stubs | mypy version | django version | python version
 | ------------ | ---- | ---- | ---- |
-| 1.3.0 | 0.750 | 2.2.x | ^3.6
 | 1.2.0 | 0.730 | 2.2.x | ^3.6
 | 1.1.0 | 0.720 | 2.2.x | ^3.6
 | 0.12.x | old semantic analyzer (<0.711), dmypy support | 2.1.x | ^3.6
@@ -53,6 +52,12 @@ django_settings_module = mysettings
 
 Where `mysettings` is a value of `DJANGO_SETTINGS_MODULE` (with or without quotes)
 
+You might also need to explicitly tweak your `PYTHONPATH` the very same way `django` does it internally in case you have troubles with mypy / django plugin not finding your settings module. Try adding the root path of your project to your `PYTHONPATH` environment variable like so:
+
+```bash
+PYTHONPATH=${PYTHONPATH}:${PWD}
+```
+
 Current implementation uses Django runtime to extract models information, so it will crash, if your installed apps `models.py` is not correct. For this same reason, you cannot use `reveal_type` inside global scope of any Python file that will be executed for `django.setup()`. 
 
 In other words, if your `manage.py runserver` crashes, mypy will crash too. 
@@ -70,7 +75,7 @@ class MyUserManager(models.Manager['MyUser']):
     pass
 
 class MyUser(models.Model):
-    objects = MyUserManager()
+    objects = UserManager()
 ```
 
 work, which should make a error messages a bit better. 

dev-requirements.txt

@@ -1,8 +1,7 @@
 black
 pytest-mypy-plugins==1.1.0
 psycopg2
-flake8==3.7.9
+flake8==3.7.8
 flake8-pyi==19.3.0
 isort==4.3.21
-gitpython==3.0.5
 -e .

django-stubs/apps/config.pyi

@@ -1,6 +1,5 @@
 from typing import Any, Iterator, Type, Optional, Dict
 
-from django.apps.registry import Apps
 from django.db.models.base import Model
 
 MODELS_MODULE_NAME: str
@@ -8,11 +7,11 @@ MODELS_MODULE_NAME: str
 class AppConfig:
     name: str = ...
     module: Optional[Any] = ...
-    apps: Optional[Apps] = ...
+    apps: None = ...
     label: str = ...
     verbose_name: str = ...
     path: str = ...
-    models_module: Optional[str] = ...
+    models_module: None = ...
     models: Dict[str, Type[Model]] = ...
     def __init__(self, app_name: str, app_module: Optional[Any]) -> None: ...
     @classmethod

django-stubs/apps/registry.pyi

@@ -1,22 +1,24 @@
 import threading
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Type, Union
+from collections import OrderedDict
+from typing import Any, Callable, DefaultDict, Dict, Iterable, List, Optional, Tuple, Type, Union
 
+from django.db.migrations.state import AppConfigStub
 from django.db.models.base import Model
 
 from .config import AppConfig
 
 class Apps:
-    all_models: Dict[str, Dict[str, Type[Model]]] = ...
-    app_configs: Dict[str, AppConfig] = ...
+    all_models: Dict[str, OrderedDict[str, Type[Model]]] = ...
+    app_configs: OrderedDict[str, AppConfig] = ...
     stored_app_configs: List[Any] = ...
     apps_ready: bool = ...
     ready_event: threading.Event = ...
     loading: bool = ...
-    _pending_operations: Dict[Tuple[str, str], List]
+    _pending_operations: DefaultDict[Tuple[str, str], List]
     models_ready: bool = ...
     ready: bool = ...
-    def __init__(self, installed_apps: Optional[Iterable[Union[AppConfig, str]]] = ...) -> None: ...
-    def populate(self, installed_apps: Iterable[Union[AppConfig, str]] = ...) -> None: ...
+    def __init__(self, installed_apps: Optional[Union[List[AppConfigStub], List[str], Tuple]] = ...) -> None: ...
+    def populate(self, installed_apps: Union[List[AppConfigStub], List[str], Tuple] = ...) -> None: ...
     def check_apps_ready(self) -> None: ...
     def check_models_ready(self) -> None: ...
     def get_app_configs(self) -> Iterable[AppConfig]: ...
@@ -29,9 +31,9 @@ class Apps:
     def get_containing_app_config(self, object_name: str) -> Optional[AppConfig]: ...
     def get_registered_model(self, app_label: str, model_name: str) -> Type[Model]: ...
     def get_swappable_settings_name(self, to_string: str) -> Optional[str]: ...
-    def set_available_apps(self, available: Iterable[str]) -> None: ...
+    def set_available_apps(self, available: List[str]) -> None: ...
     def unset_available_apps(self) -> None: ...
-    def set_installed_apps(self, installed: Iterable[str]) -> None: ...
+    def set_installed_apps(self, installed: Union[List[str], Tuple[str]]) -> None: ...
     def unset_installed_apps(self) -> None: ...
     def clear_cache(self) -> None: ...
     def lazy_model_operation(self, function: Callable, *model_keys: Any) -> None: ...

django-stubs/conf/global_settings.pyi

@@ -345,7 +345,7 @@ SESSION_COOKIE_PATH = "/"
 SESSION_COOKIE_HTTPONLY = True
 # Whether to set the flag restricting cookie leaks on cross-site requests.
 # This can be 'Lax', 'Strict', or None to disable the flag.
-SESSION_COOKIE_SAMESITE: Optional[str] = ...
+SESSION_COOKIE_SAMESITE = "Lax"
 # Whether to save the session data on every request.
 SESSION_SAVE_EVERY_REQUEST = False
 # Whether a user's session cookie expires when the Web browser is closed.
@@ -413,7 +413,7 @@ CSRF_COOKIE_DOMAIN = None
 CSRF_COOKIE_PATH = "/"
 CSRF_COOKIE_SECURE = False
 CSRF_COOKIE_HTTPONLY = False
-CSRF_COOKIE_SAMESITE: Optional[str] = ...
+CSRF_COOKIE_SAMESITE = "Lax"
 CSRF_HEADER_NAME = "HTTP_X_CSRFTOKEN"
 CSRF_TRUSTED_ORIGINS: List[str] = ...
 CSRF_USE_SESSIONS = False

django-stubs/contrib/admin/checks.pyi

@@ -1,13 +1,11 @@
-from typing import Any, List, Union, Iterable, Optional
+from typing import Any, List, Union
 
 from django.contrib.admin.options import BaseModelAdmin
 from django.core.checks.messages import Error
 
-from django.apps.config import AppConfig
-
 _CheckError = Union[str, Error]
 
-def check_admin_app(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[_CheckError]: ...
+def check_admin_app(app_configs: None, **kwargs: Any) -> List[_CheckError]: ...
 def check_dependencies(**kwargs: Any) -> List[_CheckError]: ...
 
 class BaseModelAdminChecks:

django-stubs/contrib/admin/filters.pyi

@@ -24,7 +24,7 @@ class SimpleListFilter(ListFilter):
     parameter_name: Any = ...
     lookup_choices: Any = ...
     def value(self) -> Optional[str]: ...
-    def lookups(self, request: Any, model_admin: Any) -> List[Tuple[Any, str]]: ...
+    def lookups(self, request: Any, model_admin: Any) -> None: ...
 
 class FieldListFilter(ListFilter):
     field: Field = ...

django-stubs/contrib/admin/options.pyi

@@ -86,7 +86,7 @@ class BaseModelAdmin:
     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: HttpRequest, to_field: str) -> bool: ...
-    def has_add_permission(self, request: HttpRequest) -> 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: ...

django-stubs/contrib/admin/sites.pyi

@@ -8,8 +8,6 @@ from django.template.response import TemplateResponse
 from django.urls.resolvers import URLResolver
 from django.utils.functional import LazyObject
 
-from django.apps.config import AppConfig
-
 all_sites: Any
 
 class AlreadyRegistered(Exception): ...
@@ -30,7 +28,7 @@ class AdminSite:
     name: str = ...
     _registry: Dict[Type[Model], ModelAdmin]
     def __init__(self, name: str = ...) -> None: ...
-    def check(self, app_configs: Optional[Iterable[AppConfig]]) -> List[Any]: ...
+    def check(self, app_configs: None) -> List[Any]: ...
     def register(
         self,
         model_or_iterable: Union[Type[Model], Iterable[Type[Model]]],
@@ -39,7 +37,7 @@ class AdminSite:
     ) -> None: ...
     def unregister(self, model_or_iterable: Union[Type[Model], Iterable[Type[Model]]]) -> None: ...
     def is_registered(self, model: Type[Model]) -> bool: ...
-    def add_action(self, action: Callable, name: Optional[str] = ...) -> None: ...
+    def add_action(self, action: Callable, name: None = ...) -> None: ...
     def disable_action(self, name: str) -> None: ...
     def get_action(self, name: str) -> Callable: ...
     @property
@@ -54,20 +52,14 @@ class AdminSite:
     @property
     def urls(self) -> Tuple[List[URLResolver], str, str]: ...
     def each_context(self, request: Any): ...
-    def password_change(
-        self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...
-    ) -> TemplateResponse: ...
-    def password_change_done(
-        self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...
-    ) -> TemplateResponse: ...
+    def password_change(self, request: WSGIRequest, extra_context: Dict[str, str] = ...) -> TemplateResponse: ...
+    def password_change_done(self, request: WSGIRequest, extra_context: None = ...) -> TemplateResponse: ...
     def i18n_javascript(self, request: WSGIRequest, extra_context: Optional[Dict[Any, Any]] = ...) -> HttpResponse: ...
-    def logout(self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...) -> TemplateResponse: ...
-    def login(self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...) -> HttpResponse: ...
+    def logout(self, request: WSGIRequest, extra_context: None = ...) -> TemplateResponse: ...
+    def login(self, request: WSGIRequest, extra_context: None = ...) -> HttpResponse: ...
     def get_app_list(self, request: WSGIRequest) -> List[Any]: ...
-    def index(self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...) -> TemplateResponse: ...
-    def app_index(
-        self, request: WSGIRequest, app_label: str, extra_context: Optional[Dict[str, Any]] = ...
-    ) -> TemplateResponse: ...
+    def index(self, request: WSGIRequest, extra_context: Optional[Dict[str, str]] = ...) -> TemplateResponse: ...
+    def app_index(self, request: WSGIRequest, app_label: str, extra_context: None = ...) -> TemplateResponse: ...
 
 class DefaultAdminSite(LazyObject): ...
 

django-stubs/contrib/admin/templatetags/admin_list.pyi

@@ -27,7 +27,7 @@ class ResultList(list):
 def results(cl: ChangeList) -> Iterator[ResultList]: ...
 def result_hidden_fields(cl: ChangeList) -> Iterator[BoundField]: ...
 def result_list(
-    cl: ChangeList,
+    cl: ChangeList
 ) -> Dict[
     str, Union[List[Dict[str, Optional[Union[int, str]]]], List[ResultList], List[BoundField], ChangeList, int]
 ]: ...

django-stubs/contrib/admin/utils.pyi

@@ -9,10 +9,12 @@ from django.contrib.auth.forms import AdminPasswordChangeForm
 from django.core.handlers.wsgi import WSGIRequest
 from django.db.models.base import Model
 from django.db.models.deletion import Collector
+from django.db.models.fields.mixins import FieldCacheMixin
 from django.db.models.fields.reverse_related import ManyToOneRel
 from django.db.models.options import Options
 from django.db.models.query import QuerySet
 from django.forms.forms import BaseForm
+from django.utils.safestring import SafeText
 
 from django.db.models.fields import Field, reverse_related
 
@@ -25,7 +27,7 @@ def unquote(s: str) -> str: ...
 def flatten(fields: Any) -> List[Union[Callable, str]]: ...
 def flatten_fieldsets(fieldsets: Any) -> List[Union[Callable, str]]: ...
 def get_deleted_objects(
-    objs: Sequence[Optional[Model]], request: WSGIRequest, admin_site: AdminSite
+    objs: QuerySet, request: WSGIRequest, admin_site: AdminSite
 ) -> Tuple[List[Any], Dict[Any, Any], Set[Any], List[Any]]: ...
 
 class NestedObjects(Collector):
@@ -39,14 +41,22 @@ class NestedObjects(Collector):
     model_objs: Any = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def add_edge(self, source: Optional[Model], target: Model) -> None: ...
-    def related_objects(self, related: ManyToOneRel, objs: Sequence[Optional[Model]]) -> QuerySet: ...
-    def nested(self, format_callback: Callable = ...) -> List[Any]: ...
+    def collect(
+        self,
+        objs: Union[Sequence[Optional[Model]], QuerySet],
+        source: Optional[Type[Model]] = ...,
+        source_attr: Optional[str] = ...,
+        **kwargs: Any
+    ) -> None: ...
+    def related_objects(self, related: ManyToOneRel, objs: List[Model]) -> QuerySet: ...
+    def nested(self, format_callback: Callable = ...) -> Union[List[SafeText], List[int]]: ...
+    def can_fast_delete(self, *args: Any, **kwargs: Any) -> bool: ...
 
 def model_format_dict(obj: Any): ...
 def model_ngettext(obj: Union[Options, QuerySet], n: Optional[int] = ...) -> str: ...
 def lookup_field(
     name: Union[Callable, str], obj: Model, model_admin: BaseModelAdmin = ...
-) -> Tuple[Optional[Field], Any, Any]: ...
+) -> Tuple[Optional[Field], Callable, Callable]: ...
 def label_for_field(
     name: Union[Callable, str],
     model: Type[Model],
@@ -55,14 +65,16 @@ def label_for_field(
     form: Optional[BaseForm] = ...,
 ) -> Union[Tuple[Optional[str], Union[Callable, Type[str]]], str]: ...
 def help_text_for_field(name: str, model: Type[Model]) -> str: ...
-def display_for_field(value: Any, field: Field, empty_value_display: str) -> str: ...
+def display_for_field(
+    value: Any, field: Union[Field, reverse_related.OneToOneRel], empty_value_display: str
+) -> str: ...
 def display_for_value(value: Any, empty_value_display: str, boolean: bool = ...) -> str: ...
 
 class NotRelationField(Exception): ...
 
 def get_model_from_relation(field: Union[Field, reverse_related.ForeignObjectRel]) -> Type[Model]: ...
 def reverse_field_path(model: Type[Model], path: str) -> Tuple[Type[Model], str]: ...
-def get_fields_from_path(model: Type[Model], path: str) -> List[Field]: ...
+def get_fields_from_path(model: Type[Model], path: str) -> List[Union[Field, FieldCacheMixin]]: ...
 def construct_change_message(
     form: AdminPasswordChangeForm, formsets: None, add: bool
 ) -> List[Dict[str, Dict[str, List[str]]]]: ...

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

@@ -81,7 +81,9 @@ class ChangeList:
     paginator: Any = ...
     def get_results(self, request: WSGIRequest) -> None: ...
     def get_ordering_field(self, field_name: Union[Callable, str]) -> Optional[Union[CombinedExpression, str]]: ...
-    def get_ordering(self, request: WSGIRequest, queryset: QuerySet) -> List[Union[OrderBy, Combinable, str]]: ...
+    def get_ordering(
+        self, request: WSGIRequest, queryset: QuerySet
+    ) -> Union[List[Union[Combinable, str]], List[Union[OrderBy, str]]]: ...
     def get_ordering_field_columns(self) -> OrderedDict: ...
     def get_queryset(self, request: WSGIRequest) -> QuerySet: ...
     def apply_select_related(self, qs: QuerySet) -> QuerySet: ...

django-stubs/contrib/auth/backends.pyi

@@ -1,34 +1,23 @@
 from typing import Any, Optional, Set, Union
 
 from django.contrib.auth.base_user import AbstractBaseUser
-from django.contrib.auth.models import AnonymousUser, User, Permission
-
-from django.db.models.base import Model
-
-_AnyUser = Union[Model, AnonymousUser]
+from django.contrib.auth.models import AnonymousUser, User
 
 UserModel: Any
 
-class BaseBackend:
+class ModelBackend:
     def authenticate(
-        self, request: Any, username: Optional[str] = ..., password: Optional[str] = ..., **kwargs: Any
+        self, request: Any, username: Optional[Union[int, str]] = ..., password: Optional[str] = ..., **kwargs: Any
     ) -> Optional[AbstractBaseUser]: ...
-    def get_user(self, user_id: int) -> Optional[AbstractBaseUser]: ...
-    def get_user_permissions(self, user_obj: _AnyUser, obj: Optional[Model] = ...) -> Set[str]: ...
-    def get_group_permissions(self, user_obj: _AnyUser, obj: Optional[Model] = ...) -> Set[str]: ...
-    def get_all_permissions(self, user_obj: _AnyUser, obj: Optional[Model] = ...) -> Set[str]: ...
-    def has_perm(self, user_obj: _AnyUser, perm: str, obj: Optional[Model] = ...) -> bool: ...
-
-class ModelBackend(BaseBackend):
-    def has_module_perms(self, user_obj: _AnyUser, app_label: str) -> bool: ...
-    def user_can_authenticate(self, user: Optional[_AnyUser]) -> bool: ...
-    def with_perm(
-        self,
-        perm: Union[str, Permission],
-        is_active: bool = ...,
-        include_superusers: bool = ...,
-        obj: Optional[Model] = ...,
-    ): ...
+    def user_can_authenticate(self, user: Optional[AbstractBaseUser]) -> bool: ...
+    def get_user_permissions(self, user_obj: AbstractBaseUser, obj: None = ...) -> Set[str]: ...
+    def get_group_permissions(self, user_obj: AbstractBaseUser, obj: None = ...) -> Set[str]: ...
+    def get_all_permissions(self, user_obj: AbstractBaseUser, obj: Optional[str] = ...) -> Set[str]: ...
+    def has_perm(
+        self, user_obj: Union[AbstractBaseUser, AnonymousUser], perm: str, obj: Optional[str] = ...
+    ) -> bool: ...
+    def has_module_perms(self, user_obj: Union[AbstractBaseUser, AnonymousUser], app_label: str) -> bool: ...
+    def get_user(self, user_id: int) -> AbstractBaseUser: ...
 
 class AllowAllUsersModelBackend(ModelBackend): ...
 

django-stubs/contrib/auth/base_user.pyi

@@ -13,10 +13,11 @@ class BaseUserManager(models.Manager[_T]):
     def get_by_natural_key(self, username: Optional[str]) -> _T: ...
 
 class AbstractBaseUser(models.Model):
-    REQUIRED_FIELDS: List[str] = ...
-
     password = models.CharField(max_length=128)
     last_login = models.DateTimeField(blank=True, null=True)
+
+    REQUIRED_FIELDS: List[str] = ...
+    class Meta: ...
     def get_username(self) -> str: ...
     def natural_key(self) -> Tuple[str]: ...
     @property

django-stubs/contrib/auth/checks.pyi

@@ -1,8 +1,6 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import CheckMessage
 
-from django.apps.config import AppConfig
-
-def check_user_model(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[CheckMessage]: ...
-def check_models_permissions(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ...
+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/mixins.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable, List
 
 from django import http
 from django.http.response import HttpResponse, HttpResponseRedirect
@@ -23,6 +23,6 @@ class PermissionRequiredMixin(AccessMixin):
     def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
 
 class UserPassesTestMixin(AccessMixin):
-    def test_func(self) -> Optional[bool]: ...
+    def test_func(self) -> None: ...
     def get_test_func(self) -> Callable: ...
     def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...

django-stubs/contrib/auth/models.pyi

@@ -1,6 +1,5 @@
-from typing import Any, Collection, Optional, Set, Tuple, Type, TypeVar, Union
+from typing import Any, Collection, Optional, Set, Tuple, Type, TypeVar
 
-from django.contrib.auth.backends import ModelBackend
 from django.contrib.auth.base_user import AbstractBaseUser as AbstractBaseUser, BaseUserManager as BaseUserManager
 from django.contrib.auth.validators import UnicodeUsernameValidator
 from django.contrib.contenttypes.models import ContentType
@@ -9,28 +8,22 @@ from django.db.models.manager import EmptyManager
 
 from django.db import models
 
-_AnyUser = Union[Model, "AnonymousUser"]
-
 def update_last_login(sender: Type[AbstractBaseUser], user: AbstractBaseUser, **kwargs: Any) -> None: ...
 
-class PermissionManager(models.Manager["Permission"]):
+class PermissionManager(models.Manager):
     def get_by_natural_key(self, codename: str, app_label: str, model: str) -> Permission: ...
 
 class Permission(models.Model):
     content_type_id: int
-    objects: PermissionManager
-
     name = models.CharField(max_length=255)
     content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
     codename = models.CharField(max_length=100)
     def natural_key(self) -> Tuple[str, str, str]: ...
 
-class GroupManager(models.Manager["Group"]):
+class GroupManager(models.Manager):
     def get_by_natural_key(self, name: str) -> Group: ...
 
 class Group(models.Model):
-    objects: GroupManager
-
     name = models.CharField(max_length=150)
     permissions = models.ManyToManyField(Permission)
     def natural_key(self): ...
@@ -44,24 +37,15 @@ class UserManager(BaseUserManager[_T]):
     def create_superuser(
         self, username: str, email: Optional[str], password: Optional[str], **extra_fields: Any
     ) -> _T: ...
-    def with_perm(
-        self,
-        perm: Union[str, Permission],
-        is_active: bool = ...,
-        include_superusers: bool = ...,
-        backend: Optional[Union[Type[ModelBackend], str]] = ...,
-        obj: Optional[Model] = ...,
-    ): ...
 
 class PermissionsMixin(models.Model):
     is_superuser = models.BooleanField()
-    groups = models.ManyToManyField(Group)
-    user_permissions = models.ManyToManyField(Permission)
-    def get_user_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ...
-    def get_group_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ...
-    def get_all_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ...
-    def has_perm(self, perm: str, obj: Optional[_AnyUser] = ...) -> bool: ...
-    def has_perms(self, perm_list: Collection[str], obj: Optional[_AnyUser] = ...) -> bool: ...
+    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: str, obj: Optional[str] = ...) -> bool: ...
+    def has_perms(self, perm_list: Collection[str], obj: None = ...) -> bool: ...
     def has_module_perms(self, app_label: str) -> bool: ...
 
 class AbstractUser(AbstractBaseUser, PermissionsMixin):  # type: ignore
@@ -98,11 +82,10 @@ class AnonymousUser:
     def groups(self) -> EmptyManager: ...
     @property
     def user_permissions(self) -> EmptyManager: ...
-    def get_user_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ...
-    def get_group_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[Any]: ...
-    def get_all_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ...
-    def has_perm(self, perm: str, obj: Optional[_AnyUser] = ...) -> bool: ...
-    def has_perms(self, perm_list: Collection[str], obj: Optional[_AnyUser] = ...) -> bool: ...
+    def get_group_permissions(self, obj: None = ...) -> Set[Any]: ...
+    def get_all_permissions(self, obj: Any = ...) -> Set[str]: ...
+    def has_perm(self, perm: str, obj: None = ...) -> bool: ...
+    def has_perms(self, perm_list: Collection[str], obj: None = ...) -> bool: ...
     def has_module_perms(self, module: str) -> bool: ...
     @property
     def is_anonymous(self) -> bool: ...

django-stubs/contrib/auth/views.pyi

@@ -55,7 +55,6 @@ class PasswordResetDoneView(PasswordContextMixin, TemplateView):
 class PasswordResetConfirmView(PasswordContextMixin, FormView):
     post_reset_login: bool = ...
     post_reset_login_backend: Any = ...
-    reset_url_token: str = ...
     title: Any = ...
     token_generator: Any = ...
     validlink: bool = ...

django-stubs/contrib/contenttypes/checks.pyi

@@ -1,6 +1,4 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
-from django.apps.config import AppConfig
-
-def check_generic_foreign_keys(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ...
-def check_model_name_lengths(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ...
+def check_generic_foreign_keys(app_configs: None = ..., **kwargs: Any) -> List[Any]: ...
+def check_model_name_lengths(app_configs: None = ..., **kwargs: Any) -> List[Any]: ...

django-stubs/contrib/postgres/constraints.pyi

@@ -1,18 +0,0 @@
-from typing import Optional, Sequence, Tuple, Union
-
-from django.db.models.constraints import BaseConstraint
-from django.db.models.expressions import Combinable
-from django.db.models.query_utils import Q
-
-class ExclusionConstraint(BaseConstraint):
-    expressions: Sequence[Tuple[Union[str, Combinable], str]]
-    index_type: str
-    condition: Optional[Q]
-    def __init__(
-        self,
-        *,
-        name: str,
-        expressions: Sequence[Tuple[Union[str, Combinable], str]],
-        condition: Optional[Q] = ...,
-        index_type: Optional[str] = ...,
-    ): ...

django-stubs/contrib/postgres/fields/__init__.pyi

@@ -8,8 +8,6 @@ from .ranges import (
     FloatRangeField as FloatRangeField,
     DateRangeField as DateRangeField,
     DateTimeRangeField as DateTimeRangeField,
-    RangeOperators as RangeOperators,
-    RangeBoundary as RangeBoundary,
 )
 from .hstore import HStoreField as HStoreField
 from .citext import (

django-stubs/contrib/postgres/fields/ranges.pyi

@@ -29,20 +29,3 @@ class DateTimeRangeField(RangeField):
 
 class DateRangeField(RangeField):
     def __get__(self, instance, owner) -> DateRange: ...
-
-class RangeOperators:
-    EQUAL: str
-    NOT_EQUAL: str
-    CONTAINS: str
-    CONTAINED_BY: str
-    OVERLAPS: str
-    FULLY_LT: str
-    FULLY_GT: str
-    NOT_LT: str
-    NOT_GT: str
-    ADJACENT_TO: str
-
-class RangeBoundary(models.Expression):
-    lower: str
-    upper: str
-    def __init__(self, inclusive_lower: bool = ..., inclusive_upper: bool = ...): ...

django-stubs/contrib/sites/management.pyi

@@ -1,10 +1,10 @@
 from typing import Any
 
-from django.apps.config import AppConfig
 from django.apps.registry import Apps
+from django.contrib.sites.apps import SitesConfig
 
 def create_default_site(
-    app_config: AppConfig,
+    app_config: SitesConfig,
     verbosity: int = ...,
     interactive: bool = ...,
     using: str = ...,

django-stubs/contrib/sites/models.pyi

@@ -6,16 +6,15 @@ from django.db import models
 
 SITE_CACHE: Any
 
-class SiteManager(models.Manager["Site"]):
+class SiteManager(models.Manager):
     def get_current(self, request: Optional[HttpRequest] = ...) -> Site: ...
     def clear_cache(self) -> None: ...
     def get_by_natural_key(self, domain: str) -> Site: ...
 
 class Site(models.Model):
-    objects: SiteManager
-
-    domain = models.CharField(max_length=100)
-    name = models.CharField(max_length=50)
+    domain: models.CharField = ...
+    name: models.CharField = ...
+    objects: SiteManager = ...
     def natural_key(self) -> Tuple[str]: ...
 
 def clear_site_cache(sender: Type[Site], **kwargs: Any) -> None: ...

django-stubs/contrib/staticfiles/checks.pyi

@@ -1,7 +1,5 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import Error
 
-from django.apps.config import AppConfig
-
-def check_finders(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Error]: ...
+def check_finders(app_configs: None = ..., **kwargs: Any) -> List[Error]: ...

django-stubs/contrib/staticfiles/finders.pyi

@@ -37,7 +37,7 @@ def get_finders() -> Iterator[BaseFinder]: ...
 def get_finder(import_path: Literal["django.contrib.staticfiles.finders.FileSystemFinder"]) -> FileSystemFinder: ...
 @overload
 def get_finder(
-    import_path: Literal["django.contrib.staticfiles.finders.AppDirectoriesFinder"],
+    import_path: Literal["django.contrib.staticfiles.finders.AppDirectoriesFinder"]
 ) -> AppDirectoriesFinder: ...
 @overload
 def get_finder(import_path: str) -> BaseFinder: ...

django-stubs/core/checks/caches.pyi

@@ -1,9 +1,7 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import Error
 
-from django.apps.config import AppConfig
-
 E001: Any
 
-def check_default_cache_is_configured(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ...
+def check_default_cache_is_configured(app_configs: None, **kwargs: Any) -> List[Error]: ...

django-stubs/core/checks/model_checks.pyi

@@ -1,8 +1,6 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import Warning
 
-from django.apps.config import AppConfig
-
-def check_all_models(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Warning]: ...
-def check_lazy_references(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ...
+def check_all_models(app_configs: None = ..., **kwargs: Any) -> List[Warning]: ...
+def check_lazy_references(app_configs: None = ..., **kwargs: Any) -> List[Any]: ...

django-stubs/core/checks/registry.pyi

@@ -12,7 +12,6 @@ class Tags:
     security: str = ...
     signals: str = ...
     templates: str = ...
-    translation: str = ...
     urls: str = ...
 
 class CheckRegistry:

django-stubs/core/checks/security/base.pyi

@@ -1,9 +1,7 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import Warning
 
-from django.apps.config import AppConfig
-
 SECRET_KEY_MIN_LENGTH: int
 SECRET_KEY_MIN_UNIQUE_CHARACTERS: int
 W001: Any
@@ -19,15 +17,15 @@ W019: Any
 W020: Any
 W021: Any
 
-def check_security_middleware(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_xframe_options_middleware(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_sts(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_sts_include_subdomains(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_sts_preload(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_content_type_nosniff(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_xss_filter(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_ssl_redirect(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_secret_key(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_debug(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_xframe_deny(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_allowed_hosts(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
+def check_security_middleware(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_xframe_options_middleware(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_sts(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_sts_include_subdomains(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_sts_preload(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_content_type_nosniff(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_xss_filter(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_ssl_redirect(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_secret_key(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_debug(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_xframe_deny(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_allowed_hosts(app_configs: None, **kwargs: Any) -> List[Warning]: ...

django-stubs/core/checks/security/csrf.pyi

@@ -1,11 +1,9 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import Warning
 
-from django.apps.config import AppConfig
-
 W003: Any
 W016: Any
 
-def check_csrf_middleware(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_csrf_cookie_secure(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
+def check_csrf_middleware(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_csrf_cookie_secure(app_configs: None, **kwargs: Any) -> List[Warning]: ...

django-stubs/core/checks/security/sessions.pyi

@@ -1,9 +1,7 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import Warning
 
-from django.apps.config import AppConfig
-
 def add_session_cookie_message(message: Any): ...
 
 W010: Any
@@ -16,5 +14,5 @@ W013: Any
 W014: Any
 W015: Any
 
-def check_session_cookie_secure(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
-def check_session_cookie_httponly(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
+def check_session_cookie_secure(app_configs: None, **kwargs: Any) -> List[Warning]: ...
+def check_session_cookie_httponly(app_configs: None, **kwargs: Any) -> List[Warning]: ...

django-stubs/core/checks/templates.pyi

@@ -1,11 +1,9 @@
-from typing import Any, List, Iterable, Optional
+from typing import Any, List
 
 from django.core.checks.messages import Error
 
-from django.apps.config import AppConfig
-
 E001: Any
 E002: Any
 
-def check_setting_app_dirs_loaders(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ...
-def check_string_if_invalid_is_string(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ...
+def check_setting_app_dirs_loaders(app_configs: None, **kwargs: Any) -> List[Error]: ...
+def check_string_if_invalid_is_string(app_configs: None, **kwargs: Any) -> List[Error]: ...

django-stubs/core/checks/urls.pyi

@@ -1,13 +1,11 @@
-from typing import Any, Callable, List, Tuple, Union, Iterable, Optional
+from typing import Any, Callable, List, Tuple, Union
 
 from django.core.checks.messages import CheckMessage, Error, Warning
 from django.urls.resolvers import URLPattern, URLResolver
 
-from django.apps.config import AppConfig
-
-def check_url_config(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[CheckMessage]: ...
+def check_url_config(app_configs: None, **kwargs: Any) -> List[CheckMessage]: ...
 def check_resolver(resolver: Union[Tuple[str, Callable], URLPattern, URLResolver]) -> List[CheckMessage]: ...
-def check_url_namespaces_unique(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ...
+def check_url_namespaces_unique(app_configs: None, **kwargs: Any) -> List[Warning]: ...
 def get_warning_for_invalid_pattern(pattern: Any) -> List[Error]: ...
-def check_url_settings(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ...
+def check_url_settings(app_configs: None, **kwargs: Any) -> List[Error]: ...
 def E006(name: str) -> Error: ...

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

@@ -1,5 +1,5 @@
 import types
-from typing import Any, TypeVar, Type, Iterable, Optional
+from typing import Any, TypeVar, Type, Iterable
 
 from django.core.mail.message import EmailMessage
 
@@ -7,7 +7,7 @@ _T = TypeVar("_T", bound="BaseEmailBackend")
 
 class BaseEmailBackend:
     def __init__(self, fail_silently: bool = ..., **kwargs: Any) -> None: ...
-    def open(self) -> Optional[bool]: ...
+    def open(self) -> bool: ...
     def close(self) -> None: ...
     def __enter__(self: _T) -> _T: ...
     def __exit__(

django-stubs/core/mail/backends/console.pyi

@@ -1,3 +0,0 @@
-from django.core.mail.backends.base import BaseEmailBackend
-
-class EmailBackend(BaseEmailBackend): ...

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

@@ -1,3 +0,0 @@
-from django.core.mail.backends.base import BaseEmailBackend
-
-class EmailBackend(BaseEmailBackend): ...

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

@@ -1,3 +0,0 @@
-from django.core.mail.backends.base import BaseEmailBackend
-
-class EmailBackend(BaseEmailBackend): ...

django-stubs/core/mail/backends/locmem.pyi

@@ -1,3 +0,0 @@
-from django.core.mail.backends.base import BaseEmailBackend
-
-class EmailBackend(BaseEmailBackend): ...

django-stubs/core/mail/backends/smtp.pyi

@@ -1,18 +0,0 @@
-import smtplib
-import threading
-from typing import Optional, Union
-
-from django.core.mail.backends.base import BaseEmailBackend
-
-class EmailBackend(BaseEmailBackend):
-    host: str = ...
-    port: int = ...
-    username: str = ...
-    password: str = ...
-    use_tls: bool = ...
-    use_ssl: bool = ...
-    timeout: Optional[int] = ...
-    ssl_keyfile: Optional[str] = ...
-    ssl_certfile: Optional[str] = ...
-    connection: Union[smtplib.SMTP_SSL, smtplib.SMTP, None] = ...
-    _lock: threading.RLock = ...

django-stubs/core/mail/message.pyi

@@ -1,10 +1,8 @@
 from email._policybase import Policy  # type: ignore
-from email.message import Message
-from email.mime.base import MIMEBase
 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, Sequence, Tuple, Union, overload
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 utf8_charset: Any
 utf8_charset_qp: Any
@@ -45,11 +43,6 @@ class SafeMIMEMultipart(MIMEMixin, MIMEMultipart):
         self, _subtype: str = ..., boundary: None = ..., _subparts: None = ..., encoding: str = ..., **_params: Any
     ) -> None: ...
 
-_AttachmentContent = Union[bytes, EmailMessage, Message, SafeMIMEText, str]
-_AttachmentTuple = Union[
-    Tuple[str, _AttachmentContent], Tuple[Optional[str], _AttachmentContent, str], Tuple[str, _AttachmentContent, None]
-]
-
 class EmailMessage:
     content_subtype: str = ...
     mixed_subtype: str = ...
@@ -69,42 +62,42 @@ class EmailMessage:
         subject: str = ...,
         body: Optional[str] = ...,
         from_email: Optional[str] = ...,
-        to: Optional[Sequence[str]] = ...,
-        bcc: Optional[Sequence[str]] = ...,
+        to: Optional[Union[Sequence[str], str]] = ...,
+        bcc: Optional[Union[Sequence[str], str]] = ...,
         connection: Optional[Any] = ...,
-        attachments: Optional[Sequence[Union[MIMEBase, _AttachmentTuple]]] = ...,
+        attachments: Optional[Union[List[Tuple[str, Union[str, bytes], str]], List[MIMEText]]] = ...,
         headers: Optional[Dict[str, str]] = ...,
-        cc: Optional[Sequence[str]] = ...,
-        reply_to: Optional[Sequence[str]] = ...,
+        cc: Optional[Union[Sequence[str], str]] = ...,
+        reply_to: Optional[Union[List[Optional[str]], str]] = ...,
     ) -> None: ...
     def get_connection(self, fail_silently: bool = ...) -> Any: ...
     # TODO: when typeshed gets more types for email.Message, move it to MIMEMessage, now it has too many false-positives
     def message(self) -> Any: ...
     def recipients(self) -> List[str]: ...
     def send(self, fail_silently: bool = ...) -> int: ...
-    @overload
-    def attach(self, filename: MIMEText = ...) -> None: ...
-    @overload
-    def attach(self, filename: None = ..., content: _AttachmentContent = ..., mimetype: str = ...) -> None: ...
-    @overload
-    def attach(self, filename: str = ..., content: _AttachmentContent = ..., mimetype: Optional[str] = ...) -> None: ...
+    def attach(
+        self,
+        filename: Optional[Union[MIMEText, str]] = ...,
+        content: Optional[Union[bytes, EmailMessage, SafeMIMEText, str]] = ...,
+        mimetype: Optional[str] = ...,
+    ) -> None: ...
     def attach_file(self, path: str, mimetype: Optional[str] = ...) -> None: ...
 
 class EmailMultiAlternatives(EmailMessage):
     alternative_subtype: str = ...
-    alternatives: Sequence[Tuple[_AttachmentContent, str]] = ...
+    alternatives: Any = ...
     def __init__(
         self,
         subject: str = ...,
         body: str = ...,
         from_email: Optional[str] = ...,
-        to: Optional[Sequence[str]] = ...,
-        bcc: Optional[Sequence[str]] = ...,
+        to: Optional[List[str]] = ...,
+        bcc: Optional[List[str]] = ...,
         connection: Optional[Any] = ...,
-        attachments: Optional[Sequence[Union[MIMEBase, _AttachmentTuple]]] = ...,
+        attachments: None = ...,
         headers: Optional[Dict[str, str]] = ...,
-        alternatives: Optional[Sequence[Tuple[_AttachmentContent, str]]] = ...,
-        cc: Optional[Sequence[str]] = ...,
-        reply_to: Optional[Sequence[str]] = ...,
+        alternatives: Optional[List[Tuple[str, str]]] = ...,
+        cc: None = ...,
+        reply_to: None = ...,
     ) -> None: ...
-    def attach_alternative(self, content: _AttachmentContent, mimetype: str) -> None: ...
+    def attach_alternative(self, content: str, mimetype: str) -> None: ...

django-stubs/core/management/base.pyi

@@ -63,7 +63,7 @@ class BaseCommand:
         fail_level: int = ...,
     ) -> None: ...
     def check_migrations(self) -> None: ...
-    def handle(self, *args: Any, **options: Any) -> Optional[str]: ...
+    def handle(self, *args: Any, **options: Any) -> None: ...
 
 class AppCommand(BaseCommand):
     missing_args_message: str = ...

django-stubs/core/management/color.pyi

@@ -1,24 +1,11 @@
 def supports_color() -> bool: ...
 
 class Style:
-    def ERROR(self, text: str) -> str: ...
+    def DEBUG(self, text: str) -> str: ...
+    def INFO(self, text: str) -> str: ...
     def SUCCESS(self, text: str) -> str: ...
     def WARNING(self, text: str) -> str: ...
-    def NOTICE(self, text: str) -> str: ...
-    def SQL_FIELD(self, text: str) -> str: ...
-    def SQL_COLTYPE(self, text: str) -> str: ...
-    def SQL_KEYWORD(self, text: str) -> str: ...
-    def SQL_TABLE(self, text: str) -> str: ...
-    def HTTP_INFO(self, text: str) -> str: ...
-    def HTTP_SUCCESS(self, text: str) -> str: ...
-    def HTTP_REDIRECT(self, text: str) -> str: ...
-    def HTTP_NOT_MODIFIED(self, text: str) -> str: ...
-    def HTTP_BAD_REQUEST(self, text: str) -> str: ...
-    def HTTP_NOT_FOUND(self, text: str) -> str: ...
-    def HTTP_SERVER_ERROR(self, text: str) -> str: ...
-    def MIGRATE_HEADING(self, text: str) -> str: ...
-    def MIGRATE_LABEL(self, text: str) -> str: ...
-    def ERROR_OUTPUT(self, text: str) -> str: ...
+    def ERROR(self, text: str) -> str: ...
 
 def make_style(config_string: str = ...) -> Style: ...
 def no_style() -> Style: ...

django-stubs/core/serializers/base.pyi

@@ -1,6 +1,6 @@
 from datetime import date
 from io import BufferedReader, StringIO, TextIOWrapper
-from typing import Any, Dict, Iterable, List, Mapping, Optional, Type, Union, Collection
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Type, Union
 from uuid import UUID
 
 from django.core.management.base import OutputWrapper
@@ -35,18 +35,18 @@ class Serializer:
     internal_use_only: bool = ...
     progress_class: Any = ...
     stream_class: Any = ...
-    options: Dict[str, Any] = ...
+    options: Any = ...
     stream: Any = ...
-    selected_fields: Optional[Collection[str]] = ...
-    use_natural_foreign_keys: bool = ...
-    use_natural_primary_keys: bool = ...
+    selected_fields: Any = ...
+    use_natural_foreign_keys: Any = ...
+    use_natural_primary_keys: Any = ...
     first: bool = ...
     def serialize(
         self,
         queryset: Iterable[Model],
         *,
         stream: Optional[Any] = ...,
-        fields: Optional[Collection[str]] = ...,
+        fields: Optional[Any] = ...,
         use_natural_foreign_keys: bool = ...,
         use_natural_primary_keys: bool = ...,
         progress_output: Optional[Any] = ...,
@@ -63,7 +63,7 @@ class Serializer:
     def getvalue(self) -> Optional[Union[bytes, str]]: ...
 
 class Deserializer:
-    options: Dict[str, Any] = ...
+    options: Any = ...
     stream: Any = ...
     def __init__(self, stream_or_string: Union[BufferedReader, TextIOWrapper, str], **options: Any) -> None: ...
     def __iter__(self) -> Deserializer: ...

django-stubs/core/serializers/json.pyi

@@ -1,10 +1,24 @@
 import json
-from typing import Any, Dict
+from datetime import datetime
+from decimal import Decimal
+from io import TextIOWrapper
+from typing import Any, Union, Dict
+from uuid import UUID
 
 from django.core.serializers.python import Serializer as PythonSerializer
+from django.db.models.base import Model
 
 class Serializer(PythonSerializer):
     json_kwargs: Dict[str, Any]
+    options: Dict[str, None]
+    selected_fields: None
+    stream: TextIOWrapper
+    use_natural_foreign_keys: bool
+    use_natural_primary_keys: bool
+    internal_use_only: bool = ...
+    def start_serialization(self) -> None: ...
+    def end_serialization(self) -> None: ...
+    def end_object(self, obj: Model) -> None: ...
 
 def Deserializer(stream_or_string: Any, **options: Any) -> None: ...
 
@@ -15,3 +29,4 @@ class DjangoJSONEncoder(json.JSONEncoder):
     indent: int
     skipkeys: bool
     sort_keys: bool
+    def default(self, o: Union[datetime, Decimal, UUID]) -> str: ...

django-stubs/core/serializers/python.pyi

@@ -1,15 +1,31 @@
 from collections import OrderedDict
-from typing import Any, Dict, Iterator, List, Optional
+from io import TextIOWrapper
+from typing import Any, Dict, Iterator, List
 
 from django.core.serializers.base import DeserializedObject
 from django.db.models.base import Model
+from django.db.models.fields.related import ForeignKey, ManyToManyField
 
 from django.core.serializers import base
+from django.db.models.fields import Field
 
 class Serializer(base.Serializer):
+    options: Dict[Any, Any]
+    selected_fields: None
+    stream: TextIOWrapper
+    use_natural_foreign_keys: bool
+    use_natural_primary_keys: bool
+    internal_use_only: bool = ...
     objects: List[Any] = ...
+    def start_serialization(self) -> None: ...
+    def end_serialization(self) -> None: ...
+    def start_object(self, obj: Model) -> None: ...
+    def end_object(self, obj: Model) -> None: ...
     def get_dump_object(self, obj: Model) -> OrderedDict: ...
+    def handle_field(self, obj: Model, field: Field) -> None: ...
+    def handle_fk_field(self, obj: Model, field: ForeignKey) -> None: ...
+    def handle_m2m_field(self, obj: Model, field: ManyToManyField) -> None: ...
 
 def Deserializer(
-    object_list: List[Dict[str, Any]], *, using: Optional[str] = ..., ignorenonexistent: bool = ..., **options: Any
+    object_list: List[Dict[str, Any]], *, using: Any = ..., ignorenonexistent: bool = ..., **options: Any
 ) -> Iterator[DeserializedObject]: ...

django-stubs/core/validators.pyi

@@ -1,13 +1,15 @@
+from datetime import datetime
 from decimal import Decimal
 from re import RegexFlag
-from typing import Any, Dict, List, Optional, Union, Pattern, Collection, Callable, Tuple
+from typing import Any, Dict, List, Optional, Union, Pattern, Collection
+from uuid import UUID
 
 from django.core.files.base import File
+from django.core.exceptions import ValidationError as ValidationError  # noqa: F401
 
 EMPTY_VALUES: Any
 
 _Regex = Union[str, Pattern[str]]
-_ErrorMessage = Union[str, Any]
 
 def _lazy_re_compile(regex: _Regex, flags: int = ...): ...
 
@@ -20,7 +22,7 @@ class RegexValidator:
     def __init__(
         self,
         regex: Optional[_Regex] = ...,
-        message: Optional[_ErrorMessage] = ...,
+        message: Optional[str] = ...,
         code: Optional[str] = ...,
         inverse_match: Optional[bool] = ...,
         flags: Optional[RegexFlag] = ...,
@@ -43,53 +45,67 @@ integer_validator: Any
 def validate_integer(value: Optional[Union[float, str]]) -> None: ...
 
 class EmailValidator:
-    message: str = ...
+    message: Any = ...
     code: str = ...
     user_regex: Any = ...
     domain_regex: Any = ...
     literal_regex: Any = ...
     domain_whitelist: Any = ...
     def __init__(
-        self,
-        message: Optional[_ErrorMessage] = ...,
-        code: Optional[str] = ...,
-        whitelist: Optional[Collection[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: ...
 
-validate_email: EmailValidator = ...
-slug_re: Pattern = ...
-validate_slug: RegexValidator = ...
-slug_unicode_re: Pattern = ...
-validate_unicode_slug: RegexValidator = ...
+validate_email: Any
+slug_re: Any
+validate_slug: Any
+slug_unicode_re: Any
+validate_unicode_slug: Any
 
 def validate_ipv4_address(value: str) -> None: ...
 def validate_ipv6_address(value: str) -> None: ...
 def validate_ipv46_address(value: str) -> None: ...
 
-ip_address_validator_map: Dict[str, Tuple[Callable[[Any], None], str]]
+ip_address_validator_map: Any
 
 def ip_address_validators(protocol: str, unpack_ipv4: bool) -> Any: ...
 def int_list_validator(
-    sep: str = ..., message: Optional[_ErrorMessage] = ..., code: str = ..., allow_negative: bool = ...
+    sep: str = ..., message: None = ..., code: str = ..., allow_negative: bool = ...
 ) -> RegexValidator: ...
 
 validate_comma_separated_integer_list: Any
 
 class BaseValidator:
-    message: str = ...
+    message: Any = ...
     code: str = ...
     limit_value: Any = ...
-    def __init__(self, limit_value: Any, message: Optional[_ErrorMessage] = ...) -> None: ...
+    def __init__(self, limit_value: Any, message: Optional[str] = ...) -> None: ...
     def __call__(self, value: Any) -> None: ...
-    def compare(self, a: Any, b: Any) -> bool: ...
+    def compare(self, a: bool, b: bool) -> bool: ...
     def clean(self, x: Any) -> Any: ...
 
-class MaxValueValidator(BaseValidator): ...
-class MinValueValidator(BaseValidator): ...
-class MinLengthValidator(BaseValidator): ...
-class MaxLengthValidator(BaseValidator): ...
+class MaxValueValidator(BaseValidator):
+    message: Any = ...
+    code: str = ...
+    def compare(self, a: Union[datetime, Decimal, float], b: Union[datetime, Decimal, float]) -> bool: ...
+
+class MinValueValidator(BaseValidator):
+    message: Any = ...
+    code: str = ...
+    def compare(self, a: Union[datetime, Decimal, float], b: Union[datetime, Decimal, float]) -> bool: ...
+
+class MinLengthValidator(BaseValidator):
+    message: Any = ...
+    code: str = ...
+    def compare(self, a: int, b: int) -> bool: ...
+    def clean(self, x: str) -> int: ...
+
+class MaxLengthValidator(BaseValidator):
+    message: Any = ...
+    code: str = ...
+    def compare(self, a: int, b: int) -> bool: ...
+    def clean(self, x: Union[bytes, str]) -> int: ...
 
 class DecimalValidator:
     messages: Any = ...
@@ -99,13 +115,13 @@ class DecimalValidator:
     def __call__(self, value: Decimal) -> None: ...
 
 class FileExtensionValidator:
-    message: str = ...
+    message: Any = ...
     code: str = ...
     allowed_extensions: List[str] = ...
     def __init__(
         self,
         allowed_extensions: Optional[Collection[str]] = ...,
-        message: Optional[_ErrorMessage] = ...,
+        message: Optional[str] = ...,
         code: Optional[str] = ...,
     ) -> None: ...
     def __call__(self, value: File) -> None: ...
@@ -114,7 +130,7 @@ def get_available_image_extensions() -> List[str]: ...
 def validate_image_file_extension(value: File) -> None: ...
 
 class ProhibitNullCharactersValidator:
-    message: str = ...
+    message: Any = ...
     code: str = ...
-    def __init__(self, message: Optional[_ErrorMessage] = ..., code: Optional[str] = ...) -> None: ...
-    def __call__(self, value: Any) -> None: ...
+    def __init__(self, message: Optional[str] = ..., code: Optional[str] = ...) -> None: ...
+    def __call__(self, value: Optional[Union[Dict[Any, Any], str, UUID]]) -> None: ...

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

@@ -20,7 +20,7 @@ class BaseDatabaseWrapper:
     ops: Any = ...
     vendor: str = ...
     display_name: str = ...
-    SchemaEditorClass: Optional[BaseDatabaseSchemaEditor] = ...
+    SchemaEditorClass: Any = ...
     client_class: Any = ...
     creation_class: Any = ...
     features_class: Any = ...

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

@@ -1,5 +1,5 @@
 from collections import namedtuple
-from typing import Any, Dict, List, Optional, Set, Type
+from typing import Any, Dict, List, Optional, Set, Tuple, Type, Union
 
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.db.backends.utils import CursorWrapper
@@ -13,7 +13,7 @@ class BaseDatabaseIntrospection:
     data_types_reverse: Any = ...
     connection: Any = ...
     def __init__(self, connection: BaseDatabaseWrapper) -> None: ...
-    def get_field_type(self, data_type: str, description: FieldInfo) -> str: ...
+    def get_field_type(self, data_type: str, description: FieldInfo) -> Union[Tuple[str, Dict[str, int]], str]: ...
     def table_name_converter(self, name: str) -> str: ...
     def column_name_converter(self, name: str) -> str: ...
     def table_names(self, cursor: Optional[CursorWrapper] = ..., include_views: bool = ...) -> List[str]: ...

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

@@ -1,9 +1,10 @@
-from datetime import date, datetime, timedelta, time
+from datetime import date, datetime, timedelta
 from decimal import Decimal
 from typing import Any, List, Optional, Sequence, Tuple, Type, Union
 
 from django.core.management.color import Style
 from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.backends.sqlite3.base import DatabaseWrapper
 from django.db.backends.utils import CursorWrapper
 from django.db.models.base import Model
 from django.db.models.expressions import Case, Expression
@@ -12,8 +13,6 @@ from django.db.models.sql.compiler import SQLCompiler
 from django.db import DefaultConnectionProxy
 from django.db.models.fields import Field
 
-_Connection = Union[DefaultConnectionProxy, BaseDatabaseWrapper]
-
 class BaseDatabaseOperations:
     compiler_module: str = ...
     integer_field_ranges: Any = ...
@@ -26,8 +25,8 @@ class BaseDatabaseOperations:
     UNBOUNDED_FOLLOWING: Any = ...
     CURRENT_ROW: str = ...
     explain_prefix: Any = ...
-    connection: _Connection = ...
-    def __init__(self, connection: Optional[_Connection]) -> None: ...
+    connection: Any = ...
+    def __init__(self, connection: Optional[Union[DefaultConnectionProxy, BaseDatabaseWrapper]]) -> None: ...
     def autoinc_sql(self, table: str, column: str) -> None: ...
     def bulk_batch_size(self, fields: Any, objs: Any): ...
     def cache_key_culling_sql(self) -> str: ...
@@ -76,10 +75,10 @@ class BaseDatabaseOperations:
     def prep_for_like_query(self, x: str) -> str: ...
     prep_for_iexact_query: Any = ...
     def validate_autopk_value(self, value: int) -> int: ...
-    def adapt_unknown_value(self, value: Any) -> Any: ...
+    def adapt_unknown_value(self, value: Union[datetime, Decimal, int, str]) -> Union[int, str]: ...
     def adapt_datefield_value(self, value: Optional[date]) -> Optional[str]: ...
-    def adapt_datetimefield_value(self, value: Optional[datetime]) -> Optional[str]: ...
-    def adapt_timefield_value(self, value: Optional[Union[datetime, time]]) -> Optional[str]: ...
+    def adapt_datetimefield_value(self, value: None) -> None: ...
+    def adapt_timefield_value(self, value: Optional[datetime]) -> Optional[str]: ...
     def adapt_decimalfield_value(
         self, value: Optional[Decimal], max_digits: Optional[int] = ..., decimal_places: Optional[int] = ...
     ) -> Optional[str]: ...
@@ -88,17 +87,19 @@ class BaseDatabaseOperations:
     def year_lookup_bounds_for_datetime_field(self, value: int) -> List[str]: ...
     def get_db_converters(self, expression: Expression) -> List[Any]: ...
     def convert_durationfield_value(
-        self, value: Optional[float], expression: Expression, connection: _Connection
+        self, value: Optional[float], expression: Expression, connection: DatabaseWrapper
     ) -> Optional[timedelta]: ...
     def check_expression_support(self, expression: Any) -> None: ...
     def combine_expression(self, connector: str, sub_expressions: List[str]) -> str: ...
     def combine_duration_expression(self, connector: Any, sub_expressions: Any): ...
     def binary_placeholder_sql(self, value: Optional[Case]) -> str: ...
-    def modify_insert_params(self, placeholder: str, params: Any) -> Any: ...
+    def modify_insert_params(
+        self, placeholder: str, params: Union[List[None], List[bool], List[float], List[str]]
+    ) -> Union[List[None], List[bool], List[float], List[str]]: ...
     def integer_field_range(self, internal_type: Any): ...
     def subtract_temporals(self, internal_type: Any, lhs: Any, rhs: Any): ...
     def window_frame_start(self, start: Any): ...
     def window_frame_end(self, end: Any): ...
-    def window_frame_rows_start_end(self, start: Optional[int] = ..., end: Optional[int] = ...) -> Any: ...
-    def window_frame_range_start_end(self, start: Optional[int] = ..., end: Optional[int] = ...) -> Any: ...
+    def window_frame_rows_start_end(self, start: None = ..., end: None = ...) -> Any: ...
+    def window_frame_range_start_end(self, start: Optional[Any] = ..., end: Optional[Any] = ...): ...
     def explain_query_prefix(self, format: Optional[str] = ..., **options: Any) -> str: ...

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

@@ -48,7 +48,7 @@ class BaseDatabaseSchemaEditor(ContextManager[Any]):
     def quote_name(self, name: str) -> str: ...
     def column_sql(
         self, model: Type[Model], field: Field, include_default: bool = ...
-    ) -> Tuple[Optional[str], Optional[List[Any]]]: ...
+    ) -> Union[Tuple[None, None], Tuple[str, List[Any]]]: ...
     def skip_default(self, field: Any): ...
     def prepare_default(self, value: Any) -> None: ...
     def effective_default(self, field: Field) -> Optional[Union[int, str]]: ...

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

@@ -10,5 +10,3 @@ class DatabaseWrapper(BaseDatabaseWrapper): ...
 FORMAT_QMARK_REGEX: Any
 
 class SQLiteCursorWrapper(Database.Cursor): ...
-
-def check_sqlite_version() -> None: ...

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

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any, Dict, Optional, Tuple, Union
 
 from django.db.backends.base.introspection import BaseDatabaseIntrospection
 
@@ -8,6 +8,6 @@ def get_field_size(name: str) -> Optional[int]: ...
 
 class FlexibleFieldLookupDict:
     base_data_types_reverse: Any = ...
-    def __getitem__(self, key: str) -> Any: ...
+    def __getitem__(self, key: str) -> Union[Tuple[str, Dict[str, int]], str]: ...
 
 class DatabaseIntrospection(BaseDatabaseIntrospection): ...

django-stubs/db/migrations/state.pyi

@@ -1,13 +1,21 @@
-from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, Type, Union, Set
+from typing import Any, DefaultDict, Dict, Iterator, List, Optional, Sequence, Tuple, Type, Union, Set
 
-from django.apps import AppConfig
 from django.apps.registry import Apps
 from django.db.models.base import Model
 from django.db.models.manager import Manager
 
 from django.db.models.fields import Field
 
-class AppConfigStub(AppConfig): ...
+class AppConfigStub:
+    apps: None
+    label: str
+    models: None
+    models_module: None
+    module: None
+    name: str
+    verbose_name: str
+    def __init__(self, label: str) -> None: ...
+    def import_models(self) -> None: ...
 
 class ModelState:
     name: str
@@ -58,7 +66,13 @@ class ProjectState:
     def remove_model(self, app_label: str, model_name: str) -> None: ...
 
 class StateApps(Apps):
+    all_models: DefaultDict
+    apps_ready: bool
+    loading: bool
+    models_ready: bool
+    ready: bool
     real_models: List[ModelState]
+    stored_app_configs: List[Any]
     def __init__(
         self, real_apps: List[str], models: Dict[Tuple[str, str], ModelState], ignore_swappable: bool = ...
     ) -> None: ...

django-stubs/db/models/__init__.pyi

@@ -40,7 +40,6 @@ from .fields import (
     DurationField as DurationField,
     BigAutoField as BigAutoField,
     CommaSeparatedIntegerField as CommaSeparatedIntegerField,
-    NOT_PROVIDED as NOT_PROVIDED,
 )
 
 from .fields.related import (
@@ -129,5 +128,3 @@ from .constraints import (
     CheckConstraint as CheckConstraint,
     UniqueConstraint as UniqueConstraint,
 )
-
-from .enums import Choices as Choices, IntegerChoices as IntegerChoices, TextChoices as TextChoices

django-stubs/db/models/base.pyi

@@ -1,8 +1,7 @@
-from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union, Collection
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TypeVar, Union
 
 from django.core.checks.messages import CheckMessage
-from django.core.exceptions import ValidationError
-from django.db.models.manager import BaseManager
+from django.db.models.manager import Manager
 from django.db.models.options import Options
 
 _Self = TypeVar("_Self", bound="Model")
@@ -13,19 +12,16 @@ class Model(metaclass=ModelBase):
     class DoesNotExist(Exception): ...
     class MultipleObjectsReturned(Exception): ...
     class Meta: ...
+    _default_manager: Manager[Model]
     _meta: Options[Any]
-    _default_manager: BaseManager[Model]
-    objects: BaseManager[Any]
+    objects: Manager[Any]
     pk: Any = ...
     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[Collection[str]] = ..., validate_unique: bool = ...) -> None: ...
+    def full_clean(self, exclude: Optional[List[str]] = ..., validate_unique: bool = ...) -> None: ...
     def clean(self) -> None: ...
-    def clean_fields(self, exclude: Optional[Collection[str]] = ...) -> None: ...
-    def validate_unique(self, exclude: Optional[Collection[str]] = ...) -> None: ...
-    def unique_error_message(
-        self, model_class: Type[_Self], unique_check: Collection[Union[Callable, str]]
-    ) -> ValidationError: ...
+    def clean_fields(self, exclude: List[str] = ...) -> None: ...
+    def validate_unique(self, exclude: List[str] = ...) -> None: ...
     def save(
         self,
         force_insert: bool = ...,
@@ -41,7 +37,7 @@ class Model(metaclass=ModelBase):
         using: Optional[str] = ...,
         update_fields: Optional[Union[Sequence[str], str]] = ...,
     ): ...
-    def refresh_from_db(self: _Self, using: Optional[str] = ..., fields: Optional[List[str]] = ...) -> None: ...
+    def refresh_from_db(self: _Self, using: Optional[str] = ..., fields: Optional[List[str]] = ...) -> _Self: ...
     def get_deferred_fields(self) -> Set[str]: ...
     @classmethod
     def check(cls, **kwargs: Any) -> List[CheckMessage]: ...

django-stubs/db/models/deletion.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Iterable, Optional, Union, Collection, Type
+from typing import Any, Callable, Iterable, Optional, Union
 
 from django.db.models.base import Model
 
@@ -18,11 +18,4 @@ class ProtectedError(IntegrityError): ...
 
 class Collector:
     def __init__(self, using: str) -> None: ...
-    def collect(
-        self,
-        objs: Collection[Optional[Model]],
-        source: Optional[Type[Model]] = ...,
-        source_attr: Optional[str] = ...,
-        **kwargs: Any
-    ) -> None: ...
     def can_fast_delete(self, objs: Union[Model, Iterable[Model]], from_field: Optional[Field] = ...) -> bool: ...

django-stubs/db/models/enums.pyi

@@ -1,30 +0,0 @@
-import enum
-from typing import Any, List, Tuple
-
-class ChoicesMeta(enum.EnumMeta):
-    names: List[str] = ...
-    choices: List[Tuple[Any, str]] = ...
-    labels: List[str] = ...
-    values: List[Any] = ...
-    def __contains__(self, item: Any) -> bool: ...
-
-class Choices(enum.Enum, metaclass=ChoicesMeta):
-    def __str__(self): ...
-
-# fake
-class _IntegerChoicesMeta(ChoicesMeta):
-    names: List[str] = ...
-    choices: List[Tuple[int, str]] = ...
-    labels: List[str] = ...
-    values: List[int] = ...
-
-class IntegerChoices(int, Choices, metaclass=_IntegerChoicesMeta): ...
-
-# fake
-class _TextChoicesMeta(ChoicesMeta):
-    names: List[str] = ...
-    choices: List[Tuple[str, str]] = ...
-    labels: List[str] = ...
-    values: List[str] = ...
-
-class TextChoices(str, Choices, metaclass=_TextChoicesMeta): ...

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

@@ -25,9 +25,7 @@ from django.db.models.expressions import Combinable, Col
 from django.db.models.query_utils import RegisterLookupMixin
 from django.forms import Field as FormField, Widget
 
-class NOT_PROVIDED: ...
-
-BLANK_CHOICE_DASH: List[Tuple[str, str]] = ...
+from .mixins import NOT_PROVIDED as NOT_PROVIDED
 
 _Choice = Tuple[Any, Any]
 _ChoiceNamedGroup = Tuple[str, Iterable[_Choice]]
@@ -54,8 +52,6 @@ class Field(RegisterLookupMixin, Generic[_ST, _GT]):
     auto_created: bool
     primary_key: bool
     remote_field: Field
-    is_relation: bool
-    related_model: Optional[Type[Model]]
     max_length: int
     model: Type[Model]
     name: str
@@ -65,10 +61,9 @@ class Field(RegisterLookupMixin, Generic[_ST, _GT]):
     null: bool = ...
     editable: bool = ...
     empty_strings_allowed: bool = ...
-    choices: _FieldChoices = ...
+    choices: Optional[_FieldChoices] = ...
     db_column: Optional[str]
     column: str
-    default: Any
     error_messages: _ErrorMessagesToOverride
     def __init__(
         self,
@@ -110,8 +105,7 @@ class Field(RegisterLookupMixin, Generic[_ST, _GT]):
     def db_parameters(self, connection: Any) -> Dict[str, str]: ...
     def get_prep_value(self, value: Any) -> Any: ...
     def get_internal_type(self) -> str: ...
-    # TODO: plugin support
-    def formfield(self, **kwargs) -> Any: ...
+    def formfield(self, **kwargs) -> FormField: ...
     def save_form_data(self, instance: Model, data: Any) -> None: ...
     def contribute_to_class(self, cls: Type[Model], name: str, private_only: bool = ...) -> None: ...
     def to_python(self, value: Any) -> Any: ...
@@ -134,12 +128,11 @@ class Field(RegisterLookupMixin, Generic[_ST, _GT]):
     @property
     def cached_col(self) -> Col: ...
     def value_from_object(self, obj: Model) -> _GT: ...
-    def get_attname(self) -> str: ...
 
 class IntegerField(Field[_ST, _GT]):
     _pyi_private_set_type: Union[float, int, str, Combinable]
     _pyi_private_get_type: int
-    _pyi_lookup_exact_type: Union[str, int]
+    _pyi_lookup_exact_type: int
 
 class PositiveIntegerRelDbTypeMixin:
     def rel_db_type(self, connection: Any): ...
@@ -187,7 +180,7 @@ class DecimalField(Field[_ST, _GT]):
 class AutoField(Field[_ST, _GT]):
     _pyi_private_set_type: Union[Combinable, int, str]
     _pyi_private_get_type: int
-    _pyi_lookup_exact_type: Union[str, int]
+    _pyi_lookup_exact_type: int
 
 class CharField(Field[_ST, _GT]):
     _pyi_private_set_type: Union[str, int, Combinable]
@@ -364,20 +357,20 @@ class UUIDField(Field[_ST, _GT]):
     _pyi_private_get_type: uuid.UUID
 
 class FilePathField(Field[_ST, _GT]):
-    path: Any = ...
-    match: Optional[str] = ...
+    path: str = ...
+    match: Optional[Any] = ...
     recursive: bool = ...
     allow_files: bool = ...
     allow_folders: bool = ...
     def __init__(
         self,
-        path: Union[str, Callable[..., str]] = ...,
-        match: Optional[str] = ...,
+        verbose_name: Optional[Union[str, bytes]] = ...,
+        name: Optional[str] = ...,
+        path: str = ...,
+        match: Optional[Any] = ...,
         recursive: bool = ...,
         allow_files: bool = ...,
         allow_folders: bool = ...,
-        verbose_name: Optional[str] = ...,
-        name: Optional[str] = ...,
         primary_key: bool = ...,
         max_length: int = ...,
         unique: bool = ...,
@@ -396,8 +389,7 @@ class FilePathField(Field[_ST, _GT]):
         error_messages: Optional[_ErrorMessagesToOverride] = ...,
     ): ...
 
-class BinaryField(Field[_ST, _GT]):
-    _pyi_private_get_type: bytes
+class BinaryField(Field[_ST, _GT]): ...
 
 class DurationField(Field[_ST, _GT]):
     _pyi_private_get_type: timedelta

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

@@ -1,5 +1,4 @@
-from pathlib import Path
-from typing import Any, Callable, Iterable, Optional, Type, TypeVar, Union, overload
+from typing import Any, Callable, Iterable, List, Optional, Tuple, Type, TypeVar, Union, overload
 
 from django.core.files.base import File
 from django.core.files.images import ImageFile
@@ -8,6 +7,8 @@ from django.db.models.base import Model
 
 from django.db.models.fields import Field, _FieldChoices, _ValidatorCallable, _ErrorMessagesToOverride
 
+BLANK_CHOICE_DASH: List[Tuple[str, str]] = ...
+
 class FieldFile(File):
     instance: Model = ...
     field: FileField = ...
@@ -38,10 +39,11 @@ class FileField(Field):
     upload_to: Union[str, Callable] = ...
     def __init__(
         self,
-        upload_to: Union[str, Callable, Path] = ...,
-        storage: Optional[Storage] = ...,
         verbose_name: Optional[Union[str, bytes]] = ...,
         name: Optional[str] = ...,
+        upload_to: Union[str, Callable] = ...,
+        storage: Optional[Storage] = ...,
+        primary_key: bool = ...,
         max_length: Optional[int] = ...,
         unique: bool = ...,
         blank: bool = ...,

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

@@ -43,8 +43,9 @@ class RelatedField(FieldCacheMixin, Field[_ST, _GT]):
     one_to_one: bool = ...
     many_to_many: bool = ...
     many_to_one: bool = ...
-    related_model: Type[Model]
     opts: Any = ...
+    @property
+    def related_model(self) -> Type[Model]: ...
     def get_forward_related_filter(self, obj: Model) -> Dict[str, Union[int, UUID]]: ...
     def get_reverse_related_filter(self, obj: Model) -> Q: ...
     @property

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

@@ -18,7 +18,6 @@ class ForeignObjectRel(FieldCacheMixin):
     concrete: bool = ...
     editable: bool = ...
     is_relation: bool = ...
-    related_model: Type[Model]
     null: bool = ...
     field: RelatedField = ...
     model: Union[Type[Model], str] = ...
@@ -45,6 +44,8 @@ class ForeignObjectRel(FieldCacheMixin):
     @property
     def name(self) -> str: ...
     @property
+    def related_model(self) -> Type[Model]: ...
+    @property
     def remote_field(self) -> RelatedField: ...
     @property
     def target_field(self) -> AutoField: ...

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

@@ -14,14 +14,9 @@ from .text import (
     Trim as Trim,
     Ord as Ord,
     Repeat as Repeat,
-    SHA1 as SHA1,
-    SHA224 as SHA224,
-    SHA256 as SHA256,
-    SHA384 as SHA384,
-    SHA512 as SHA512,
     StrIndex as StrIndex,
-    Substr as Substr,
     Replace as Replace,
+    Substr as Substr,
     Reverse as Reverse,
 )
 
@@ -86,7 +81,6 @@ from .math import (
     Power as Power,
     Radians as Radians,
     Round as Round,
-    Sign as Sign,
     Sin as Sin,
     Sqrt as Sqrt,
     Tan as Tan,

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

@@ -23,4 +23,3 @@ class Round(Transform): ...
 class Sin(NumericOutputFieldMixin, Transform): ...
 class Sqrt(NumericOutputFieldMixin, Transform): ...
 class Tan(NumericOutputFieldMixin, Transform): ...
-class Sign(Transform): ...

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

@@ -55,11 +55,3 @@ class Substr(Func):
 class Trim(Transform): ...
 class Upper(Transform): ...
 class Reverse(Transform): ...
-class MySQLSHA2Mixin: ...
-class OracleHashMixin: ...
-class PostgreSQLSHAMixin: ...
-class SHA1(OracleHashMixin, PostgreSQLSHAMixin, Transform): ...
-class SHA224(MySQLSHA2Mixin, PostgreSQLSHAMixin, Transform): ...
-class SHA256(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform): ...
-class SHA384(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform): ...
-class SHA512(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform): ...

django-stubs/db/models/lookups.pyi

@@ -31,9 +31,11 @@ class Lookup(Generic[_T]):
     def process_lhs(
         self, compiler: SQLCompiler, connection: DatabaseWrapper, lhs: Optional[Expression] = ...
     ) -> Tuple[str, List[Union[int, str]]]: ...
-    def process_rhs(self, compiler: SQLCompiler, connection: DatabaseWrapper) -> Tuple[str, List[Union[int, str]]]: ...
+    def process_rhs(
+        self, compiler: SQLCompiler, connection: DatabaseWrapper
+    ) -> Tuple[str, Union[List[Union[int, str]], Tuple[int, int]]]: ...
     def rhs_is_direct_value(self) -> bool: ...
-    def relabeled_clone(self: _T, relabels: Mapping[str, str]) -> _T: ...
+    def relabeled_clone(self, relabels: Mapping[str, str]) -> Union[BuiltinLookup, FieldGetDbPrepValueMixin]: ...
     def get_group_by_cols(self) -> List[Expression]: ...
     def as_sql(self, compiler: Any, connection: Any) -> Any: ...
     def contains_aggregate(self) -> bool: ...

django-stubs/db/models/manager.pyi

@@ -1,17 +1,16 @@
-from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Iterable, Union
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar
 
 from django.db.models.base import Model
 from django.db.models.query import QuerySet
 
 _T = TypeVar("_T", bound=Model, covariant=True)
-_M = TypeVar("_M", bound="BaseManager")
 
 class BaseManager(QuerySet[_T]):
     creation_counter: int = ...
     auto_created: bool = ...
     use_in_migrations: bool = ...
     name: str = ...
-    model: Type[_T] = ...
+    model: Type[Model] = ...
     db: str
     def __init__(self) -> None: ...
     def deconstruct(self) -> Tuple[bool, str, None, Tuple, Dict[str, int]]: ...
@@ -21,18 +20,13 @@ class BaseManager(QuerySet[_T]):
     @classmethod
     def _get_queryset_methods(cls, queryset_class: type) -> Dict[str, Any]: ...
     def contribute_to_class(self, model: Type[Model], name: str) -> None: ...
-    def db_manager(self: _M, using: Optional[str] = ..., hints: Optional[Dict[str, Model]] = ...) -> _M: ...
+    def db_manager(self, using: Optional[str] = ..., hints: Optional[Dict[str, Model]] = ...) -> Manager: ...
     def get_queryset(self) -> QuerySet[_T]: ...
 
 class Manager(BaseManager[_T]): ...
 
 class RelatedManager(Manager[_T]):
-    related_val: Tuple[int, ...]
-    def add(self, *objs: Union[_T, int], bulk: bool = ...) -> None: ...
-    def remove(self, *objs: Union[_T, int], bulk: bool = ...) -> None: ...
-    def set(
-        self, objs: Union[QuerySet[_T], Iterable[Union[_T, int]]], *, bulk: bool = ..., clear: bool = ...
-    ) -> None: ...
+    def add(self, *objs: Model, bulk: bool = ...) -> None: ...
     def clear(self) -> None: ...
 
 class ManagerDescriptor:

django-stubs/db/models/options.pyi

@@ -1,5 +1,5 @@
 import collections
-from typing import Any, Callable, Dict, Generic, Iterator, List, Optional, Sequence, Tuple, Type, TypeVar, Union
+from typing import Any, Callable, Dict, Generic, Iterator, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union
 
 from django.apps.config import AppConfig
 from django.apps.registry import Apps
@@ -8,7 +8,6 @@ from django.contrib.postgres.fields.array import ArrayField
 from django.contrib.postgres.fields.citext import CIText
 from django.db.backends.sqlite3.base import DatabaseWrapper
 from django.db.models.base import Model
-from django.db.models.constraints import BaseConstraint
 from django.db.models.fields.mixins import FieldCacheMixin
 from django.db.models.fields.related import ManyToManyField, OneToOneField
 from django.db.models.fields.reverse_related import ForeignObjectRel
@@ -24,8 +23,8 @@ IMMUTABLE_WARNING: str
 DEFAULT_NAMES: Tuple[str, ...]
 
 def normalize_together(
-    option_together: Union[Sequence[Tuple[str, str]], Tuple[str, str]]
-) -> Tuple[Tuple[str, str], ...]: ...
+    option_together: Any
+) -> Union[List[Union[Tuple[str, str], int]], Set[Tuple[str, str]], Tuple, int, str]: ...
 def make_immutable_fields_list(
     name: str, data: Union[Iterator[Any], List[Union[ArrayField, CIText]], List[Union[Field, FieldCacheMixin]]]
 ) -> ImmutableList: ...
@@ -35,7 +34,6 @@ _M = TypeVar("_M", bound=Model)
 class Options(Generic[_M]):
     base_manager: Manager
     concrete_fields: ImmutableList
-    constraints: List[BaseConstraint]
     default_manager: Manager
     fields: ImmutableList
     local_concrete_fields: ImmutableList
@@ -110,8 +108,6 @@ class Options(Generic[_M]):
     def managers(self) -> List[Manager]: ...
     @property
     def managers_map(self) -> Dict[str, Manager]: ...
-    @property
-    def db_returning_fields(self) -> List[Field]: ...
     def get_field(self, field_name: Union[Callable, str]) -> Field: ...
     def get_base_chain(self, model: Type[Model]) -> List[Type[Model]]: ...
     def get_parent_list(self) -> List[Type[Model]]: ...

django-stubs/db/models/query.pyi

@@ -16,7 +16,6 @@ from typing import (
     TypeVar,
     Union,
     overload,
-    Reversible,
 )
 
 from django.db.models.base import Model
@@ -31,7 +30,6 @@ _T = TypeVar("_T", bound=models.Model, covariant=True)
 _QS = TypeVar("_QS", bound="_BaseQuerySet")
 
 class _BaseQuerySet(Generic[_T], Sized):
-    model: Type[_T]
     query: Query
     def __init__(
         self,
@@ -54,9 +52,8 @@ class _BaseQuerySet(Generic[_T], Sized):
     def get(self, *args: Any, **kwargs: Any) -> _T: ...
     def create(self, *args: Any, **kwargs: Any) -> _T: ...
     def bulk_create(
-        self, objs: Iterable[_T], batch_size: Optional[int] = ..., ignore_conflicts: bool = ...
+        self, objs: Iterable[Model], batch_size: Optional[int] = ..., ignore_conflicts: bool = ...
     ) -> List[_T]: ...
-    def bulk_update(self, objs: Iterable[_T], fields: Sequence[str], batch_size: Optional[int] = ...) -> None: ...
     def get_or_create(self, defaults: Optional[MutableMapping[str, Any]] = ..., **kwargs: Any) -> Tuple[_T, bool]: ...
     def update_or_create(
         self, defaults: Optional[MutableMapping[str, Any]] = ..., **kwargs: Any
@@ -122,15 +119,16 @@ class _BaseQuerySet(Generic[_T], Sized):
     @property
     def db(self) -> str: ...
     def resolve_expression(self, *args: Any, **kwargs: Any) -> Any: ...
+    # TODO: remove when django adds __class_getitem__ methods
+    def __getattr__(self, item: str) -> Any: ...
 
-class QuerySet(_BaseQuerySet[_T], Collection[_T], Reversible[_T], Sized):
+class QuerySet(_BaseQuerySet[_T], Collection[_T], Sized):
     def __iter__(self) -> Iterator[_T]: ...
     def __contains__(self, x: object) -> bool: ...
     @overload
     def __getitem__(self, i: int) -> _T: ...
     @overload
     def __getitem__(self: _QS, s: slice) -> _QS: ...
-    def __reversed__(self) -> Iterator[_T]: ...
 
 _Row = TypeVar("_Row", covariant=True)
 

django-stubs/db/models/query_utils.pyi

@@ -1,13 +1,13 @@
-from collections import namedtuple
-from typing import Any, Collection, Dict, Iterator, List, Mapping, Optional, Sequence, Set, Tuple, Type
+from collections import OrderedDict, namedtuple
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Type, Union
 
 from django.db.models.base import Model
+from django.db.models.expressions import Expression
+from django.db.models.fields import Field
 from django.db.models.fields.mixins import FieldCacheMixin
 from django.db.models.sql.compiler import SQLCompiler
 from django.db.models.sql.query import Query
 from django.db.models.sql.where import WhereNode
-
-from django.db.models.fields import Field
 from django.utils import tree
 
 PathInfo = namedtuple("PathInfo", "from_opts to_opts target_fields join_field m2m direct filtered_relation")
@@ -23,8 +23,12 @@ class QueryWrapper:
     def as_sql(self, compiler: SQLCompiler = ..., connection: Any = ...) -> Any: ...
 
 class Q(tree.Node):
+    children: Union[List[Dict[str, str]], List[Tuple[str, Any]], List[Q]]
+    connector: str
+    negated: bool
     AND: str = ...
     OR: str = ...
+    default: Any = ...
     conditional: bool = ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def __or__(self, other: Any) -> Q: ...
@@ -42,8 +46,8 @@ class Q(tree.Node):
 
 class DeferredAttribute:
     field_name: str = ...
-    field: Field
     def __init__(self, field_name: str) -> None: ...
+    def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> Any: ...
 
 class RegisterLookupMixin:
     lookup_name: str
@@ -61,11 +65,15 @@ class RegisterLookupMixin:
 def select_related_descend(
     field: Field,
     restricted: bool,
-    requested: Optional[Mapping[str, Any]],
-    load_fields: Optional[Collection[str]],
+    requested: Optional[
+        Union[Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, Dict[Any, Any]]]]]]]], bool]
+    ],
+    load_fields: Optional[Set[str]],
     reverse: bool = ...,
 ) -> bool: ...
-def refs_expression(lookup_parts: Sequence[str], annotations: Mapping[str, bool]) -> Tuple[bool, Sequence[str]]: ...
+def refs_expression(
+    lookup_parts: List[str], annotations: OrderedDict
+) -> Union[Tuple[bool, Tuple], Tuple[Expression, List[str]]]: ...
 def check_rel_lookup_compatibility(model: Type[Model], target_opts: Any, field: FieldCacheMixin) -> bool: ...
 
 class FilteredRelation:

django-stubs/db/models/sql/compiler.pyi

@@ -25,7 +25,7 @@ class SQLCompiler:
     def setup_query(self) -> None: ...
     has_extra_select: Any = ...
     def pre_sql_setup(
-        self,
+        self
     ) -> Tuple[
         List[Tuple[Expression, Tuple[str, Union[List[Any], Tuple[str, str]]], None]],
         List[Tuple[Expression, Tuple[str, List[Union[int, str]], bool]]],
@@ -40,7 +40,7 @@ class SQLCompiler:
         self, expressions: List[Expression], having: Union[List[Expression], Tuple]
     ) -> List[Expression]: ...
     def get_select(
-        self,
+        self
     ) -> Tuple[
         List[Tuple[Expression, Tuple[str, List[Union[int, str]]], Optional[str]]],
         Optional[Dict[str, Any]],

django-stubs/db/models/sql/query.pyi

@@ -1,6 +1,6 @@
 import collections
 from collections import OrderedDict, namedtuple
-from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union, Iterable
+from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union
 
 from django.db.models.lookups import Lookup, Transform
 from django.db.models.query_utils import PathInfo, RegisterLookupMixin
@@ -155,19 +155,19 @@ class Query:
     def add_ordering(self, *ordering: Any) -> None: ...
     def clear_ordering(self, force_empty: bool) -> None: ...
     def set_group_by(self) -> None: ...
-    def add_select_related(self, fields: Iterable[str]) -> None: ...
+    def add_select_related(self, fields: Tuple[str]) -> None: ...
     def add_extra(
         self,
-        select: Optional[Dict[str, Any]],
-        select_params: Optional[Iterable[Any]],
-        where: Optional[Sequence[str]],
-        params: Optional[Sequence[str]],
-        tables: Optional[Sequence[str]],
-        order_by: Optional[Sequence[str]],
+        select: Optional[Union[Dict[str, int], Dict[str, str], OrderedDict]],
+        select_params: Optional[Union[List[int], List[str], Tuple[int]]],
+        where: Optional[List[str]],
+        params: Optional[List[str]],
+        tables: Optional[List[str]],
+        order_by: Optional[Union[List[str], Tuple[str]]],
     ) -> None: ...
     def clear_deferred_loading(self) -> None: ...
-    def add_deferred_loading(self, field_names: Iterable[str]) -> None: ...
-    def add_immediate_loading(self, field_names: Iterable[str]) -> None: ...
+    def add_deferred_loading(self, field_names: Tuple[str]) -> None: ...
+    def add_immediate_loading(self, field_names: Tuple[str]) -> None: ...
     def get_loaded_field_names(self) -> Dict[Type[Model], Set[str]]: ...
     def get_loaded_field_names_cb(
         self, target: Dict[Type[Model], Set[str]], model: Type[Model], fields: Set[Field]

django-stubs/forms/__init__.pyi

@@ -2,8 +2,6 @@ from django.core.exceptions import ValidationError as ValidationError
 
 from .forms import Form as Form, BaseForm as BaseForm
 
-from .formsets import BaseFormSet as BaseFormSet, all_valid as all_valid, formset_factory as formset_factory
-
 from .models import (
     ModelForm as ModelForm,
     ModelChoiceField as ModelChoiceField,

django-stubs/forms/fields.pyi

@@ -205,9 +205,10 @@ class CallableChoiceIterator:
     def __iter__(self) -> None: ...
 
 class ChoiceField(Field):
+    choices: Any = ...
     def __init__(
         self,
-        choices: Union[_FieldChoices, Callable[[], _FieldChoices]] = ...,
+        choices: Any = ...,
         required: bool = ...,
         widget: Optional[Union[Widget, Type[Widget]]] = ...,
         label: Optional[Any] = ...,

django-stubs/forms/forms.pyi

@@ -68,6 +68,4 @@ class BaseForm:
     def visible_fields(self): ...
     def get_initial_for_field(self, field: Field, field_name: str) -> Any: ...
 
-class Form(BaseForm):
-    base_fields: Dict[str, Field]
-    declared_fields: Dict[str, Field]
+class Form(BaseForm): ...

django-stubs/forms/models.pyi

@@ -1,21 +1,5 @@
 from datetime import datetime
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Mapping,
-    MutableMapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    Union,
-    ClassVar,
-    Container,
-    TypeVar,
-)
+from typing import Any, Callable, Dict, Iterator, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Type, Union
 from unittest.mock import MagicMock
 from uuid import UUID
 
@@ -40,11 +24,6 @@ _Fields = Union[List[Union[Callable, str]], Sequence[str], Literal["__all__"]]
 _Labels = Dict[str, str]
 _ErrorMessages = Dict[str, Dict[str, str]]
 
-_M = TypeVar("_M", bound=Model)
-
-def construct_instance(
-    form: BaseForm, instance: _M, fields: Optional[Container[str]] = ..., exclude: Optional[Container[str]] = ...
-) -> _M: ...
 def model_to_dict(
     instance: Model, fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ...
 ) -> Dict[str, Any]: ...
@@ -97,8 +76,7 @@ class BaseModelForm(BaseForm):
     save_m2m: Any = ...
     def save(self, commit: bool = ...) -> Any: ...
 
-class ModelForm(BaseModelForm, metaclass=ModelFormMetaclass):
-    base_fields: ClassVar[Dict[str, Field]] = ...
+class ModelForm(BaseModelForm): ...
 
 def modelform_factory(
     model: Type[Model],

django-stubs/http/request.pyi

@@ -18,7 +18,6 @@ from typing import (
 
 from django.contrib.auth.base_user import AbstractBaseUser
 from django.contrib.sessions.backends.base import SessionBase
-from django.contrib.sites.models import Site
 from django.utils.datastructures import CaseInsensitiveMapping, ImmutableList, MultiValueDict
 
 from django.core.files import uploadedfile, uploadhandler
@@ -52,7 +51,6 @@ class HttpRequest(BytesIO):
     content_type: Optional[str] = ...
     content_params: Optional[Dict[str, str]] = ...
     user: AbstractBaseUser
-    site: Site
     session: SessionBase
     encoding: Optional[str] = ...
     upload_handlers: UploadHandlerList = ...
@@ -65,7 +63,7 @@ class HttpRequest(BytesIO):
         self, key: str, default: Any = ..., salt: str = ..., max_age: Optional[int] = ...
     ) -> Optional[str]: ...
     def get_raw_uri(self) -> str: ...
-    def build_absolute_uri(self, location: Optional[str] = ...) -> str: ...
+    def build_absolute_uri(self, location: str = ...) -> str: ...
     @property
     def scheme(self) -> Optional[str]: ...
     def is_secure(self) -> bool: ...

django-stubs/http/response.pyi

@@ -63,8 +63,7 @@ class HttpResponseBase(Iterable[Any]):
 
 class HttpResponse(HttpResponseBase):
     client: Client
-    context: Context
-    content: Any
+    context: Optional[Context]
     csrf_cookie_set: bool
     redirect_chain: List[Tuple[str, int]]
     request: Dict[str, Any]
@@ -79,6 +78,10 @@ class HttpResponse(HttpResponseBase):
     def __init__(self, content: object = ..., *args: Any, **kwargs: Any) -> None: ...
     def serialize(self) -> bytes: ...
     @property
+    def content(self) -> Any: ...
+    @content.setter
+    def content(self, value: Any) -> None: ...
+    @property
     def url(self) -> str: ...
     def json(self) -> Dict[str, Any]: ...
 
@@ -104,7 +107,7 @@ class FileResponse(StreamingHttpResponse):
     def json(self) -> Dict[str, Any]: ...
 
 class HttpResponseRedirectBase(HttpResponse):
-    allowed_schemes: List[str] = ...
+    allowed_schemes = ...  # type: List[str]
     def __init__(self, redirect_to: str, *args: Any, **kwargs: Any) -> None: ...
 
 class HttpResponseRedirect(HttpResponseRedirectBase): ...

django-stubs/shortcuts.pyi

@@ -1,11 +1,7 @@
 from typing import Any, Callable, Dict, List, Optional, Protocol, Sequence, Type, TypeVar, Union
 
 from django.db.models.base import Model
-from django.http.response import (
-    HttpResponse as HttpResponse,
-    HttpResponseRedirect as HttpResponseRedirect,
-    HttpResponsePermanentRedirect as HttpResponsePermanentRedirect,
-)
+from django.http.response import HttpResponse as HttpResponse, HttpResponseRedirect as HttpResponseRedirect
 
 from django.db.models import Manager, QuerySet
 from django.http import HttpRequest
@@ -30,7 +26,7 @@ class SupportsGetAbsoluteUrl(Protocol): ...
 
 def redirect(
     to: Union[Callable, str, SupportsGetAbsoluteUrl], *args: Any, permanent: bool = ..., **kwargs: Any
-) -> Union[HttpResponseRedirect, HttpResponsePermanentRedirect]: ...
+) -> HttpResponseRedirect: ...
 
 _T = TypeVar("_T", bound=Model)
 

django-stubs/test/client.pyi

@@ -1,7 +1,7 @@
 from io import BytesIO
 from typing import Any, Dict, List, Optional, Pattern, Tuple, Type, Union
 
-from django.contrib.auth.models import AbstractUser
+from django.contrib.auth.models import User
 from django.contrib.sessions.backends.base import SessionBase
 from django.core.handlers.base import BaseHandler
 from django.core.serializers.json import DjangoJSONEncoder
@@ -9,8 +9,6 @@ from django.http.cookie import SimpleCookie
 from django.http.request import HttpRequest
 from django.http.response import HttpResponse, HttpResponseBase
 
-from django.core.handlers.wsgi import WSGIRequest
-
 BOUNDARY: str = ...
 MULTIPART_CONTENT: str = ...
 CONTENT_TYPE_RE: Pattern = ...
@@ -42,13 +40,13 @@ class RequestFactory:
     cookies: SimpleCookie = ...
     errors: BytesIO = ...
     def __init__(self, *, json_encoder: Any = ..., **defaults: Any) -> None: ...
-    def request(self, **request: Any) -> WSGIRequest: ...
-    def get(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ...
+    def request(self, **request: Any) -> HttpRequest: ...
+    def get(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> HttpRequest: ...
     def post(
         self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
-    ) -> WSGIRequest: ...
-    def head(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ...
-    def trace(self, path: str, secure: bool = ..., **extra: Any) -> WSGIRequest: ...
+    ) -> HttpRequest: ...
+    def head(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> HttpRequest: ...
+    def trace(self, path: str, secure: bool = ..., **extra: Any) -> HttpRequest: ...
     def options(
         self,
         path: str,
@@ -56,16 +54,16 @@ class RequestFactory:
         content_type: str = ...,
         secure: bool = ...,
         **extra: Any
-    ) -> WSGIRequest: ...
+    ) -> HttpRequest: ...
     def put(
         self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
-    ) -> WSGIRequest: ...
+    ) -> HttpRequest: ...
     def patch(
         self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
-    ) -> WSGIRequest: ...
+    ) -> HttpRequest: ...
     def delete(
         self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
-    ) -> WSGIRequest: ...
+    ) -> HttpRequest: ...
     def generic(
         self,
         method: str,
@@ -74,7 +72,7 @@ class RequestFactory:
         content_type: Optional[str] = ...,
         secure: bool = ...,
         **extra: Any
-    ) -> WSGIRequest: ...
+    ) -> HttpRequest: ...
 
 class Client:
     json_encoder: Type[DjangoJSONEncoder] = ...
@@ -84,11 +82,13 @@ class Client:
     handler: ClientHandler = ...
     exc_info: None = ...
     def __init__(self, enforce_csrf_checks: bool = ..., **defaults: Any) -> None: ...
-    def request(self, **request: Any) -> Any: ...
-    def get(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> Any: ...
-    def post(self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any) -> Any: ...
-    def head(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> Any: ...
-    def trace(self, path: str, secure: bool = ..., **extra: Any) -> Any: ...
+    def request(self, **request: Any) -> HttpResponse: ...
+    def get(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> HttpResponse: ...
+    def post(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...
+    def head(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> HttpResponse: ...
+    def trace(self, path: str, secure: bool = ..., **extra: Any) -> HttpResponse: ...
     def options(
         self,
         path: str,
@@ -96,10 +96,16 @@ class Client:
         content_type: str = ...,
         secure: bool = ...,
         **extra: Any
-    ) -> Any: ...
-    def put(self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any) -> Any: ...
-    def patch(self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any) -> Any: ...
-    def delete(self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any) -> Any: ...
+    ) -> HttpResponse: ...
+    def put(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...
+    def patch(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...
+    def delete(
+        self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
+    ) -> HttpResponse: ...
     def generic(
         self,
         method: str,
@@ -108,12 +114,12 @@ class Client:
         content_type: Optional[str] = ...,
         secure: bool = ...,
         **extra: Any
-    ) -> Any: ...
+    ) -> HttpResponse: ...
     def store_exc_info(self, **kwargs: Any) -> None: ...
     @property
     def session(self) -> SessionBase: ...
     def login(self, **credentials: Any) -> bool: ...
-    def force_login(self, user: AbstractUser, backend: Optional[str] = ...) -> None: ...
+    def force_login(self, user: User, backend: Optional[str] = ...) -> None: ...
     def logout(self) -> None: ...
 
 def conditional_content_removal(request: HttpRequest, response: HttpResponseBase) -> HttpResponse: ...

django-stubs/test/testcases.pyi

@@ -1,7 +1,7 @@
 import threading
 import unittest
 from datetime import date
-from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union, ClassVar, overload
+from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union
 
 from django.core.exceptions import ImproperlyConfigured
 from django.core.handlers.wsgi import WSGIHandler
@@ -47,8 +47,7 @@ class SimpleTestCase(unittest.TestCase):
     client_class: Any = ...
     client: Client
     allow_database_queries: bool = ...
-    # TODO: str -> Literal['__all__']
-    databases: Union[Set[str], str] = ...
+    databases: Set[str] = ...
     def __call__(self, result: Optional[unittest.TestResult] = ...) -> None: ...
     def settings(self, **kwargs: Any) -> Any: ...
     def modify_settings(self, **kwargs: Any) -> Any: ...
@@ -146,14 +145,9 @@ class TransactionTestCase(SimpleTestCase):
         ordered: bool = ...,
         msg: Optional[str] = ...,
     ) -> None: ...
-    @overload
     def assertNumQueries(
-        self, num: int, func: Callable[..., Any], *args: Any, using: str = ..., **kwargs: Any
-    ) -> None: ...
-    @overload
-    def assertNumQueries(
-        self, num: int, func: None = ..., *args: Any, using: str = ..., **kwargs: Any
-    ) -> _AssertNumQueriesContext: ...
+        self, num: int, func: Optional[Union[Callable, Type[list]]] = ..., *args: Any, using: Any = ..., **kwargs: Any
+    ) -> Optional[_AssertNumQueriesContext]: ...
 
 class TestCase(TransactionTestCase):
     @classmethod
@@ -204,12 +198,13 @@ class LiveServerThread(threading.Thread):
     def terminate(self) -> None: ...
 
 class LiveServerTestCase(TransactionTestCase):
-    live_server_url: ClassVar[str]
     host: str = ...
     port: int = ...
     server_thread_class: Type[Any] = ...
     server_thread: Any
     static_handler: Any = ...
+    @classmethod
+    def live_server_url(cls): ...
 
 class SerializeMixin:
     lockfile: Any = ...

django-stubs/test/utils.pyi

@@ -1,22 +1,9 @@
 import decimal
+import warnings
 from contextlib import contextmanager
 from decimal import Decimal
 from io import StringIO
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    Union,
-    ContextManager,
-)
+from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Set, Tuple, Type, Union
 
 from django.apps.registry import Apps
 from django.core.checks.registry import CheckRegistry
@@ -99,7 +86,7 @@ class ignore_warnings(TestContextDecorator):
     ignore_kwargs: Dict[str, Any] = ...
     filter_func: Callable = ...
     def __init__(self, **kwargs: Any) -> None: ...
-    catch_warnings: ContextManager[Optional[list]] = ...
+    catch_warnings: warnings.catch_warnings = ...
 
 requires_tz_support: Any
 

django-stubs/utils/_os.pyi

@@ -1,5 +1,4 @@
 from os.path import abspath
-from pathlib import Path
 from typing import Any, Union
 
 abspathu = abspath
@@ -8,4 +7,3 @@ def upath(path: Any): ...
 def npath(path: Any): ...
 def safe_join(base: Union[bytes, str], *paths: Any) -> str: ...
 def symlinks_supported() -> Any: ...
-def to_path(value: Union[Path, str]) -> Path: ...

django-stubs/utils/deprecation.pyi

@@ -5,7 +5,6 @@ from django.http.response import HttpResponse
 
 class RemovedInDjango30Warning(PendingDeprecationWarning): ...
 class RemovedInDjango31Warning(PendingDeprecationWarning): ...
-class RemovedInDjango40Warning(PendingDeprecationWarning): ...
 class RemovedInNextVersionWarning(DeprecationWarning): ...
 
 class warn_about_renamed_method:

django-stubs/utils/encoding.pyi

@@ -1,59 +1,25 @@
-import datetime
-from decimal import Decimal
-from typing import Any, TypeVar, overload, Union
-
-from django.utils.functional import Promise
-from typing_extensions import Literal
+from typing import Any, Optional
 
 class DjangoUnicodeDecodeError(UnicodeDecodeError):
     obj: bytes = ...
     def __init__(self, obj: bytes, *args: Any) -> None: ...
 
-_P = TypeVar("_P", bound=Promise)
-_S = TypeVar("_S", bound=str)
-_PT = TypeVar("_PT", None, int, float, Decimal, datetime.datetime, datetime.date, datetime.time)
-@overload
-def smart_text(s: _P, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _P: ...
-@overload
-def smart_text(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ...
-@overload
-def smart_text(s: _S, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _S: ...
-@overload
+python_2_unicode_compatible: Any
+
 def smart_text(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> str: ...
 def is_protected_type(obj: Any) -> bool: ...
-@overload
-def force_text(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ...
-@overload
-def force_text(s: _S, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _S: ...
-@overload
-def force_text(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> str: ...
-@overload
-def smart_bytes(s: _P, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _P: ...
-@overload
-def smart_bytes(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ...
-@overload
+def force_text(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> Optional[str]: ...
 def smart_bytes(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> bytes: ...
-@overload
-def force_bytes(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ...
-@overload
 def force_bytes(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> bytes: ...
 
 smart_str = smart_text
 force_str = force_text
-@overload
-def iri_to_uri(iri: None) -> None: ...
-@overload
-def iri_to_uri(iri: Union[str, Promise]) -> str: ...
-@overload
-def uri_to_iri(iri: None) -> None: ...
-@overload
-def uri_to_iri(iri: str) -> str: ...
+
+def iri_to_uri(iri: Optional[str]) -> Optional[str]: ...
+def uri_to_iri(uri: Optional[str]) -> Optional[str]: ...
 def escape_uri_path(path: str) -> str: ...
 def repercent_broken_unicode(path: bytes) -> bytes: ...
-@overload
-def filepath_to_uri(path: None) -> None: ...
-@overload
-def filepath_to_uri(path: str) -> str: ...
+def filepath_to_uri(path: Optional[str]) -> Optional[str]: ...
 def get_system_encoding() -> str: ...
 
 DEFAULT_LOCALE_ENCODING: Any

django-stubs/utils/http.pyi

@@ -25,9 +25,6 @@ def urlsafe_base64_decode(s: Union[bytes, str]) -> bytes: ...
 def parse_etags(etag_str: str) -> List[str]: ...
 def quote_etag(etag_str: str) -> str: ...
 def is_same_domain(host: str, pattern: str) -> bool: ...
-def url_has_allowed_host_and_scheme(
-    url: Optional[str], allowed_hosts: Optional[Union[str, Iterable[str]]], require_https: bool = ...
-) -> bool: ...
 def is_safe_url(
     url: Optional[str], allowed_hosts: Optional[Union[str, Iterable[str]]], require_https: bool = ...
 ) -> bool: ...

django-stubs/utils/timezone.pyi

@@ -1,10 +1,8 @@
 import types
 from contextlib import ContextDecorator
-from datetime import date, datetime as datetime, time, timedelta as timedelta, tzinfo as tzinfo, timezone
+from datetime import date, datetime as datetime, time, timedelta as timedelta, tzinfo as tzinfo
 from typing import Optional, Union, Type
 
-from pytz import BaseTzInfo
-
 _AnyTime = Union[time, datetime]
 
 class UTC(tzinfo):
@@ -32,14 +30,10 @@ class LocalTimezone(ReferenceLocalTimezone):
 
 utc: UTC = ...
 
-def get_fixed_timezone(offset: Union[timedelta, int]) -> timezone: ...
-def get_default_timezone() -> BaseTzInfo: ...
+def get_fixed_timezone(offset: Union[timedelta, int]) -> tzinfo: ...
+def get_default_timezone() -> tzinfo: ...
 def get_default_timezone_name() -> str: ...
-
-# Strictly speaking, it is possible to activate() a non-pytz timezone,
-# in which case BaseTzInfo is incorrect. However, this is unlikely,
-# so we use it anyway, to keep things ergonomic for most users.
-def get_current_timezone() -> BaseTzInfo: ...
+def get_current_timezone() -> tzinfo: ...
 def get_current_timezone_name() -> str: ...
 def activate(timezone: Union[tzinfo, str]) -> None: ...
 def deactivate() -> None: ...

django-stubs/utils/tree.pyi

@@ -1,16 +1,16 @@
-from typing import Any, Dict, Iterable, Optional, Tuple, Union, Sequence, List
+from typing import Any, Dict, Iterable, Optional, Tuple, Union, Sequence
 
 from django.db.models.sql.where import NothingNode
 
-_NodeChildren = Iterable[Union["Node", NothingNode, Sequence[Any]]]
-
 class Node:
-    children: List[Any]
-    default: Any = ...
+    default: str = ...
     connector: str = ...
     negated: bool = ...
     def __init__(
-        self, children: Optional[_NodeChildren] = ..., connector: Optional[str] = ..., negated: bool = ...
+        self,
+        children: Optional[Iterable[Union[Node, NothingNode, Sequence[Any]]]] = ...,
+        connector: Optional[str] = ...,
+        negated: bool = ...,
     ) -> None: ...
     def __deepcopy__(self, memodict: Dict[Any, Any]) -> Node: ...
     def __len__(self) -> int: ...

django-stubs/views/debug.pyi

@@ -63,4 +63,4 @@ class ExceptionReporter:
     ): ...
 
 def technical_404_response(request: HttpRequest, exception: Http404) -> HttpResponse: ...
-def default_urlconf(request: Optional[HttpResponse]) -> HttpResponse: ...
+def default_urlconf(request: HttpRequest) -> HttpResponse: ...

django-stubs/views/generic/base.pyi

@@ -13,7 +13,6 @@ class View:
     def __init__(self, **kwargs: Any) -> None: ...
     @classmethod
     def as_view(cls: Any, **initkwargs: Any) -> Callable[..., http.HttpResponse]: ...
-    def setup(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> None: ...
     def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
     def http_method_not_allowed(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...
     def options(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ...

django-stubs/views/generic/edit.pyi

@@ -1,12 +1,11 @@
 from typing import Any, Callable, Dict, Optional, Sequence, Type, Union
 
 from django.forms.forms import BaseForm
+from django.http import HttpRequest, HttpResponse
 from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
 from django.views.generic.detail import BaseDetailView, SingleObjectMixin, SingleObjectTemplateResponseMixin
 from typing_extensions import Literal
 
-from django.http import HttpRequest, HttpResponse
-
 class FormMixin(ContextMixin):
     initial: Dict[str, Any] = ...
     form_class: Optional[Type[BaseForm]] = ...

mypy.ini

@@ -1,2 +1 @@
 [mypy]
-warn_unused_ignores = True

mypy_django_plugin/django/context.py

@@ -1,5 +1,4 @@
 import os
-import sys
 from collections import defaultdict
 from contextlib import contextmanager
 from typing import (
@@ -49,9 +48,6 @@ def initialize_django(settings_module: str) -> Tuple['Apps', 'LazySettings']:
     with temp_environ():
         os.environ['DJANGO_SETTINGS_MODULE'] = settings_module
 
-        # add current directory to sys.path
-        sys.path.append(os.getcwd())
-
         def noop_class_getitem(cls, key):
             return cls
 
@@ -77,12 +73,176 @@ def initialize_django(settings_module: str) -> Tuple['Apps', 'LazySettings']:
     return apps, settings
 
 
+class DjangoFieldsContext:
+    def __init__(self, django_context: 'DjangoContext') -> None:
+        self.django_context = django_context
+
+    def get_attname(self, field: Field) -> str:
+        attname = field.attname
+        return attname
+
+    def get_field_nullability(self, field: Field, method: Optional[str]) -> bool:
+        nullable = field.null
+        if not nullable and isinstance(field, CharField) and field.blank:
+            return True
+        if method == '__init__':
+            if field.primary_key or isinstance(field, ForeignKey):
+                return True
+        if method == 'create':
+            if isinstance(field, AutoField):
+                return True
+        if field.has_default():
+            return True
+        return nullable
+
+    def get_field_set_type(self, api: TypeChecker, field: Field, *, method: str) -> MypyType:
+        """ Get a type of __set__ for this specific Django field. """
+        target_field = field
+        if isinstance(field, ForeignKey):
+            target_field = field.target_field
+
+        field_info = helpers.lookup_class_typeinfo(api, target_field.__class__)
+        if field_info is None:
+            return AnyType(TypeOfAny.from_error)
+
+        field_set_type = helpers.get_private_descriptor_type(field_info, '_pyi_private_set_type',
+                                                             is_nullable=self.get_field_nullability(field, method))
+        if isinstance(target_field, ArrayField):
+            argument_field_type = self.get_field_set_type(api, target_field.base_field, method=method)
+            field_set_type = helpers.convert_any_to_type(field_set_type, argument_field_type)
+        return field_set_type
+
+    def get_field_get_type(self, api: TypeChecker, field: Field, *, method: str) -> MypyType:
+        """ Get a type of __get__ for this specific Django field. """
+        field_info = helpers.lookup_class_typeinfo(api, field.__class__)
+        if field_info is None:
+            return AnyType(TypeOfAny.unannotated)
+
+        is_nullable = self.get_field_nullability(field, method)
+        if isinstance(field, RelatedField):
+            related_model_cls = self.django_context.fields_context.get_related_model_cls(field)
+
+            if method == 'values':
+                primary_key_field = self.django_context.get_primary_key_field(related_model_cls)
+                return self.get_field_get_type(api, primary_key_field, method=method)
+
+            model_info = helpers.lookup_class_typeinfo(api, related_model_cls)
+            if model_info is None:
+                return AnyType(TypeOfAny.unannotated)
+
+            return Instance(model_info, [])
+        else:
+            return helpers.get_private_descriptor_type(field_info, '_pyi_private_get_type',
+                                                       is_nullable=is_nullable)
+
+    def get_related_model_cls(self, field: Union[RelatedField, ForeignObjectRel]) -> Type[Model]:
+        if isinstance(field, RelatedField):
+            related_model_cls = field.remote_field.model
+        else:
+            related_model_cls = field.field.model
+
+        if isinstance(related_model_cls, str):
+            if related_model_cls == 'self':
+                # same model
+                related_model_cls = field.model
+            elif '.' not in related_model_cls:
+                # same file model
+                related_model_fullname = field.model.__module__ + '.' + related_model_cls
+                related_model_cls = self.django_context.get_model_class_by_fullname(related_model_fullname)
+            else:
+                related_model_cls = self.django_context.apps_registry.get_model(related_model_cls)
+
+        return related_model_cls
+
+
 class LookupsAreUnsupported(Exception):
     pass
 
 
+class DjangoLookupsContext:
+    def __init__(self, django_context: 'DjangoContext'):
+        self.django_context = django_context
+
+    def _resolve_field_from_parts(self, field_parts: Iterable[str], model_cls: Type[Model]) -> Field:
+        currently_observed_model = model_cls
+        field = None
+        for field_part in field_parts:
+            if field_part == 'pk':
+                field = self.django_context.get_primary_key_field(currently_observed_model)
+                continue
+
+            field = currently_observed_model._meta.get_field(field_part)
+            if isinstance(field, RelatedField):
+                currently_observed_model = field.related_model
+                model_name = currently_observed_model._meta.model_name
+                if (model_name is not None
+                        and field_part == (model_name + '_id')):
+                    field = self.django_context.get_primary_key_field(currently_observed_model)
+
+            if isinstance(field, ForeignObjectRel):
+                currently_observed_model = field.related_model
+
+        assert field is not None
+        return field
+
+    def resolve_lookup_info_field(self, model_cls: Type[Model], lookup: str) -> Field:
+        query = Query(model_cls)
+        lookup_parts, field_parts, is_expression = query.solve_lookup_type(lookup)
+        if lookup_parts:
+            raise LookupsAreUnsupported()
+
+        return self._resolve_field_from_parts(field_parts, model_cls)
+
+    def resolve_lookup_expected_type(self, ctx: MethodContext, model_cls: Type[Model], lookup: str) -> MypyType:
+        query = Query(model_cls)
+        try:
+            lookup_parts, field_parts, is_expression = query.solve_lookup_type(lookup)
+            if is_expression:
+                return AnyType(TypeOfAny.explicit)
+        except FieldError as exc:
+            ctx.api.fail(exc.args[0], ctx.context)
+            return AnyType(TypeOfAny.from_error)
+
+        field = self._resolve_field_from_parts(field_parts, model_cls)
+
+        lookup_cls = None
+        if lookup_parts:
+            lookup = lookup_parts[-1]
+            lookup_cls = field.get_lookup(lookup)
+            if lookup_cls is None:
+                # unknown lookup
+                return AnyType(TypeOfAny.explicit)
+
+        if lookup_cls is None or isinstance(lookup_cls, Exact):
+            return self.django_context.get_field_lookup_exact_type(helpers.get_typechecker_api(ctx), field)
+
+        assert lookup_cls is not None
+
+        lookup_info = helpers.lookup_class_typeinfo(helpers.get_typechecker_api(ctx), lookup_cls)
+        if lookup_info is None:
+            return AnyType(TypeOfAny.explicit)
+
+        for lookup_base in helpers.iter_bases(lookup_info):
+            if lookup_base.args and isinstance(lookup_base.args[0], Instance):
+                lookup_type: MypyType = lookup_base.args[0]
+                # if it's Field, consider lookup_type a __get__ of current field
+                if (isinstance(lookup_type, Instance)
+                        and lookup_type.type.fullname() == fullnames.FIELD_FULLNAME):
+                    field_info = helpers.lookup_class_typeinfo(helpers.get_typechecker_api(ctx), field.__class__)
+                    if field_info is None:
+                        return AnyType(TypeOfAny.explicit)
+                    lookup_type = helpers.get_private_descriptor_type(field_info, '_pyi_private_get_type',
+                                                                      is_nullable=field.null)
+                return lookup_type
+
+        return AnyType(TypeOfAny.explicit)
+
+
 class DjangoContext:
     def __init__(self, django_settings_module: str) -> None:
+        self.fields_context = DjangoFieldsContext(self)
+        self.lookups_context = DjangoLookupsContext(self)
+
         self.django_settings_module = django_settings_module
 
         apps, settings = initialize_django(self.django_settings_module)
@@ -124,18 +284,20 @@ class DjangoContext:
             if isinstance(field, ForeignObjectRel):
                 yield field
 
-    def get_field_lookup_exact_type(self, api: TypeChecker, field: Union[Field, ForeignObjectRel]) -> MypyType:
+    def get_field_lookup_exact_type(self, api: TypeChecker, field: Field) -> MypyType:
         if isinstance(field, (RelatedField, ForeignObjectRel)):
             related_model_cls = field.related_model
             primary_key_field = self.get_primary_key_field(related_model_cls)
-            primary_key_type = self.get_field_get_type(api, primary_key_field, method='init')
+            primary_key_type = self.fields_context.get_field_get_type(api, primary_key_field, method='init')
 
             rel_model_info = helpers.lookup_class_typeinfo(api, related_model_cls)
             if rel_model_info is None:
                 return AnyType(TypeOfAny.explicit)
 
-            model_and_primary_key_type = UnionType.make_union([Instance(rel_model_info, []), primary_key_type])
+            model_and_primary_key_type = UnionType.make_union([Instance(rel_model_info, []),
+                                                               primary_key_type])
             return helpers.make_optional(model_and_primary_key_type)
+            # return helpers.make_optional(Instance(rel_model_info, []))
 
         field_info = helpers.lookup_class_typeinfo(api, field.__class__)
         if field_info is None:
@@ -157,13 +319,13 @@ class DjangoContext:
         # add pk if not abstract=True
         if not model_cls._meta.abstract:
             primary_key_field = self.get_primary_key_field(model_cls)
-            field_set_type = self.get_field_set_type(api, primary_key_field, method=method)
+            field_set_type = self.fields_context.get_field_set_type(api, primary_key_field, method=method)
             expected_types['pk'] = field_set_type
 
         for field in model_cls._meta.get_fields():
             if isinstance(field, Field):
                 field_name = field.attname
-                field_set_type = self.get_field_set_type(api, field, method=method)
+                field_set_type = self.fields_context.get_field_set_type(api, field, method=method)
                 expected_types[field_name] = field_set_type
 
                 if isinstance(field, ForeignKey):
@@ -174,11 +336,7 @@ class DjangoContext:
                         expected_types[field_name] = AnyType(TypeOfAny.unannotated)
                         continue
 
-                    related_model = self.get_field_related_model_cls(field)
-                    if related_model is None:
-                        expected_types[field_name] = AnyType(TypeOfAny.from_error)
-                        continue
-
+                    related_model = self.fields_context.get_related_model_cls(field)
                     if related_model._meta.proxy_for_model is not None:
                         related_model = related_model._meta.proxy_for_model
 
@@ -187,7 +345,7 @@ class DjangoContext:
                         expected_types[field_name] = AnyType(TypeOfAny.unannotated)
                         continue
 
-                    is_nullable = self.get_field_nullability(field, method)
+                    is_nullable = self.fields_context.get_field_nullability(field, method)
                     foreign_key_set_type = helpers.get_private_descriptor_type(foreign_key_info,
                                                                                '_pyi_private_set_type',
                                                                                is_nullable=is_nullable)
@@ -207,177 +365,13 @@ class DjangoContext:
         return expected_types
 
     @cached_property
-    def all_registered_model_classes(self) -> Set[Type[models.Model]]:
+    def model_base_classes(self) -> Set[str]:
         model_classes = self.apps_registry.get_models()
 
         all_model_bases = set()
         for model_cls in model_classes:
             for base_cls in model_cls.mro():
                 if issubclass(base_cls, models.Model):
-                    all_model_bases.add(base_cls)
+                    all_model_bases.add(helpers.get_class_fullname(base_cls))
 
         return all_model_bases
-
-    @cached_property
-    def all_registered_model_class_fullnames(self) -> Set[str]:
-        return {helpers.get_class_fullname(cls) for cls in self.all_registered_model_classes}
-
-    def get_attname(self, field: Field) -> str:
-        attname = field.attname
-        return attname
-
-    def get_field_nullability(self, field: Union[Field, ForeignObjectRel], method: Optional[str]) -> bool:
-        nullable = field.null
-        if not nullable and isinstance(field, CharField) and field.blank:
-            return True
-        if method == '__init__':
-            if ((isinstance(field, Field) and field.primary_key)
-                    or isinstance(field, ForeignKey)):
-                return True
-        if method == 'create':
-            if isinstance(field, AutoField):
-                return True
-        if isinstance(field, Field) and field.has_default():
-            return True
-        return nullable
-
-    def get_field_set_type(self, api: TypeChecker, field: Union[Field, ForeignObjectRel], *, method: str) -> MypyType:
-        """ Get a type of __set__ for this specific Django field. """
-        target_field = field
-        if isinstance(field, ForeignKey):
-            target_field = field.target_field
-
-        field_info = helpers.lookup_class_typeinfo(api, target_field.__class__)
-        if field_info is None:
-            return AnyType(TypeOfAny.from_error)
-
-        field_set_type = helpers.get_private_descriptor_type(field_info, '_pyi_private_set_type',
-                                                             is_nullable=self.get_field_nullability(field, method))
-        if isinstance(target_field, ArrayField):
-            argument_field_type = self.get_field_set_type(api, target_field.base_field, method=method)
-            field_set_type = helpers.convert_any_to_type(field_set_type, argument_field_type)
-        return field_set_type
-
-    def get_field_get_type(self, api: TypeChecker, field: Union[Field, ForeignObjectRel], *, method: str) -> MypyType:
-        """ Get a type of __get__ for this specific Django field. """
-        field_info = helpers.lookup_class_typeinfo(api, field.__class__)
-        if field_info is None:
-            return AnyType(TypeOfAny.unannotated)
-
-        is_nullable = self.get_field_nullability(field, method)
-        if isinstance(field, RelatedField):
-            related_model_cls = self.get_field_related_model_cls(field)
-            if related_model_cls is None:
-                return AnyType(TypeOfAny.from_error)
-
-            if method == 'values':
-                primary_key_field = self.get_primary_key_field(related_model_cls)
-                return self.get_field_get_type(api, primary_key_field, method=method)
-
-            model_info = helpers.lookup_class_typeinfo(api, related_model_cls)
-            if model_info is None:
-                return AnyType(TypeOfAny.unannotated)
-
-            return Instance(model_info, [])
-        else:
-            return helpers.get_private_descriptor_type(field_info, '_pyi_private_get_type',
-                                                       is_nullable=is_nullable)
-
-    def get_field_related_model_cls(self, field: Union[RelatedField, ForeignObjectRel]) -> Optional[Type[Model]]:
-        if isinstance(field, RelatedField):
-            related_model_cls = field.remote_field.model
-        else:
-            related_model_cls = field.field.model
-
-        if isinstance(related_model_cls, str):
-            if related_model_cls == 'self':
-                # same model
-                related_model_cls = field.model
-            elif '.' not in related_model_cls:
-                # same file model
-                related_model_fullname = field.model.__module__ + '.' + related_model_cls
-                related_model_cls = self.get_model_class_by_fullname(related_model_fullname)
-            else:
-                related_model_cls = self.apps_registry.get_model(related_model_cls)
-
-        return related_model_cls
-
-    def _resolve_field_from_parts(self,
-                                  field_parts: Iterable[str],
-                                  model_cls: Type[Model]
-                                  ) -> Union[Field, ForeignObjectRel]:
-        currently_observed_model = model_cls
-        field = None
-        for field_part in field_parts:
-            if field_part == 'pk':
-                field = self.get_primary_key_field(currently_observed_model)
-                continue
-
-            field = currently_observed_model._meta.get_field(field_part)
-            if isinstance(field, RelatedField):
-                currently_observed_model = field.related_model
-                model_name = currently_observed_model._meta.model_name
-                if (model_name is not None
-                        and field_part == (model_name + '_id')):
-                    field = self.get_primary_key_field(currently_observed_model)
-
-            if isinstance(field, ForeignObjectRel):
-                currently_observed_model = field.related_model
-
-        assert field is not None
-        return field
-
-    def resolve_lookup_into_field(self, model_cls: Type[Model], lookup: str) -> Union[Field, ForeignObjectRel]:
-        query = Query(model_cls)
-        lookup_parts, field_parts, is_expression = query.solve_lookup_type(lookup)
-        if lookup_parts:
-            raise LookupsAreUnsupported()
-
-        return self._resolve_field_from_parts(field_parts, model_cls)
-
-    def resolve_lookup_expected_type(self, ctx: MethodContext, model_cls: Type[Model], lookup: str) -> MypyType:
-        query = Query(model_cls)
-        try:
-            lookup_parts, field_parts, is_expression = query.solve_lookup_type(lookup)
-            if is_expression:
-                return AnyType(TypeOfAny.explicit)
-        except FieldError as exc:
-            ctx.api.fail(exc.args[0], ctx.context)
-            return AnyType(TypeOfAny.from_error)
-
-        field = self._resolve_field_from_parts(field_parts, model_cls)
-
-        lookup_cls = None
-        if lookup_parts:
-            lookup = lookup_parts[-1]
-            lookup_cls = field.get_lookup(lookup)
-            if lookup_cls is None:
-                # unknown lookup
-                return AnyType(TypeOfAny.explicit)
-
-        if lookup_cls is None or isinstance(lookup_cls, Exact):
-            return self.get_field_lookup_exact_type(helpers.get_typechecker_api(ctx), field)
-
-        assert lookup_cls is not None
-
-        lookup_info = helpers.lookup_class_typeinfo(helpers.get_typechecker_api(ctx), lookup_cls)
-        if lookup_info is None:
-            return AnyType(TypeOfAny.explicit)
-
-        for lookup_base in helpers.iter_bases(lookup_info):
-            if lookup_base.args and isinstance(lookup_base.args[0], Instance):
-                lookup_type: MypyType = lookup_base.args[0]
-                # if it's Field, consider lookup_type a __get__ of current field
-                if (isinstance(lookup_type, Instance)
-                        and lookup_type.type.fullname == fullnames.FIELD_FULLNAME):
-                    field_info = helpers.lookup_class_typeinfo(helpers.get_typechecker_api(ctx), field.__class__)
-                    if field_info is None:
-                        return AnyType(TypeOfAny.explicit)
-                    lookup_type = helpers.get_private_descriptor_type(field_info, '_pyi_private_get_type',
-                                                                      is_nullable=field.null)
-                return lookup_type
-
-        return AnyType(TypeOfAny.explicit)
-
-    def resolve_f_expression_type(self, f_expression_type: Instance) -> MypyType:
-        return AnyType(TypeOfAny.explicit)

mypy_django_plugin/lib/fullnames.py

@@ -13,7 +13,7 @@ DUMMY_SETTINGS_BASE_CLASS = 'django.conf._DjangoConfLazyObject'
 QUERYSET_CLASS_FULLNAME = 'django.db.models.query.QuerySet'
 BASE_MANAGER_CLASS_FULLNAME = 'django.db.models.manager.BaseManager'
 MANAGER_CLASS_FULLNAME = 'django.db.models.manager.Manager'
-RELATED_MANAGER_CLASS = 'django.db.models.manager.RelatedManager'
+RELATED_MANAGER_CLASS_FULLNAME = 'django.db.models.manager.RelatedManager'
 
 BASEFORM_CLASS_FULLNAME = 'django.forms.forms.BaseForm'
 FORM_CLASS_FULLNAME = 'django.forms.forms.Form'
@@ -23,7 +23,9 @@ FORM_MIXIN_CLASS_FULLNAME = 'django.views.generic.edit.FormMixin'
 
 MANAGER_CLASSES = {
     MANAGER_CLASS_FULLNAME,
+    RELATED_MANAGER_CLASS_FULLNAME,
     BASE_MANAGER_CLASS_FULLNAME,
+    # QUERYSET_CLASS_FULLNAME
 }
 
 RELATED_FIELDS_CLASSES = {
@@ -35,5 +37,3 @@ RELATED_FIELDS_CLASSES = {
 MIGRATION_CLASS_FULLNAME = 'django.db.migrations.migration.Migration'
 OPTIONS_CLASS_FULLNAME = 'django.db.models.options.Options'
 HTTPREQUEST_CLASS_FULLNAME = 'django.http.request.HttpRequest'
-
-F_EXPRESSION_FULLNAME = 'django.db.models.expressions.F'

mypy_django_plugin/lib/helpers.py

@@ -1,6 +1,6 @@
 from collections import OrderedDict
 from typing import (
-    TYPE_CHECKING, Any, Dict, Iterable, Iterator, List, Optional, Set, Tuple, Union,
+    TYPE_CHECKING, Any, Dict, Iterable, Iterator, List, Optional, Set, Union, cast,
 )
 
 from django.db.models.fields import Field
@@ -10,15 +10,13 @@ from mypy import checker
 from mypy.checker import TypeChecker
 from mypy.mro import calculate_mro
 from mypy.nodes import (
-    GDEF, MDEF, Argument, Block, ClassDef, Expression, FuncDef, MemberExpr, MypyFile, NameExpr, StrExpr, SymbolNode,
-    SymbolTable, SymbolTableNode, TypeInfo, Var,
+    GDEF, MDEF, Block, ClassDef, Expression, MemberExpr, MypyFile, NameExpr, StrExpr, SymbolNode, SymbolTable,
+    SymbolTableNode, TypeInfo, Var,
 )
 from mypy.plugin import (
-    AttributeContext, CheckerPluginInterface, ClassDefContext, DynamicClassDefContext, FunctionContext, MethodContext,
+    AttributeContext, CheckerPluginInterface, FunctionContext, MethodContext,
 )
-from mypy.plugins.common import add_method
-from mypy.semanal import SemanticAnalyzer
-from mypy.types import AnyType, CallableType, Instance, NoneTyp, TupleType
+from mypy.types import AnyType, Instance, NoneTyp, TupleType
 from mypy.types import Type as MypyType
 from mypy.types import TypedDictType, TypeOfAny, UnionType
 
@@ -57,7 +55,7 @@ def lookup_fully_qualified_generic(name: str, all_modules: Dict[str, MypyFile])
     return sym.node
 
 
-def lookup_fully_qualified_typeinfo(api: Union[TypeChecker, SemanticAnalyzer], fullname: str) -> Optional[TypeInfo]:
+def lookup_fully_qualified_typeinfo(api: TypeChecker, fullname: str) -> Optional[TypeInfo]:
     node = lookup_fully_qualified_generic(fullname, api.modules)
     if not isinstance(node, TypeInfo):
         return None
@@ -175,30 +173,32 @@ def get_nested_meta_node_for_current_class(info: TypeInfo) -> Optional[TypeInfo]
     return None
 
 
-def add_new_class_for_module(module: MypyFile,
-                             name: str,
-                             bases: List[Instance],
-                             fields: Optional[Dict[str, MypyType]] = None
-                             ) -> TypeInfo:
+def add_new_class_for_module(module: MypyFile, name: str, bases: List[Instance],
+                             fields: 'OrderedDict[str, MypyType]') -> TypeInfo:
     new_class_unique_name = checker.gen_unique_name(name, module.names)
 
     # make new class expression
     classdef = ClassDef(new_class_unique_name, Block([]))
-    classdef.fullname = module.fullname + '.' + new_class_unique_name
+    classdef.fullname = module.fullname() + '.' + new_class_unique_name
 
     # make new TypeInfo
-    new_typeinfo = TypeInfo(SymbolTable(), classdef, module.fullname)
+    new_typeinfo = TypeInfo(SymbolTable(), classdef, module.fullname())
     new_typeinfo.bases = bases
     calculate_mro(new_typeinfo)
     new_typeinfo.calculate_metaclass_type()
 
+    def add_field_to_new_typeinfo(var: Var, is_initialized_in_class: bool = False,
+                                  is_property: bool = False) -> None:
+        var.info = new_typeinfo
+        var.is_initialized_in_class = is_initialized_in_class
+        var.is_property = is_property
+        var._fullname = new_typeinfo.fullname() + '.' + var.name()
+        new_typeinfo.names[var.name()] = SymbolTableNode(MDEF, var)
+
     # add fields
-    if fields:
-        for field_name, field_type in fields.items():
-            var = Var(field_name, type=field_type)
-            var.info = new_typeinfo
-            var._fullname = new_typeinfo.fullname + '.' + field_name
-            new_typeinfo.names[field_name] = SymbolTableNode(MDEF, var, plugin_generated=True)
+    var_items = [Var(item, typ) for item, typ in fields.items()]
+    for var_item in var_items:
+        add_field_to_new_typeinfo(var_item, is_property=True)
 
     classdef.info = new_typeinfo
     module.names[new_class_unique_name] = SymbolTableNode(GDEF, new_typeinfo, plugin_generated=True)
@@ -259,7 +259,8 @@ def make_typeddict(api: CheckerPluginInterface, fields: 'OrderedDict[str, MypyTy
     return typed_dict_type
 
 
-def resolve_string_attribute_value(attr_expr: Expression, django_context: 'DjangoContext') -> Optional[str]:
+def resolve_string_attribute_value(attr_expr: Expression, ctx: Union[FunctionContext, MethodContext],
+                                   django_context: 'DjangoContext') -> Optional[str]:
     if isinstance(attr_expr, StrExpr):
         return attr_expr.value
 
@@ -269,74 +270,17 @@ def resolve_string_attribute_value(attr_expr: Expression, django_context: 'Djang
         if isinstance(attr_expr.expr, NameExpr) and attr_expr.expr.fullname == 'django.conf.settings':
             if hasattr(django_context.settings, member_name):
                 return getattr(django_context.settings, member_name)
+
+    ctx.api.fail(f'Expression of type {type(attr_expr).__name__!r} is not supported', ctx.context)
     return None
 
 
-def get_semanal_api(ctx: Union[ClassDefContext, DynamicClassDefContext]) -> SemanticAnalyzer:
-    if not isinstance(ctx.api, SemanticAnalyzer):
-        raise ValueError('Not a SemanticAnalyzer')
-    return ctx.api
-
-
 def get_typechecker_api(ctx: Union[AttributeContext, MethodContext, FunctionContext]) -> TypeChecker:
     if not isinstance(ctx.api, TypeChecker):
         raise ValueError('Not a TypeChecker')
-    return ctx.api
+    return cast(TypeChecker, ctx.api)
 
 
 def is_model_subclass_info(info: TypeInfo, django_context: 'DjangoContext') -> bool:
-    return (info.fullname in django_context.all_registered_model_class_fullnames
+    return (info.fullname() in django_context.model_base_classes
             or info.has_base(fullnames.MODEL_CLASS_FULLNAME))
-
-
-def check_types_compatible(ctx: Union[FunctionContext, MethodContext],
-                           *, expected_type: MypyType, actual_type: MypyType, error_message: str) -> None:
-    api = get_typechecker_api(ctx)
-    api.check_subtype(actual_type, expected_type,
-                      ctx.context, error_message,
-                      'got', 'expected')
-
-
-def add_new_sym_for_info(info: TypeInfo, *, name: str, sym_type: MypyType) -> None:
-    # type=: type of the variable itself
-    var = Var(name=name, type=sym_type)
-    # var.info: type of the object variable is bound to
-    var.info = info
-    var._fullname = info.fullname + '.' + name
-    var.is_initialized_in_class = True
-    var.is_inferred = True
-    info.names[name] = SymbolTableNode(MDEF, var,
-                                       plugin_generated=True)
-
-
-def _prepare_new_method_arguments(node: FuncDef) -> Tuple[List[Argument], MypyType]:
-    arguments = []
-    for argument in node.arguments[1:]:
-        if argument.type_annotation is None:
-            argument.type_annotation = AnyType(TypeOfAny.unannotated)
-        arguments.append(argument)
-
-    if isinstance(node.type, CallableType):
-        return_type = node.type.ret_type
-    else:
-        return_type = AnyType(TypeOfAny.unannotated)
-
-    return arguments, return_type
-
-
-def copy_method_to_another_class(ctx: ClassDefContext, self_type: Instance,
-                                 new_method_name: str, method_node: FuncDef) -> None:
-    arguments, return_type = _prepare_new_method_arguments(method_node)
-
-    semanal_api = get_semanal_api(ctx)
-    for argument in arguments:
-        if argument.type_annotation is not None:
-            argument.type_annotation = semanal_api.anal_type(argument.type_annotation)
-    if return_type is not None:
-        return_type = semanal_api.anal_type(return_type) or AnyType(TypeOfAny.unannotated)
-
-    add_method(ctx,
-               new_method_name,
-               args=arguments,
-               return_type=return_type,
-               self_type=self_type)

mypy_django_plugin/main.py

@@ -7,19 +7,15 @@ from mypy.errors import Errors
 from mypy.nodes import MypyFile, TypeInfo
 from mypy.options import Options
 from mypy.plugin import (
-    AttributeContext, ClassDefContext, DynamicClassDefContext, FunctionContext, MethodContext, Plugin,
+    AttributeContext, ClassDefContext, FunctionContext, MethodContext, Plugin,
 )
 from mypy.types import Type as MypyType
 
-import mypy_django_plugin.transformers.orm_lookups
 from mypy_django_plugin.django.context import DjangoContext
 from mypy_django_plugin.lib import fullnames, helpers
 from mypy_django_plugin.transformers import (
     fields, forms, init_create, meta, querysets, request, settings,
 )
-from mypy_django_plugin.transformers.managers import (
-    create_new_manager_class_from_from_queryset_method,
-)
 from mypy_django_plugin.transformers.models import process_model_class
 
 
@@ -124,17 +120,17 @@ class NewSemanalDjangoPlugin(Plugin):
 
     def get_additional_deps(self, file: MypyFile) -> List[Tuple[int, str, int]]:
         # for settings
-        if file.fullname == 'django.conf' and self.django_context.django_settings_module:
+        if file.fullname() == 'django.conf' and self.django_context.django_settings_module:
             return [self._new_dependency(self.django_context.django_settings_module)]
 
         # for values / values_list
-        if file.fullname == 'django.db.models':
+        if file.fullname() == 'django.db.models':
             return [self._new_dependency('mypy_extensions'), self._new_dependency('typing')]
 
         # for `get_user_model()`
         if self.django_context.settings:
-            if (file.fullname == 'django.contrib.auth'
-                    or file.fullname in {'django.http', 'django.http.request'}):
+            if (file.fullname() == 'django.contrib.auth'
+                    or file.fullname() in {'django.http', 'django.http.request'}):
                 auth_user_model_name = self.django_context.settings.AUTH_USER_MODEL
                 try:
                     auth_user_module = self.django_context.apps_registry.get_model(auth_user_model_name).__module__
@@ -144,7 +140,7 @@ class NewSemanalDjangoPlugin(Plugin):
                 return [self._new_dependency(auth_user_module)]
 
         # ensure that all mentioned to='someapp.SomeModel' are loaded with corresponding related Fields
-        defined_model_classes = self.django_context.model_modules.get(file.fullname)
+        defined_model_classes = self.django_context.model_modules.get(file.fullname())
         if not defined_model_classes:
             return []
         deps = set()
@@ -152,17 +148,15 @@ class NewSemanalDjangoPlugin(Plugin):
             # forward relations
             for field in self.django_context.get_model_fields(model_class):
                 if isinstance(field, RelatedField):
-                    related_model_cls = self.django_context.get_field_related_model_cls(field)
-                    if related_model_cls is None:
-                        continue
+                    related_model_cls = self.django_context.fields_context.get_related_model_cls(field)
                     related_model_module = related_model_cls.__module__
-                    if related_model_module != file.fullname:
+                    if related_model_module != file.fullname():
                         deps.add(self._new_dependency(related_model_module))
             # reverse relations
             for relation in model_class._meta.related_objects:
-                related_model_cls = self.django_context.get_field_related_model_cls(relation)
+                related_model_cls = self.django_context.fields_context.get_related_model_cls(relation)
                 related_model_module = related_model_cls.__module__
-                if related_model_module != file.fullname:
+                if related_model_module != file.fullname():
                     deps.add(self._new_dependency(related_model_module))
         return list(deps)
 
@@ -216,13 +210,12 @@ class NewSemanalDjangoPlugin(Plugin):
         if class_fullname in manager_classes and method_name == 'create':
             return partial(init_create.redefine_and_typecheck_model_create, django_context=self.django_context)
         if class_fullname in manager_classes and method_name in {'filter', 'get', 'exclude'}:
-            return partial(mypy_django_plugin.transformers.orm_lookups.typecheck_queryset_filter,
-                           django_context=self.django_context)
+            return partial(init_create.typecheck_queryset_filter, django_context=self.django_context)
         return None
 
     def get_base_class_hook(self, fullname: str
                             ) -> Optional[Callable[[ClassDefContext], None]]:
-        if (fullname in self.django_context.all_registered_model_class_fullnames
+        if (fullname in self.django_context.model_base_classes
                 or fullname in self._get_current_model_bases()):
             return partial(transform_model_class, django_context=self.django_context)
 
@@ -245,15 +238,6 @@ class NewSemanalDjangoPlugin(Plugin):
             return partial(request.set_auth_user_model_as_type_for_request_user, django_context=self.django_context)
         return None
 
-    def get_dynamic_class_hook(self, fullname: str
-                               ) -> Optional[Callable[[DynamicClassDefContext], None]]:
-        if fullname.endswith('from_queryset'):
-            class_name, _, _ = fullname.rpartition('.')
-            info = self._get_typeinfo_or_none(class_name)
-            if info and info.has_base(fullnames.BASE_MANAGER_CLASS_FULLNAME):
-                return create_new_manager_class_from_from_queryset_method
-        return None
-
 
 def plugin(version):
     return NewSemanalDjangoPlugin