move generated stubs to separate directory, too messty

django-stubs-generated/contrib/auth/__init__.pyi

@@ -0,0 +1,38 @@
+from typing import Any, List, Optional, Type, Union
+
+from django.contrib.auth.backends import ModelBackend
+from django.contrib.auth.base_user import AbstractBaseUser
+from django.contrib.auth.models import AbstractUser, AnonymousUser
+from django.core.handlers.wsgi import WSGIRequest
+from django.db.models.base import Model
+from django.db.models.options import Options
+from django.http.request import HttpRequest
+
+from .signals import user_logged_in, user_logged_out, user_login_failed
+
+SESSION_KEY: str
+BACKEND_SESSION_KEY: str
+HASH_SESSION_KEY: str
+REDIRECT_FIELD_NAME: str
+
+def load_backend(path: str) -> ModelBackend: ...
+def get_backends() -> List[ModelBackend]: ...
+def authenticate(
+    request: Any = ..., **credentials: Any
+) -> Optional[AbstractBaseUser]: ...
+def login(
+    request: HttpRequest,
+    user: AbstractBaseUser,
+    backend: Optional[Union[Type[ModelBackend], str]] = ...,
+) -> None: ...
+def logout(request: HttpRequest) -> None: ...
+def get_user_model() -> Type[Model]: ...
+def get_user(
+    request: HttpRequest
+) -> Union[AbstractBaseUser, AnonymousUser]: ...
+def get_permission_codename(action: str, opts: Options) -> str: ...
+def update_session_auth_hash(
+    request: WSGIRequest, user: AbstractUser
+) -> None: ...
+
+default_app_config: str

django-stubs-generated/contrib/auth/admin.pyi

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

django-stubs-generated/contrib/auth/apps.pyi

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

django-stubs-generated/contrib/auth/backends.pyi

@@ -0,0 +1,52 @@
+from typing import Any, Optional, Set, Union
+
+from django.contrib.auth.base_user import AbstractBaseUser
+from django.contrib.auth.models import AnonymousUser, User
+from django.core.handlers.wsgi import WSGIRequest
+
+UserModel: Any
+
+class ModelBackend:
+    def authenticate(
+        self,
+        request: Any,
+        username: Optional[Union[int, str]] = ...,
+        password: Optional[str] = ...,
+        **kwargs: Any
+    ) -> Optional[AbstractBaseUser]: ...
+    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):
+    def user_can_authenticate(self, user: AbstractBaseUser) -> bool: ...
+
+class RemoteUserBackend(ModelBackend):
+    create_unknown_user: bool = ...
+    def authenticate(
+        self, request: WSGIRequest, remote_user: Optional[str]
+    ) -> Optional[User]: ...
+    def clean_username(self, username: str) -> str: ...
+    def configure_user(self, user: User) -> User: ...
+
+class AllowAllUsersRemoteUserBackend(RemoteUserBackend):
+    def user_can_authenticate(self, user: User) -> bool: ...

django-stubs-generated/contrib/auth/base_user.pyi

@@ -0,0 +1,44 @@
+from typing import Any, Optional, Tuple, Union
+
+from django.db import models
+
+
+class BaseUserManager(models.Manager):
+    creation_counter: int
+    model: None
+    name: None
+    @classmethod
+    def normalize_email(cls, email: Optional[str]) -> str: ...
+    def make_random_password(
+        self, length: int = ..., allowed_chars: str = ...
+    ) -> str: ...
+    def get_by_natural_key(
+        self, username: Optional[str]
+    ) -> AbstractBaseUser: ...
+
+class AbstractBaseUser(models.Model):
+    password: str = ...
+    last_login: None = ...
+    is_active: bool = ...
+    REQUIRED_FIELDS: Any = ...
+    class Meta:
+        abstract: bool = ...
+    def get_username(self) -> str: ...
+    def clean(self) -> None: ...
+    def save(self, *args: Any, **kwargs: Any) -> None: ...
+    def natural_key(self) -> Tuple[str]: ...
+    @property
+    def is_anonymous(self) -> bool: ...
+    @property
+    def is_authenticated(self) -> bool: ...
+    def set_password(self, raw_password: Optional[str]) -> None: ...
+    def check_password(self, raw_password: str) -> bool: ...
+    def set_unusable_password(self) -> None: ...
+    def has_usable_password(self) -> bool: ...
+    def get_session_auth_hash(self) -> str: ...
+    @classmethod
+    def get_email_field_name(cls) -> str: ...
+    @classmethod
+    def normalize_username(
+        cls, username: Union[int, str]
+    ) -> Union[int, str]: ...

django-stubs-generated/contrib/auth/checks.pyi

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

django-stubs-generated/contrib/auth/context_processors.pyi

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

django-stubs-generated/contrib/auth/decorators.pyi

@@ -0,0 +1,18 @@
+from typing import Any, Callable, List, Optional, Set, Union
+
+
+def user_passes_test(
+    test_func: Callable,
+    login_url: Optional[str] = ...,
+    redirect_field_name: str = ...,
+) -> Callable: ...
+def login_required(
+    function: Optional[Callable] = ...,
+    redirect_field_name: str = ...,
+    login_url: Optional[str] = ...,
+) -> Callable: ...
+def permission_required(
+    perm: Union[List[str], Set[str], str],
+    login_url: None = ...,
+    raise_exception: bool = ...,
+) -> Callable: ...

django-stubs-generated/contrib/auth/forms.pyi

@@ -0,0 +1,190 @@
+from typing import Any, Dict, Iterator, List, Optional, Union
+
+from django import forms
+from django.contrib.auth.base_user import AbstractBaseUser
+from django.contrib.auth.models import AbstractUser, User
+from django.contrib.auth.tokens import PasswordResetTokenGenerator
+from django.core.exceptions import ValidationError
+from django.core.handlers.wsgi import WSGIRequest
+
+UserModel: Any
+
+class ReadOnlyPasswordHashWidget(forms.Widget):
+    attrs: Dict[Any, Any]
+    template_name: str = ...
+    def get_context(
+        self, name: str, value: Optional[str], attrs: Dict[str, str]
+    ) -> Dict[
+        str,
+        Union[
+            Dict[str, Optional[Union[Dict[str, str], bool, str]]],
+            List[Dict[str, str]],
+        ],
+    ]: ...
+
+class ReadOnlyPasswordHashField(forms.Field):
+    widget: Any = ...
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def bound_data(self, data: None, initial: str) -> str: ...
+    def has_changed(self, initial: str, data: Optional[str]) -> bool: ...
+
+class UsernameField(forms.CharField):
+    def to_python(self, value: Optional[str]) -> str: ...
+
+class UserCreationForm(forms.ModelForm):
+    auto_id: str
+    data: Dict[str, str]
+    empty_permitted: bool
+    error_class: Type[django.forms.utils.ErrorList]
+    fields: collections.OrderedDict
+    files: Dict[Any, Any]
+    initial: Dict[Any, Any]
+    instance: django.contrib.auth.models.User
+    is_bound: bool
+    label_suffix: str
+    error_messages: Any = ...
+    password1: Any = ...
+    password2: Any = ...
+    class Meta:
+        model: Any = ...
+        fields: Any = ...
+        field_classes: Any = ...
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def clean_password2(self) -> str: ...
+    def save(self, commit: bool = ...) -> User: ...
+
+class UserChangeForm(forms.ModelForm):
+    auto_id: str
+    data: Dict[Any, Any]
+    empty_permitted: bool
+    error_class: Type[django.forms.utils.ErrorList]
+    fields: collections.OrderedDict
+    files: Dict[Any, Any]
+    initial: Dict[str, Optional[Union[List[Any], datetime.datetime, int, str]]]
+    instance: django.contrib.auth.models.User
+    is_bound: bool
+    label_suffix: str
+    password: Any = ...
+    class Meta:
+        model: Any = ...
+        fields: str = ...
+        field_classes: Any = ...
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def clean_password(self) -> str: ...
+
+class AuthenticationForm(forms.Form):
+    auto_id: str
+    data: django.http.request.QueryDict
+    empty_permitted: bool
+    error_class: Type[django.forms.utils.ErrorList]
+    fields: collections.OrderedDict
+    files: django.utils.datastructures.MultiValueDict
+    initial: Dict[Any, Any]
+    is_bound: bool
+    label_suffix: str
+    username: Any = ...
+    password: Any = ...
+    error_messages: Any = ...
+    request: django.core.handlers.wsgi.WSGIRequest = ...
+    user_cache: None = ...
+    username_field: Any = ...
+    def __init__(
+        self, request: Any = ..., *args: Any, **kwargs: Any
+    ) -> None: ...
+    def clean(self) -> Dict[str, str]: ...
+    def confirm_login_allowed(self, user: AbstractBaseUser) -> None: ...
+    def get_user(self) -> User: ...
+    def get_invalid_login_error(self) -> ValidationError: ...
+
+class PasswordResetForm(forms.Form):
+    auto_id: str
+    data: Dict[Any, Any]
+    empty_permitted: bool
+    error_class: Type[django.forms.utils.ErrorList]
+    fields: collections.OrderedDict
+    files: Dict[Any, Any]
+    initial: Dict[Any, Any]
+    is_bound: bool
+    label_suffix: str
+    email: Any = ...
+    def send_mail(
+        self,
+        subject_template_name: str,
+        email_template_name: str,
+        context: Dict[str, Union[AbstractBaseUser, str]],
+        from_email: Optional[str],
+        to_email: str,
+        html_email_template_name: Optional[str] = ...,
+    ) -> None: ...
+    def get_users(self, email: str) -> Iterator[Any]: ...
+    def save(
+        self,
+        domain_override: Optional[str] = ...,
+        subject_template_name: str = ...,
+        email_template_name: str = ...,
+        use_https: bool = ...,
+        token_generator: PasswordResetTokenGenerator = ...,
+        from_email: Optional[str] = ...,
+        request: Optional[WSGIRequest] = ...,
+        html_email_template_name: Optional[str] = ...,
+        extra_email_context: Optional[Dict[str, str]] = ...,
+    ) -> None: ...
+
+class SetPasswordForm(forms.Form):
+    auto_id: str
+    data: Dict[Any, Any]
+    empty_permitted: bool
+    error_class: Type[django.forms.utils.ErrorList]
+    fields: collections.OrderedDict
+    files: Dict[Any, Any]
+    initial: Dict[Any, Any]
+    is_bound: bool
+    label_suffix: str
+    error_messages: Any = ...
+    new_password1: Any = ...
+    new_password2: Any = ...
+    user: django.contrib.auth.models.User = ...
+    def __init__(
+        self, user: Optional[AbstractBaseUser], *args: Any, **kwargs: Any
+    ) -> None: ...
+    def clean_new_password2(self) -> str: ...
+    def save(self, commit: bool = ...) -> AbstractBaseUser: ...
+
+class PasswordChangeForm(SetPasswordForm):
+    auto_id: str
+    data: Dict[Any, Any]
+    empty_permitted: bool
+    error_class: Type[django.forms.utils.ErrorList]
+    fields: collections.OrderedDict
+    files: Dict[Any, Any]
+    initial: Dict[Any, Any]
+    is_bound: bool
+    label_suffix: str
+    user: django.contrib.auth.models.User
+    error_messages: Any = ...
+    old_password: Any = ...
+    field_order: Any = ...
+    def clean_old_password(self) -> str: ...
+
+class AdminPasswordChangeForm(forms.Form):
+    auto_id: str
+    data: Dict[Any, Any]
+    empty_permitted: bool
+    error_class: Type[django.forms.utils.ErrorList]
+    fields: collections.OrderedDict
+    files: Dict[Any, Any]
+    initial: Dict[Any, Any]
+    is_bound: bool
+    label_suffix: str
+    error_messages: Any = ...
+    required_css_class: str = ...
+    password1: Any = ...
+    password2: Any = ...
+    user: django.contrib.auth.models.User = ...
+    def __init__(
+        self, user: AbstractUser, *args: Any, **kwargs: Any
+    ) -> None: ...
+    def clean_password2(self) -> str: ...
+    def save(self, commit: bool = ...) -> AbstractUser: ...
+    @property
+    def changed_data(self) -> List[str]: ...

django-stubs-generated/contrib/auth/handlers/modwsgi.pyi

@@ -0,0 +1,8 @@
+from typing import Any, Dict, Optional
+
+UserModel: Any
+
+def check_password(
+    environ: Dict[Any, Any], username: str, password: str
+) -> Any: ...
+def groups_for_user(environ: Dict[Any, Any], username: str) -> Any: ...

django-stubs-generated/contrib/auth/hashers.pyi

@@ -0,0 +1,115 @@
+from collections import OrderedDict
+from typing import Any, Callable, Dict, List, Optional
+
+UNUSABLE_PASSWORD_PREFIX: str
+UNUSABLE_PASSWORD_SUFFIX_LENGTH: int
+
+def is_password_usable(encoded: Optional[str]) -> bool: ...
+def check_password(
+    password: Optional[str],
+    encoded: str,
+    setter: Optional[Callable] = ...,
+    preferred: str = ...,
+) -> bool: ...
+def make_password(
+    password: Optional[str], salt: Optional[str] = ..., hasher: str = ...
+) -> str: ...
+def get_hashers() -> List[BasePasswordHasher]: ...
+def get_hashers_by_algorithm() -> Dict[str, BasePasswordHasher]: ...
+def reset_hashers(**kwargs: Any) -> None: ...
+def get_hasher(algorithm: str = ...) -> BasePasswordHasher: ...
+def identify_hasher(encoded: str) -> BasePasswordHasher: ...
+def mask_hash(hash: str, show: int = ..., char: str = ...) -> str: ...
+
+class BasePasswordHasher:
+    algorithm: Any = ...
+    library: Any = ...
+    def salt(self) -> str: ...
+    def verify(self, password: str, encoded: str) -> Any: ...
+    def encode(self, password: str, salt: str) -> Any: ...
+    def safe_summary(self, encoded: str) -> Any: ...
+    def must_update(self, encoded: str) -> bool: ...
+    def harden_runtime(self, password: str, encoded: str) -> None: ...
+
+class PBKDF2PasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    iterations: int = ...
+    digest: Any = ...
+    def encode(
+        self, password: str, salt: str, iterations: Optional[int] = ...
+    ) -> str: ...
+    def verify(self, password: str, encoded: str) -> bool: ...
+    def safe_summary(self, encoded: str) -> OrderedDict: ...
+    def must_update(self, encoded: str) -> bool: ...
+    def harden_runtime(self, password: str, encoded: str) -> None: ...
+
+class PBKDF2SHA1PasswordHasher(PBKDF2PasswordHasher):
+    algorithm: str = ...
+    digest: Any = ...
+
+class Argon2PasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    library: str = ...
+    time_cost: int = ...
+    memory_cost: int = ...
+    parallelism: int = ...
+    def encode(self, password: Any, salt: Any): ...
+    def verify(self, password: Any, encoded: Any): ...
+    def safe_summary(self, encoded: Any): ...
+    def must_update(self, encoded: Any): ...
+    def harden_runtime(self, password: Any, encoded: Any) -> None: ...
+
+class BCryptSHA256PasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    digest: Any = ...
+    library: Any = ...
+    rounds: int = ...
+    def salt(self): ...
+    def encode(self, password: Any, salt: Any): ...
+    def verify(self, password: Any, encoded: Any): ...
+    def safe_summary(self, encoded: Any): ...
+    def must_update(self, encoded: Any): ...
+    def harden_runtime(self, password: Any, encoded: Any) -> None: ...
+
+class BCryptPasswordHasher(BCryptSHA256PasswordHasher):
+    algorithm: str = ...
+    digest: Any = ...
+
+class SHA1PasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    def encode(self, password: str, salt: str) -> str: ...
+    def verify(self, password: str, encoded: str) -> bool: ...
+    def safe_summary(self, encoded: Any): ...
+    def harden_runtime(self, password: Any, encoded: Any) -> None: ...
+
+class MD5PasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    def encode(self, password: str, salt: str) -> str: ...
+    def verify(self, password: str, encoded: str) -> bool: ...
+    def safe_summary(self, encoded: str) -> OrderedDict: ...
+    def harden_runtime(self, password: Any, encoded: Any) -> None: ...
+
+class UnsaltedSHA1PasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    def salt(self) -> str: ...
+    def encode(self, password: str, salt: str) -> str: ...
+    def verify(self, password: str, encoded: str) -> bool: ...
+    def safe_summary(self, encoded: Any): ...
+    def harden_runtime(self, password: Any, encoded: Any) -> None: ...
+
+class UnsaltedMD5PasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    def salt(self) -> str: ...
+    def encode(self, password: str, salt: str) -> str: ...
+    def verify(self, password: str, encoded: str) -> bool: ...
+    def safe_summary(self, encoded: Any): ...
+    def harden_runtime(self, password: Any, encoded: Any) -> None: ...
+
+class CryptPasswordHasher(BasePasswordHasher):
+    algorithm: str = ...
+    library: str = ...
+    def salt(self): ...
+    def encode(self, password: Any, salt: Any): ...
+    def verify(self, password: Any, encoded: Any): ...
+    def safe_summary(self, encoded: Any): ...
+    def harden_runtime(self, password: Any, encoded: Any) -> None: ...

django-stubs-generated/contrib/auth/management/__init__.pyi

@@ -0,0 +1,16 @@
+from typing import Any, Optional
+
+from django.apps.config import AppConfig
+from django.apps.registry import Apps
+
+
+def create_permissions(
+    app_config: AppConfig,
+    verbosity: int = ...,
+    interactive: bool = ...,
+    using: str = ...,
+    apps: Apps = ...,
+    **kwargs: Any
+) -> None: ...
+def get_system_username() -> str: ...
+def get_default_username(check_db: bool = ...) -> str: ...

django-stubs-generated/contrib/auth/management/commands/changepassword.pyi

@@ -0,0 +1,15 @@
+from typing import Any, Optional
+
+from django.core.management.base import BaseCommand, CommandParser
+
+UserModel: Any
+
+class Command(BaseCommand):
+    stderr: django.core.management.base.OutputWrapper
+    stdout: django.core.management.base.OutputWrapper
+    style: django.core.management.color.Style
+    help: str = ...
+    requires_migrations_checks: bool = ...
+    requires_system_checks: bool = ...
+    def add_arguments(self, parser: CommandParser) -> None: ...
+    def handle(self, *args: Any, **options: Any) -> str: ...

django-stubs-generated/contrib/auth/management/commands/createsuperuser.pyi

@@ -0,0 +1,25 @@
+from typing import Any, Optional, Union
+
+from django.core.management.base import BaseCommand, CommandParser
+from django.db.models.fields import Field
+
+
+class NotRunningInTTYException(Exception): ...
+
+class Command(BaseCommand):
+    stderr: django.core.management.base.OutputWrapper
+    stdout: django.core.management.base.OutputWrapper
+    style: django.core.management.color.Style
+    help: str = ...
+    requires_migrations_checks: bool = ...
+    stealth_options: Any = ...
+    UserModel: Any = ...
+    username_field: Any = ...
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def add_arguments(self, parser: CommandParser) -> None: ...
+    stdin: Any = ...
+    def execute(self, *args: Any, **options: Any) -> None: ...
+    def handle(self, *args: Any, **options: Any) -> None: ...
+    def get_input_data(
+        self, field: Field, message: str, default: Optional[str] = ...
+    ) -> Optional[Union[int, str]]: ...

django-stubs-generated/contrib/auth/middleware.pyi

@@ -0,0 +1,24 @@
+from typing import Any, Optional, Union
+
+from django.contrib.auth.models import AnonymousUser, User
+from django.core.handlers.wsgi import WSGIRequest
+from django.http.request import HttpRequest
+from django.utils.deprecation import MiddlewareMixin
+
+
+def get_user(request: WSGIRequest) -> Union[AnonymousUser, User]: ...
+
+class AuthenticationMiddleware(MiddlewareMixin):
+    get_response: Callable
+    def process_request(self, request: HttpRequest) -> None: ...
+
+class RemoteUserMiddleware(MiddlewareMixin):
+    get_response: Callable
+    header: str = ...
+    force_logout_if_no_header: bool = ...
+    def process_request(self, request: WSGIRequest) -> None: ...
+    def clean_username(self, username: str, request: WSGIRequest) -> str: ...
+
+class PersistentRemoteUserMiddleware(RemoteUserMiddleware):
+    get_response: Callable
+    force_logout_if_no_header: bool = ...

django-stubs-generated/contrib/auth/mixins.pyi

@@ -0,0 +1,35 @@
+from typing import Any, Callable, List, Optional
+
+from django.core.handlers.wsgi import WSGIRequest
+from django.http.response import HttpResponse, HttpResponseRedirect
+
+
+class AccessMixin:
+    login_url: Any = ...
+    permission_denied_message: str = ...
+    raise_exception: bool = ...
+    redirect_field_name: Any = ...
+    def get_login_url(self) -> str: ...
+    def get_permission_denied_message(self) -> str: ...
+    def get_redirect_field_name(self) -> str: ...
+    def handle_no_permission(self) -> HttpResponseRedirect: ...
+
+class LoginRequiredMixin(AccessMixin):
+    def dispatch(
+        self, request: WSGIRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+
+class PermissionRequiredMixin(AccessMixin):
+    permission_required: Any = ...
+    def get_permission_required(self) -> List[str]: ...
+    def has_permission(self) -> bool: ...
+    def dispatch(
+        self, request: WSGIRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+
+class UserPassesTestMixin(AccessMixin):
+    def test_func(self) -> None: ...
+    def get_test_func(self) -> Callable: ...
+    def dispatch(
+        self, request: WSGIRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...

django-stubs-generated/contrib/auth/models.pyi

@@ -0,0 +1,160 @@
+from typing import Any, List, Optional, Set, Tuple, Type, Union
+
+from django.contrib.auth.base_user import AbstractBaseUser, BaseUserManager
+from django.db import models
+from django.db.models.manager import EmptyManager
+
+from .validators import UnicodeUsernameValidator
+
+
+def update_last_login(
+    sender: Type[AbstractBaseUser], user: AbstractBaseUser, **kwargs: Any
+) -> None: ...
+
+class PermissionManager(models.Manager):
+    creation_counter: int
+    model: None
+    name: None
+    use_in_migrations: bool = ...
+    def get_by_natural_key(
+        self, codename: str, app_label: str, model: str
+    ) -> Permission: ...
+
+class Permission(models.Model):
+    content_type_id: int
+    id: int
+    name: str = ...
+    content_type: Any = ...
+    codename: str = ...
+    objects: Any = ...
+    class Meta:
+        verbose_name: Any = ...
+        verbose_name_plural: Any = ...
+        unique_together: Any = ...
+        ordering: Any = ...
+    def natural_key(self) -> Tuple[str, str, str]: ...
+
+class GroupManager(models.Manager):
+    creation_counter: int
+    model: None
+    name: None
+    use_in_migrations: bool = ...
+    def get_by_natural_key(self, name: str) -> Group: ...
+
+class Group(models.Model):
+    id: None
+    name: str = ...
+    permissions: Any = ...
+    objects: Any = ...
+    class Meta:
+        verbose_name: Any = ...
+        verbose_name_plural: Any = ...
+    def natural_key(self): ...
+
+class UserManager(BaseUserManager):
+    creation_counter: int
+    model: None
+    name: None
+    use_in_migrations: bool = ...
+    def create_user(
+        self,
+        username: str,
+        email: Optional[str] = ...,
+        password: Optional[str] = ...,
+        **extra_fields: Any
+    ) -> AbstractUser: ...
+    def create_superuser(
+        self,
+        username: str,
+        email: Optional[str],
+        password: Optional[str],
+        **extra_fields: Any
+    ) -> AbstractBaseUser: ...
+
+class PermissionsMixin(models.Model):
+    is_superuser: Any = ...
+    groups: Any = ...
+    user_permissions: Any = ...
+    class Meta:
+        abstract: bool = ...
+    def get_group_permissions(self, obj: None = ...) -> Set[str]: ...
+    def get_all_permissions(self, obj: Optional[str] = ...) -> Set[str]: ...
+    def has_perm(
+        self, perm: Union[Tuple[str, Any], str], obj: Optional[str] = ...
+    ) -> bool: ...
+    def has_perms(
+        self, perm_list: Union[List[str], Set[str], Tuple[str]], obj: None = ...
+    ) -> bool: ...
+    def has_module_perms(self, app_label: str) -> bool: ...
+
+class AbstractUser(AbstractBaseUser, PermissionsMixin):
+    is_superuser: bool
+    last_login: None
+    password: str
+    username_validator: Any = ...
+    username: str = ...
+    first_name: str = ...
+    last_name: str = ...
+    email: str = ...
+    is_staff: bool = ...
+    is_active: bool = ...
+    date_joined: datetime.datetime = ...
+    objects: Any = ...
+    EMAIL_FIELD: str = ...
+    USERNAME_FIELD: str = ...
+    REQUIRED_FIELDS: Any = ...
+    class Meta:
+        verbose_name: Any = ...
+        verbose_name_plural: Any = ...
+        abstract: bool = ...
+    def clean(self) -> None: ...
+    def get_full_name(self) -> str: ...
+    def get_short_name(self) -> str: ...
+    def email_user(
+        self, subject: str, message: str, from_email: str = ..., **kwargs: Any
+    ) -> None: ...
+
+class User(AbstractUser):
+    date_joined: datetime.datetime
+    email: str
+    first_name: str
+    id: None
+    is_active: bool
+    is_staff: bool
+    is_superuser: bool
+    last_login: None
+    last_name: str
+    password: str
+    username: str
+    class Meta(AbstractUser.Meta):
+        swappable: str = ...
+
+class AnonymousUser:
+    id: Any = ...
+    pk: Any = ...
+    username: str = ...
+    is_staff: bool = ...
+    is_active: bool = ...
+    is_superuser: bool = ...
+    def __eq__(self, other: Union[AnonymousUser, User]) -> bool: ...
+    def __hash__(self) -> int: ...
+    def save(self) -> Any: ...
+    def delete(self) -> Any: ...
+    def set_password(self, raw_password: str) -> Any: ...
+    def check_password(self, raw_password: str) -> Any: ...
+    @property
+    def groups(self) -> EmptyManager: ...
+    @property
+    def user_permissions(self) -> EmptyManager: ...
+    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: Union[List[str], Tuple[str]], obj: None = ...
+    ) -> bool: ...
+    def has_module_perms(self, module: str) -> bool: ...
+    @property
+    def is_anonymous(self) -> bool: ...
+    @property
+    def is_authenticated(self) -> bool: ...
+    def get_username(self) -> str: ...

django-stubs-generated/contrib/auth/password_validation.pyi

@@ -0,0 +1,63 @@
+from pathlib import PosixPath
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from django.contrib.auth.base_user import AbstractBaseUser
+from django.contrib.auth.models import User
+
+
+def get_default_password_validators() -> Union[
+    List[NumericPasswordValidator], List[UserAttributeSimilarityValidator]
+]: ...
+def get_password_validators(
+    validator_config: List[Dict[str, Union[Dict[str, int], str]]]
+) -> Union[
+    List[NumericPasswordValidator], List[UserAttributeSimilarityValidator]
+]: ...
+def validate_password(
+    password: str,
+    user: Optional[AbstractBaseUser] = ...,
+    password_validators: Optional[List[Any]] = ...,
+) -> None: ...
+def password_changed(
+    password: str,
+    user: Optional[AbstractBaseUser] = ...,
+    password_validators: None = ...,
+) -> None: ...
+def password_validators_help_texts(
+    password_validators: Optional[List[Any]] = ...
+) -> List[str]: ...
+
+password_validators_help_text_html: Any
+
+class MinimumLengthValidator:
+    min_length: int = ...
+    def __init__(self, min_length: int = ...) -> None: ...
+    def validate(self, password: str, user: Optional[User] = ...) -> None: ...
+    def get_help_text(self) -> str: ...
+
+class UserAttributeSimilarityValidator:
+    DEFAULT_USER_ATTRIBUTES: Any = ...
+    user_attributes: Tuple[str, str, str, str] = ...
+    max_similarity: float = ...
+    def __init__(
+        self,
+        user_attributes: Union[List[str], Tuple[str, str, str, str]] = ...,
+        max_similarity: float = ...,
+    ) -> None: ...
+    def validate(self, password: str, user: Optional[User] = ...) -> None: ...
+    def get_help_text(self) -> str: ...
+
+class CommonPasswordValidator:
+    DEFAULT_PASSWORD_LIST_PATH: Any = ...
+    passwords: Set[str] = ...
+    def __init__(
+        self, password_list_path: Union[PosixPath, str] = ...
+    ) -> None: ...
+    def validate(self, password: str, user: None = ...) -> None: ...
+    def get_help_text(self) -> str: ...
+
+class NumericPasswordValidator:
+    def validate(
+        self, password: str, user: Optional[AbstractBaseUser] = ...
+    ) -> None: ...
+    def get_help_text(self) -> str: ...

django-stubs-generated/contrib/auth/tokens.pyi

@@ -0,0 +1,14 @@
+from typing import Any, Optional
+
+from django.contrib.auth.base_user import AbstractBaseUser
+
+
+class PasswordResetTokenGenerator:
+    key_salt: str = ...
+    secret: Any = ...
+    def make_token(self, user: AbstractBaseUser) -> str: ...
+    def check_token(
+        self, user: Optional[AbstractBaseUser], token: Optional[str]
+    ) -> bool: ...
+
+default_token_generator: Any

django-stubs-generated/contrib/auth/views.pyi

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