add django.tasks, django.utils.csp, update models.constraints

django-stubs/contrib/admin/tests.pyi

@@ -1,25 +1,27 @@
 from collections.abc import Callable
+from contextlib import AbstractContextManager
 from typing import Any
 
 from django.contrib.staticfiles.testing import StaticLiveServerTestCase
 from django.test.selenium import SeleniumTestCase
-from django.utils.deprecation import MiddlewareMixin
+from django.utils.csp import CSP as CSP
 from django.utils.functional import _StrOrPromise
 
-class CSPMiddleware(MiddlewareMixin): ...
-
 class AdminSeleniumTestCase(SeleniumTestCase, StaticLiveServerTestCase):
-    def wait_until(self, callback: Callable[..., Any], timeout: int = ...) -> None: ...
-    def wait_for_popup(self, num_windows: int = ..., timeout: int = ...) -> None: ...
-    def wait_for(self, css_selector: str, timeout: int = ...) -> None: ...
-    def wait_for_text(self, css_selector: str, text: str, timeout: int = ...) -> None: ...
-    def wait_for_value(self, css_selector: str, text: str, timeout: int = ...) -> None: ...
-    def wait_until_visible(self, css_selector: str, timeout: int = ...) -> None: ...
-    def wait_until_invisible(self, css_selector: str, timeout: int = ...) -> None: ...
-    def wait_page_loaded(self) -> None: ...
-    def admin_login(self, username: str, password: str, login_url: _StrOrPromise = ...) -> None: ...
-    def get_css_value(self, selector: str, attribute: str) -> Any: ...
-    def get_select_option(self, selector: str, value: Any) -> Any: ...
+    def wait_until(self, callback: Callable[..., Any], timeout: int = 10) -> None: ...
+    def wait_for_and_switch_to_popup(self, num_windows: int = 2, timeout: int = 10) -> None: ...
+    def wait_for(self, css_selector: str, timeout: int = 10) -> None: ...
+    def wait_for_text(self, css_selector: str, text: str, timeout: int = 10) -> None: ...
+    def wait_for_value(self, css_selector: str, text: str, timeout: int = 10) -> None: ...
+    def wait_until_visible(self, css_selector: str, timeout: int = 10) -> None: ...
+    def wait_until_invisible(self, css_selector: str, timeout: int = 10) -> None: ...
+    def wait_page_ready(self, timeout: int = 10) -> None: ...
+    def wait_page_loaded(self, timeout: int = 10) -> AbstractContextManager[None]: ...
+    def trigger_resize(self) -> None: ...
+    def admin_login(self, username: str, password: str, login_url: _StrOrPromise = "/admin/") -> None: ...
+    def select_option(self, selector: str, value: Any) -> None: ...
+    def deselect_option(self, selector: str, value: Any) -> None: ...
+    def assertCountSeleniumElements(self, selector: str, count: int, root_element: Any = None) -> None: ...
     def assertSelectOptions(self, selector: str, values: Any) -> None: ...
     def assertSelectedOptions(self, selector: str, values: Any) -> None: ...
-    def has_css_class(self, selector: str, klass: str) -> bool: ...
+    def is_disabled(self, selector: str) -> bool: ...

django-stubs/db/models/constraints.pyi

@@ -2,68 +2,62 @@ from collections.abc import Sequence
 from enum import Enum
 from typing import Any, cast, overload
 
+from django.core.checks import CheckMessage
+from django.db.backends.base.base import BaseDatabaseWrapper
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
 from django.db.models.base import Model
 from django.db.models.expressions import BaseExpression, Combinable
 from django.db.models.query_utils import Q
 from django.utils.functional import _StrOrPromise
-from typing_extensions import Self, deprecated
+from typing_extensions import Self, override
 
 class Deferrable(Enum):
     DEFERRED = cast(str, ...)
     IMMEDIATE = cast(str, ...)
 
 class BaseConstraint:
     name: str
+    violation_error_code: str | None
+    violation_error_message: _StrOrPromise | None
+    default_violation_error_message: _StrOrPromise
+    non_db_attrs: tuple[str, ...]
     def __init__(
         self,
-        *args: BaseExpression | Combinable | str,
-        name: str | None = ...,
-        violation_error_message: _StrOrPromise | None = ...,
+        *,
+        name: str,
+        violation_error_code: str | None = None,
+        violation_error_message: _StrOrPromise | None = None,
     ) -> None: ...
-    def constraint_sql(
-        self,
-        model: type[Model] | None,
-        schema_editor: BaseDatabaseSchemaEditor | None,
-    ) -> str: ...
-    def create_sql(
-        self,
-        model: type[Model] | None,
-        schema_editor: BaseDatabaseSchemaEditor | None,
-    ) -> str: ...
-    def remove_sql(
-        self,
-        model: type[Model] | None,
-        schema_editor: BaseDatabaseSchemaEditor | None,
-    ) -> str: ...
-    def deconstruct(self) -> Any: ...
+    @property
+    def contains_expressions(self) -> bool: ...
+    def constraint_sql(self, model: type[Model] | None, schema_editor: BaseDatabaseSchemaEditor | None) -> str: ...
+    def create_sql(self, model: type[Model] | None, schema_editor: BaseDatabaseSchemaEditor | None) -> str: ...
+    def remove_sql(self, model: type[Model] | None, schema_editor: BaseDatabaseSchemaEditor | None) -> str: ...
+    def validate(
+        self, model: type[Model], instance: Model, exclude: set[str] | None = None, using: str = "default"
+    ) -> None: ...
+    def get_violation_error_message(self) -> _StrOrPromise | dict[str, Any]: ...
+    def check(self, model: type[Model], connection: BaseDatabaseWrapper) -> list[CheckMessage]: ...
+    def deconstruct(self) -> tuple[str, Sequence[Any], dict[str, Any]]: ...
     def clone(self) -> Self: ...
 
 class CheckConstraint(BaseConstraint):
-    check: Q | BaseExpression
     condition: Q | BaseExpression
 
-    @overload
-    @deprecated("check keyword argument is deprecated in favor of condition and will be removed in Django 6.0")
-    def __init__(
-        self,
-        *,
-        name: str,
-        condition: None = None,
-        check: Q | BaseExpression,
-        violation_error_code: str | None = None,
-        violation_error_message: _StrOrPromise | None = None,
-    ) -> None: ...
-    @overload
     def __init__(
         self,
         *,
         name: str,
         condition: Q | BaseExpression,
-        check: None = None,
         violation_error_code: str | None = None,
         violation_error_message: _StrOrPromise | None = None,
     ) -> None: ...
+    @override
+    def check(self, model: type[Model], connection: BaseDatabaseWrapper) -> list[CheckMessage]: ...
+    @override
+    def validate(
+        self, model: type[Model], instance: Model, exclude: set[str] | None = None, using: str = "default"
+    ) -> None: ...
 
 class UniqueConstraint(BaseConstraint):
     expressions: Sequence[BaseExpression | Combinable]
@@ -100,3 +94,14 @@ class UniqueConstraint(BaseConstraint):
         violation_error_code: str | None = None,
         violation_error_message: _StrOrPromise | None = None,
     ) -> None: ...
+    @property
+    @override
+    def contains_expressions(self) -> bool: ...
+    @override
+    def check(self, model: type[Model], connection: BaseDatabaseWrapper) -> list[CheckMessage]: ...
+    @override
+    def validate(
+        self, model: type[Model], instance: Model, exclude: set[str] | None = None, using: str = "default"
+    ) -> None: ...
+
+__all__ = ["BaseConstraint", "CheckConstraint", "Deferrable", "UniqueConstraint"]

django-stubs/db/utils.pyi

@@ -1,16 +1,13 @@
 from collections.abc import Callable, Iterable
 from types import TracebackType
-from typing import Any, ParamSpec, TypeVar
-from typing import Any as Incomplete
+from typing import Any
 
 from django.apps import AppConfig
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.db.models import Model
 from django.utils.connection import BaseConnectionHandler
-from django.utils.connection import ConnectionDoesNotExist as ConnectionDoesNotExist
-
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
+from django.utils.functional import cached_property
+from typing_extensions import TypeVar, override
 
 DEFAULT_DB_ALIAS: str
 DJANGO_VERSION_PICKLE_KEY: str
@@ -25,30 +22,33 @@ class InternalError(DatabaseError): ...
 class ProgrammingError(DatabaseError): ...
 class NotSupportedError(DatabaseError): ...
 
+_F = TypeVar("_F", bound=Callable[..., Any])
+
 class DatabaseErrorWrapper:
-    wrapper: Incomplete
-    def __init__(self, wrapper: Incomplete) -> None: ...
+    def __init__(self, wrapper: Any) -> None: ...
+    def __del__(self) -> None: ...
     def __enter__(self) -> None: ...
     def __exit__(
         self,
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
     ) -> None: ...
-    def __call__(self, func: Callable[_P, _R]) -> Callable[_P, _R]: ...
+    def __call__(self, func: _F) -> _F: ...
 
 def load_backend(backend_name: str) -> Any: ...
 
-class ConnectionHandler(BaseConnectionHandler):
-    settings_name: str  # pyright: ignore[reportIncompatibleVariableOverride]
-    def configure_settings(self, databases: dict[str, dict[str, Any]] | None) -> dict[str, dict[str, Any]]: ...
+class ConnectionHandler(BaseConnectionHandler[BaseDatabaseWrapper]):
+    @override
+    def configure_settings(self, databases: dict[str, Any] | None) -> dict[str, Any]: ...
     @property
     def databases(self) -> dict[str, dict[str, Any]]: ...
+    @override
     def create_connection(self, alias: str) -> BaseDatabaseWrapper: ...
 
 class ConnectionRouter:
     def __init__(self, routers: Iterable[Any] | None = None) -> None: ...
-    @property
+    @cached_property
     def routers(self) -> list[Any]: ...
     def db_for_read(self, model: type[Model], **hints: Any) -> str: ...
     def db_for_write(self, model: type[Model], **hints: Any) -> str: ...

django-stubs/middleware/csp.pyi

@@ -0,0 +1,10 @@
+from django.http import HttpRequest, HttpResponse
+from django.utils.csp import CSP as CSP
+from django.utils.csp import LazyNonce
+from django.utils.deprecation import MiddlewareMixin
+
+def get_nonce(request: HttpRequest) -> LazyNonce | None: ...
+
+class ContentSecurityPolicyMiddleware(MiddlewareMixin):
+    def process_request(self, request: HttpRequest) -> None: ...
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ...

django-stubs/tasks/__init__.pyi

@@ -0,0 +1,28 @@
+from django.utils.connection import BaseConnectionHandler
+
+from .backends.base import BaseTaskBackend
+from .base import DEFAULT_TASK_BACKEND_ALIAS as DEFAULT_TASK_BACKEND_ALIAS
+from .base import DEFAULT_TASK_QUEUE_NAME as DEFAULT_TASK_QUEUE_NAME
+from .base import Task as Task
+from .base import TaskContext as TaskContext
+from .base import TaskResult as TaskResult
+from .base import TaskResultStatus as TaskResultStatus
+from .base import task as task
+
+__all__ = [
+    "DEFAULT_TASK_BACKEND_ALIAS",
+    "DEFAULT_TASK_QUEUE_NAME",
+    "Task",
+    "TaskContext",
+    "TaskResult",
+    "TaskResultStatus",
+    "default_task_backend",
+    "task",
+    "task_backends",
+]
+
+class TaskBackendHandler(BaseConnectionHandler[BaseTaskBackend]): ...
+
+task_backends: TaskBackendHandler
+# Actually ConnectionProxy, but quacks exactly like BaseTaskBackend, it's not worth distinguishing the two.
+default_task_backend: BaseTaskBackend

django-stubs/tasks/backends/base.pyi

@@ -0,0 +1,22 @@
+from abc import ABCMeta, abstractmethod
+from typing import Any
+
+from django.tasks.base import Task, TaskResult
+
+class BaseTaskBackend(metaclass=ABCMeta):
+    task_class: type[Task]
+    supports_defer: bool
+    supports_async_task: bool
+    supports_get_result: bool
+    supports_priority: bool
+    alias: str
+    queues: list[str]
+    options: dict[str, Any]
+    def __init__(self, alias: str, params: dict[str, Any]) -> None: ...
+    def validate_task(self, task: Task) -> None: ...
+    @abstractmethod
+    def enqueue(self, task: Task, args: list[Any], kwargs: dict[str, Any]) -> TaskResult: ...
+    async def aenqueue(self, task: Task, args: list[Any], kwargs: dict[str, Any]) -> TaskResult: ...
+    def get_result(self, result_id: str) -> TaskResult: ...
+    async def aget_result(self, result_id: str) -> TaskResult: ...
+    def check(self, **kwargs: Any) -> list[Any]: ...

django-stubs/tasks/backends/dummy.pyi

@@ -0,0 +1,17 @@
+from typing import Any
+
+from django.tasks.base import Task, TaskResult
+from typing_extensions import override
+
+from .base import BaseTaskBackend
+
+class DummyBackend(BaseTaskBackend):
+    results: list[TaskResult]
+    def __init__(self, alias: str, params: dict[str, Any]) -> None: ...
+    @override
+    def enqueue(self, task: Task, args: list[Any], kwargs: dict[str, Any]) -> TaskResult: ...
+    @override
+    def get_result(self, result_id: str) -> TaskResult: ...
+    @override
+    async def aget_result(self, result_id: str) -> TaskResult: ...
+    def clear(self) -> None: ...

django-stubs/tasks/backends/immediate.pyi

@@ -0,0 +1,15 @@
+from logging import Logger
+from typing import Any
+
+from django.tasks.base import Task, TaskResult
+from typing_extensions import override
+
+from .base import BaseTaskBackend
+
+logger: Logger
+
+class ImmediateBackend(BaseTaskBackend):
+    worker_id: str
+    def __init__(self, alias: str, params: dict[str, Any]) -> None: ...
+    @override
+    def enqueue(self, task: Task, args: list[Any], kwargs: dict[str, Any]) -> TaskResult: ...