plain.models 0.49.2__py3-none-any.whl → 0.51.0__py3-none-any.whl

plain/models/backends/mysql/schema.py

@@ -1,9 +1,21 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
 from plain.models.constants import LOOKUP_SEP
 from plain.models.constraints import UniqueConstraint
 from plain.models.expressions import F
 from plain.models.fields import NOT_PROVIDED
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from plain.models.base import Model
+    from plain.models.constraints import BaseConstraint
+    from plain.models.fields import Field
+    from plain.models.indexes import Index
+
 
 class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     sql_rename_table = "RENAME TABLE %(old_table)s TO %(new_table)s"
@@ -37,7 +49,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     sql_alter_column_comment = None
 
     @property
-    def sql_delete_check(self):
+    def sql_delete_check(self) -> str:
         if self.connection.mysql_is_mariadb:
             # The name of the column check constraint is the same as the field
             # name on MariaDB. Adding IF EXISTS clause prevents migrations
@@ -46,7 +58,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         return "ALTER TABLE %(table)s DROP CHECK %(name)s"
 
     @property
-    def sql_rename_column(self):
+    def sql_rename_column(self) -> str:
         # MariaDB >= 10.5.2 and MySQL >= 8.0.4 support an
         # "ALTER TABLE ... RENAME COLUMN" statement.
         if self.connection.mysql_is_mariadb:
@@ -56,7 +68,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             return super().sql_rename_column
         return "ALTER TABLE %(table)s CHANGE %(old_column)s %(new_column)s %(type)s"
 
-    def quote_value(self, value):
+    def quote_value(self, value: Any) -> str:
         self.connection.ensure_connection()
         if isinstance(value, str):
             value = value.replace("%", "%%")
@@ -68,19 +80,19 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             quoted = quoted.decode()
         return quoted
 
-    def _is_limited_data_type(self, field):
+    def _is_limited_data_type(self, field: Field) -> bool:
         db_type = field.db_type(self.connection)
         return (
             db_type is not None
             and db_type.lower() in self.connection._limited_data_types
         )
 
-    def skip_default(self, field):
+    def skip_default(self, field: Field) -> bool:
         if not self._supports_limited_data_type_defaults:
             return self._is_limited_data_type(field)
         return False
 
-    def skip_default_on_alter(self, field):
+    def skip_default_on_alter(self, field: Field) -> bool:
         if self._is_limited_data_type(field) and not self.connection.mysql_is_mariadb:
             # MySQL doesn't support defaults for BLOB and TEXT in the
             # ALTER COLUMN statement.
@@ -88,13 +100,13 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         return False
 
     @property
-    def _supports_limited_data_type_defaults(self):
+    def _supports_limited_data_type_defaults(self) -> bool:
         # MariaDB and MySQL >= 8.0.13 support defaults for BLOB and TEXT.
         if self.connection.mysql_is_mariadb:
             return True
         return self.connection.mysql_version >= (8, 0, 13)
 
-    def _column_default_sql(self, field):
+    def _column_default_sql(self, field: Field) -> str:
         if (
             not self.connection.mysql_is_mariadb
             and self._supports_limited_data_type_defaults
@@ -105,7 +117,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             return "(%s)"
         return super()._column_default_sql(field)
 
-    def add_field(self, model, field):
+    def add_field(self, model: type[Model], field: Field) -> None:
         super().add_field(model, field)
 
         # Simulate the effect of a one-off default.
@@ -113,11 +125,11 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         if self.skip_default(field) and field.default not in (None, NOT_PROVIDED):
             effective_default = self.effective_default(field)
             self.execute(
-                f"UPDATE {self.quote_name(model._meta.db_table)} SET {self.quote_name(field.column)} = %s",
+                f"UPDATE {self.quote_name(model.model_options.db_table)} SET {self.quote_name(field.column)} = %s",
                 [effective_default],
             )
 
-    def remove_constraint(self, model, constraint):
+    def remove_constraint(self, model: type[Model], constraint: BaseConstraint) -> None:
         if (
             isinstance(constraint, UniqueConstraint)
             and constraint.create_sql(model, self) is not None
@@ -129,7 +141,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             )
         super().remove_constraint(model, constraint)
 
-    def remove_index(self, model, index):
+    def remove_index(self, model: type[Model], index: Index) -> None:
         self._create_missing_fk_index(
             model,
             fields=[field_name for field_name, _ in index.fields_orders],
@@ -137,12 +149,12 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         )
         super().remove_index(model, index)
 
-    def _field_should_be_indexed(self, model, field):
+    def _field_should_be_indexed(self, model: type[Model], field: Field) -> bool:
         if not super()._field_should_be_indexed(model, field):
             return False
 
         storage = self.connection.introspection.get_storage_engine(
-            self.connection.cursor(), model._meta.db_table
+            self.connection.cursor(), model.model_options.db_table
         )
         # No need to create an index for ForeignKey fields except if
         # db_constraint=False because the index from that constraint won't be
@@ -150,18 +162,18 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         if (
             storage == "InnoDB"
             and field.get_internal_type() == "ForeignKey"
-            and field.db_constraint
+            and field.db_constraint  # type: ignore[attr-defined]
         ):
             return False
         return not self._is_limited_data_type(field)
 
     def _create_missing_fk_index(
         self,
-        model,
+        model: type[Model],
         *,
-        fields,
-        expressions=None,
-    ):
+        fields: Sequence[str],
+        expressions: Sequence[Any] | None = None,
+    ) -> None:
         """
         MySQL can remove an implicit FK index on a field when that field is
         covered by another index. "covered" here means
@@ -185,7 +197,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         if not first_field_name:
             return
 
-        first_field = model._meta.get_field(first_field_name)
+        first_field = model._model_meta.get_field(first_field_name)
         if first_field.get_internal_type() == "ForeignKey":
             column = self.connection.introspection.identifier_converter(
                 first_field.column
@@ -194,7 +206,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                 constraint_names = [
                     name
                     for name, infodict in self.connection.introspection.get_constraints(
-                        cursor, model._meta.db_table
+                        cursor, model.model_options.db_table
                     ).items()
                     if infodict["index"] and infodict["columns"][0] == column
                 ]
@@ -205,7 +217,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                     self._create_index_sql(model, fields=[first_field], suffix="")
                 )
 
-    def _set_field_new_type_null_status(self, field, new_type):
+    def _set_field_new_type_null_status(self, field: Field, new_type: str) -> str:
         """
         Keep the null property of the old field. If it has changed, it will be
         handled separately.
@@ -217,14 +229,22 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         return new_type
 
     def _alter_column_type_sql(
-        self, model, old_field, new_field, new_type, old_collation, new_collation
-    ):
+        self,
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        new_type: str,
+        old_collation: str,
+        new_collation: str,
+    ) -> tuple[str, list[Any]]:
         new_type = self._set_field_new_type_null_status(old_field, new_type)
         return super()._alter_column_type_sql(
             model, old_field, new_field, new_type, old_collation, new_collation
         )
 
-    def _field_db_check(self, field, field_db_params):
+    def _field_db_check(
+        self, field: Field, field_db_params: dict[str, Any]
+    ) -> str | None:
         if self.connection.mysql_is_mariadb and self.connection.mysql_version >= (
             10,
             5,
@@ -237,14 +257,18 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # renamed.
         return field_db_params["check"]
 
-    def _rename_field_sql(self, table, old_field, new_field, new_type):
+    def _rename_field_sql(
+        self, table: str, old_field: Field, new_field: Field, new_type: str
+    ) -> str:
         new_type = self._set_field_new_type_null_status(old_field, new_type)
         return super()._rename_field_sql(table, old_field, new_field, new_type)
 
-    def _alter_column_comment_sql(self, model, new_field, new_type, new_db_comment):
+    def _alter_column_comment_sql(
+        self, model: type[Model], new_field: Field, new_type: str, new_db_comment: str
+    ) -> tuple[str, list[Any]]:
         # Comment is alter when altering the column type.
         return "", []
 
-    def _comment_sql(self, comment):
+    def _comment_sql(self, comment: str | None) -> str:
         comment_sql = super()._comment_sql(comment)
         return f" COMMENT {comment_sql}"

plain/models/backends/mysql/validation.py

@@ -1,19 +1,26 @@
-from plain import preflight
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from plain.models.backends.base.validation import BaseDatabaseValidation
+from plain.preflight import PreflightResult
+
+if TYPE_CHECKING:
+    from plain.models.fields import Field
 
 
 class DatabaseValidation(BaseDatabaseValidation):
-    def preflight(self):
+    def preflight(self) -> list[PreflightResult]:
         issues = super().preflight()
         issues.extend(self._check_sql_mode())
         return issues
 
-    def _check_sql_mode(self):
+    def _check_sql_mode(self) -> list[PreflightResult]:
         if not (
             self.connection.sql_mode & {"STRICT_TRANS_TABLES", "STRICT_ALL_TABLES"}
         ):
             return [
-                preflight.PreflightResult(
+                PreflightResult(
                     fix=f"{self.connection.display_name} Strict Mode is not set for the database connection. "
                     f"{self.connection.display_name}'s Strict Mode fixes many data integrity problems in "
                     f"{self.connection.display_name}, such as data truncation upon insertion, by "
@@ -25,7 +32,7 @@ class DatabaseValidation(BaseDatabaseValidation):
             ]
         return []
 
-    def check_field_type(self, field, field_type):
+    def check_field_type(self, field: Field, field_type: str) -> list[PreflightResult]:
         """
         MySQL has the following field length restriction:
         No character (varchar) fields can have a length exceeding 255
@@ -39,7 +46,7 @@ class DatabaseValidation(BaseDatabaseValidation):
             and (field.max_length is None or int(field.max_length) > 255)
         ):
             errors.append(
-                preflight.PreflightResult(
+                PreflightResult(
                     fix=f"{self.connection.display_name} may not allow unique CharFields to have a max_length "
                     "> 255.",
                     obj=field,

plain/models/backends/postgresql/base.py

@@ -1,15 +1,20 @@
+from __future__ import annotations
+
+import datetime
 import threading
 import warnings
+from collections.abc import Generator
 from contextlib import contextmanager
 from functools import cached_property, lru_cache
+from typing import Any
 
-import psycopg as Database
-from psycopg import IsolationLevel, adapt, adapters, sql
-from psycopg.postgres import types as pg_types
-from psycopg.pq import Format
-from psycopg.types.datetime import TimestamptzLoader
-from psycopg.types.range import Range, RangeDumper
-from psycopg.types.string import TextLoader
+import psycopg as Database  # type: ignore[import-untyped]
+from psycopg import IsolationLevel, adapt, adapters, sql  # type: ignore[import-untyped]
+from psycopg.postgres import types as pg_types  # type: ignore[import-untyped]
+from psycopg.pq import Format  # type: ignore[import-untyped]
+from psycopg.types.datetime import TimestamptzLoader  # type: ignore[import-untyped]
+from psycopg.types.range import Range, RangeDumper  # type: ignore[import-untyped]
+from psycopg.types.string import TextLoader  # type: ignore[import-untyped]
 
 from plain.exceptions import ImproperlyConfigured
 from plain.models.backends.base.base import BaseDatabaseWrapper
@@ -38,14 +43,14 @@ class BaseTzLoader(TimestamptzLoader):
     The timezone can be None too, in which case it will be chopped.
     """
 
-    timezone = None
+    timezone: datetime.tzinfo | None = None
 
-    def load(self, data):
+    def load(self, data: bytes) -> datetime.datetime:
         res = super().load(data)
         return res.replace(tzinfo=self.timezone)
 
 
-def register_tzloader(tz, context):
+def register_tzloader(tz: datetime.tzinfo | None, context: Any) -> None:
     class SpecificTzLoader(BaseTzLoader):
         timezone = tz
 
@@ -55,7 +60,7 @@ def register_tzloader(tz, context):
 class PlainRangeDumper(RangeDumper):
     """A Range dumper customized for Plain."""
 
-    def upgrade(self, obj, format):
+    def upgrade(self, obj: Any, format: Format) -> RangeDumper:
         dumper = super().upgrade(obj, format)
         if dumper is not self and dumper.oid == TSRANGE_OID:
             dumper.oid = TSTZRANGE_OID
@@ -63,7 +68,7 @@ class PlainRangeDumper(RangeDumper):
 
 
 @lru_cache
-def get_adapters_template(timezone):
+def get_adapters_template(timezone: datetime.tzinfo | None) -> adapters.AdaptersMap:
     ctx = adapt.AdaptersMap(adapters)
     # No-op JSON loader to avoid psycopg3 round trips
     ctx.register_loader("jsonb", TextLoader)
@@ -75,13 +80,13 @@ def get_adapters_template(timezone):
     return ctx
 
 
-def _get_varchar_column(data):
+def _get_varchar_column(data: dict[str, Any]) -> str:
     if data["max_length"] is None:
         return "varchar"
     return "varchar({max_length})".format(**data)
 
 
-class DatabaseWrapper(BaseDatabaseWrapper):
+class PostgreSQLDatabaseWrapper(BaseDatabaseWrapper):
     vendor = "postgresql"
     display_name = "PostgreSQL"
     # This dictionary maps Field objects to their associated PostgreSQL column
@@ -166,14 +171,14 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     # PostgreSQL backend-specific attributes.
     _named_cursor_idx = 0
 
-    def get_database_version(self):
+    def get_database_version(self) -> tuple[int, ...]:
         """
         Return a tuple of the database's version.
         E.g. for pg_version 120004, return (12, 4).
         """
         return divmod(self.pg_version, 10000)
 
-    def get_connection_params(self):
+    def get_connection_params(self) -> dict[str, Any]:
         settings_dict = self.settings_dict
         # None may be used to connect to the default 'postgres' db
         if settings_dict["NAME"] == "" and not settings_dict.get("OPTIONS", {}).get(
@@ -194,7 +199,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
                     self.ops.max_name_length(),
                 )
             )
-        conn_params = {"client_encoding": "UTF8"}
+        conn_params: dict[str, Any] = {"client_encoding": "UTF8"}
         if settings_dict["NAME"]:
             conn_params = {
                 "dbname": settings_dict["NAME"],
@@ -224,7 +229,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         conn_params["prepare_threshold"] = conn_params.pop("prepare_threshold", None)
         return conn_params
 
-    def get_new_connection(self, conn_params):
+    def get_new_connection(self, conn_params: dict[str, Any]) -> Any:
         # self.isolation_level must be set:
         # - after connecting to the database in order to obtain the database's
         #   default when no value is explicitly specified in options.
@@ -257,7 +262,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         )
         return connection
 
-    def ensure_timezone(self):
+    def ensure_timezone(self) -> bool:
         if self.connection is None:
             return False
         conn_timezone_name = self.connection.info.parameter_status("TimeZone")
@@ -268,7 +273,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             return True
         return False
 
-    def ensure_role(self):
+    def ensure_role(self) -> bool:
         if self.connection is None:
             return False
         if new_role := self.settings_dict.get("OPTIONS", {}).get("assume_role"):
@@ -278,7 +283,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             return True
         return False
 
-    def init_connection_state(self):
+    def init_connection_state(self) -> None:
         super().init_connection_state()
 
         # Commit after setting the time zone.
@@ -291,7 +296,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         if (commit_role or commit_tz) and not self.get_autocommit():
             self.connection.commit()
 
-    def create_cursor(self, name=None):
+    def create_cursor(self, name: str | None = None) -> Any:
         if name:
             # In autocommit mode, the cursor will be used outside of a
             # transaction, hence use a holdable cursor.
@@ -307,10 +312,10 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             register_tzloader(self.timezone, cursor)
         return cursor
 
-    def tzinfo_factory(self, offset):
+    def tzinfo_factory(self, offset: int) -> datetime.tzinfo | None:
         return self.timezone
 
-    def chunked_cursor(self):
+    def chunked_cursor(self) -> Any:
         self._named_cursor_idx += 1
         # Get the current async task
         # Note that right now this is behind @async_unsafe, so this is
@@ -329,11 +334,11 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             )
         )
 
-    def _set_autocommit(self, autocommit):
+    def _set_autocommit(self, autocommit: bool) -> None:
         with self.wrap_database_errors:
             self.connection.autocommit = autocommit
 
-    def check_constraints(self, table_names=None):
+    def check_constraints(self, table_names: list[str] | None = None) -> None:
         """
         Check constraints by setting them to immediate. Return them to deferred
         afterward.
@@ -342,7 +347,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             cursor.execute("SET CONSTRAINTS ALL IMMEDIATE")
             cursor.execute("SET CONSTRAINTS ALL DEFERRED")
 
-    def is_usable(self):
+    def is_usable(self) -> bool:
         try:
             # Use a psycopg cursor directly, bypassing Plain's utilities.
             with self.connection.cursor() as cursor:
@@ -353,7 +358,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             return True
 
     @contextmanager
-    def _nodb_cursor(self):
+    def _nodb_cursor(self) -> Generator[Any, None, None]:
         cursor = None
         try:
             with super()._nodb_cursor() as cursor:
@@ -382,11 +387,11 @@ class DatabaseWrapper(BaseDatabaseWrapper):
                 conn.close()
 
     @cached_property
-    def pg_version(self):
+    def pg_version(self) -> int:
         with self.temporary_connection():
             return self.connection.info.server_version
 
-    def make_debug_cursor(self, cursor):
+    def make_debug_cursor(self, cursor: Any) -> CursorDebugWrapper:
         return CursorDebugWrapper(cursor, self)
 
 
@@ -395,11 +400,13 @@ class CursorMixin:
     A subclass of psycopg cursor implementing callproc.
     """
 
-    def callproc(self, name, args=None):
+    def callproc(
+        self, name: str | sql.Identifier, args: list[Any] | None = None
+    ) -> list[Any] | None:
         if not isinstance(name, sql.Identifier):
             name = sql.Identifier(name)
 
-        qparts = [sql.SQL("SELECT * FROM "), name, sql.SQL("(")]
+        qparts: list[sql.Composable] = [sql.SQL("SELECT * FROM "), name, sql.SQL("(")]
         if args:
             for item in args:
                 qparts.append(sql.Literal(item))
@@ -408,7 +415,7 @@ class CursorMixin:
 
         qparts.append(sql.SQL(")"))
         stmt = sql.Composed(qparts)
-        self.execute(stmt)
+        self.execute(stmt)  # type: ignore[attr-defined]
         return args
 
 
@@ -421,6 +428,6 @@ class Cursor(CursorMixin, Database.ClientCursor):
 
 
 class CursorDebugWrapper(BaseCursorDebugWrapper):
-    def copy(self, statement):
+    def copy(self, statement: Any) -> Any:
         with self.debug_sql(statement):
             return self.cursor.copy(statement)

plain/models/backends/postgresql/client.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import signal
+from typing import Any
 
 from plain.models.backends.base.client import BaseDatabaseClient
 
@@ -7,7 +10,9 @@ class DatabaseClient(BaseDatabaseClient):
     executable_name = "psql"
 
     @classmethod
-    def settings_to_cmd_args_env(cls, settings_dict, parameters):
+    def settings_to_cmd_args_env(
+        cls, settings_dict: dict[str, Any], parameters: list[str]
+    ) -> tuple[list[str], dict[str, str] | None]:
         args = [cls.executable_name]
         options = settings_dict.get("OPTIONS", {})
 
@@ -53,7 +58,7 @@ class DatabaseClient(BaseDatabaseClient):
             env["PGPASSFILE"] = str(passfile)
         return args, (env or None)
 
-    def runshell(self, parameters):
+    def runshell(self, parameters: list[str]) -> None:
         sigint_handler = signal.getsignal(signal.SIGINT)
         try:
             # Allow SIGINT to pass to psql to abort queries.

plain/models/backends/postgresql/creation.py

@@ -1,16 +1,21 @@
+from __future__ import annotations
+
 import sys
+from typing import Any
 
-from psycopg import errors
+from psycopg import errors  # type: ignore[import-untyped]
 
 from plain.exceptions import ImproperlyConfigured
 from plain.models.backends.base.creation import BaseDatabaseCreation
 
 
 class DatabaseCreation(BaseDatabaseCreation):
-    def _quote_name(self, name):
+    def _quote_name(self, name: str) -> str:
         return self.connection.ops.quote_name(name)
 
-    def _get_database_create_suffix(self, encoding=None, template=None):
+    def _get_database_create_suffix(
+        self, encoding: str | None = None, template: str | None = None
+    ) -> str:
         suffix = ""
         if encoding:
             suffix += f" ENCODING '{encoding}'"
@@ -18,7 +23,7 @@ class DatabaseCreation(BaseDatabaseCreation):
             suffix += f" TEMPLATE {self._quote_name(template)}"
         return suffix and "WITH" + suffix
 
-    def sql_table_creation_suffix(self):
+    def sql_table_creation_suffix(self) -> str:
         test_settings = self.connection.settings_dict["TEST"]
         if test_settings.get("COLLATION") is not None:
             raise ImproperlyConfigured(
@@ -30,7 +35,7 @@ class DatabaseCreation(BaseDatabaseCreation):
             template=test_settings.get("TEMPLATE"),
         )
 
-    def _execute_create_test_db(self, cursor, parameters):
+    def _execute_create_test_db(self, cursor: Any, parameters: dict[str, Any]) -> None:
         try:
             super()._execute_create_test_db(cursor, parameters)
         except Exception as e:

plain/models/backends/postgresql/introspection.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from collections import namedtuple
+from typing import Any
 
 from plain.models.backends.base.introspection import BaseDatabaseIntrospection
 from plain.models.backends.base.introspection import FieldInfo as BaseFieldInfo
@@ -36,9 +39,9 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
     # A hook for subclasses.
     index_default_access_method = "btree"
 
-    ignored_tables = []
+    ignored_tables: list[str] = []
 
-    def get_field_type(self, data_type, description):
+    def get_field_type(self, data_type: Any, description: Any) -> str:
         field_type = super().get_field_type(data_type, description)
         if description.is_autofield or (
             # Required for pre-Plain 4.1 serial columns.
@@ -48,7 +51,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
                 return "PrimaryKeyField"
         return field_type
 
-    def get_table_list(self, cursor):
+    def get_table_list(self, cursor: Any) -> list[TableInfo]:
         """Return a list of table and view names in the current database."""
         cursor.execute(
             """
@@ -73,7 +76,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             if row[0] not in self.ignored_tables
         ]
 
-    def get_table_description(self, cursor, table_name):
+    def get_table_description(self, cursor: Any, table_name: str) -> list[FieldInfo]:
         """
         Return a description of the table with the DB-API cursor.description
         interface.
@@ -120,7 +123,9 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             for line in cursor.description
         ]
 
-    def get_sequences(self, cursor, table_name, table_fields=()):
+    def get_sequences(
+        self, cursor: Any, table_name: str, table_fields: tuple[Any, ...] = ()
+    ) -> list[dict[str, Any]]:
         cursor.execute(
             """
             SELECT
@@ -146,7 +151,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             for row in cursor.fetchall()
         ]
 
-    def get_relations(self, cursor, table_name):
+    def get_relations(self, cursor: Any, table_name: str) -> dict[str, tuple[str, str]]:
         """
         Return a dictionary of {field_name: (field_name_other_table, other_table)}
         representing all foreign keys in the given table.
@@ -171,13 +176,15 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
         )
         return {row[0]: (row[2], row[1]) for row in cursor.fetchall()}
 
-    def get_constraints(self, cursor, table_name):
+    def get_constraints(
+        self, cursor: Any, table_name: str
+    ) -> dict[str, dict[str, Any]]:
         """
         Retrieve any constraints or keys (unique, pk, fk, check, index) across
         one or more columns. Also retrieve the definition of expression-based
         indexes.
         """
-        constraints = {}
+        constraints: dict[str, dict[str, Any]] = {}
         # Loop over the key table, collecting things as constraints. The column
         # array must return column names in the same order in which they were
         # created.