plain.models 0.49.1__py3-none-any.whl → 0.50.0__py3-none-any.whl

plain/models/backends/postgresql/operations.py

@@ -1,19 +1,28 @@
+from __future__ import annotations
+
 import ipaddress
 import json
+from collections.abc import Callable
 from functools import lru_cache, partial
+from typing import TYPE_CHECKING, Any
 
-from psycopg import ClientCursor, errors
-from psycopg.types import numeric
-from psycopg.types.json import Jsonb
+from psycopg import ClientCursor, errors  # type: ignore[import-untyped]
+from psycopg.types import numeric  # type: ignore[import-untyped]
+from psycopg.types.json import Jsonb  # type: ignore[import-untyped]
 
 from plain.models.backends.base.operations import BaseDatabaseOperations
 from plain.models.backends.utils import split_tzname_delta
 from plain.models.constants import OnConflict
 from plain.utils.regex_helper import _lazy_re_compile
 
+if TYPE_CHECKING:
+    from plain.models.fields import Field
+
 
 @lru_cache
-def get_json_dumps(encoder):
+def get_json_dumps(
+    encoder: type[json.JSONEncoder] | None,
+) -> Callable[..., str]:
     if encoder is None:
         return json.dumps
     return partial(json.dumps, cls=encoder)
@@ -47,7 +56,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         "PositiveBigIntegerField": numeric.Int8,
     }
 
-    def unification_cast_sql(self, output_field):
+    def unification_cast_sql(self, output_field: Field) -> str:
         internal_type = output_field.get_internal_type()
         if internal_type in (
             "GenericIPAddressField",
@@ -61,15 +70,17 @@ class DatabaseOperations(BaseDatabaseOperations):
             # PostgreSQL configuration so we need to explicitly cast them.
             # We must also remove components of the type within brackets:
             # varchar(255) -> varchar.
-            return "CAST(%s AS {})".format(
-                output_field.db_type(self.connection).split("(")[0]
-            )
+            db_type = output_field.db_type(self.connection)
+            if db_type:
+                return "CAST(%s AS {})".format(db_type.split("(")[0])
         return "%s"
 
     # EXTRACT format cannot be passed in parameters.
     _extract_format_re = _lazy_re_compile(r"[A-Z_]+")
 
-    def date_extract_sql(self, lookup_type, sql, params):
+    def date_extract_sql(
+        self, lookup_type: str, sql: str, params: list[Any] | tuple[Any, ...]
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         # https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-EXTRACT
         if lookup_type == "week_day":
             # For consistency across backends, we return Sunday=1, Saturday=7.
@@ -84,65 +95,97 @@ class DatabaseOperations(BaseDatabaseOperations):
             raise ValueError(f"Invalid lookup type: {lookup_type!r}")
         return f"EXTRACT({lookup_type} FROM {sql})", params
 
-    def date_trunc_sql(self, lookup_type, sql, params, tzname=None):
+    def date_trunc_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None = None,
+    ) -> tuple[str, tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         # https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-TRUNC
         return f"DATE_TRUNC(%s, {sql})", (lookup_type, *params)
 
-    def _prepare_tzname_delta(self, tzname):
+    def _prepare_tzname_delta(self, tzname: str) -> str:
         tzname, sign, offset = split_tzname_delta(tzname)
         if offset:
             sign = "-" if sign == "+" else "+"
             return f"{tzname}{sign}{offset}"
         return tzname
 
-    def _convert_sql_to_tz(self, sql, params, tzname):
+    def _convert_sql_to_tz(
+        self, sql: str, params: list[Any] | tuple[Any, ...], tzname: str | None
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         if tzname:
             tzname_param = self._prepare_tzname_delta(tzname)
             return f"{sql} AT TIME ZONE %s", (*params, tzname_param)
         return sql, params
 
-    def datetime_cast_date_sql(self, sql, params, tzname):
+    def datetime_cast_date_sql(
+        self, sql: str, params: list[Any] | tuple[Any, ...], tzname: str | None
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         return f"({sql})::date", params
 
-    def datetime_cast_time_sql(self, sql, params, tzname):
+    def datetime_cast_time_sql(
+        self, sql: str, params: list[Any] | tuple[Any, ...], tzname: str | None
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         return f"({sql})::time", params
 
-    def datetime_extract_sql(self, lookup_type, sql, params, tzname):
+    def datetime_extract_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None,
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         if lookup_type == "second":
             # Truncate fractional seconds.
             return f"EXTRACT(SECOND FROM DATE_TRUNC(%s, {sql}))", ("second", *params)
         return self.date_extract_sql(lookup_type, sql, params)
 
-    def datetime_trunc_sql(self, lookup_type, sql, params, tzname):
+    def datetime_trunc_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None,
+    ) -> tuple[str, tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         # https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-TRUNC
         return f"DATE_TRUNC(%s, {sql})", (lookup_type, *params)
 
-    def time_extract_sql(self, lookup_type, sql, params):
+    def time_extract_sql(
+        self, lookup_type: str, sql: str, params: list[Any] | tuple[Any, ...]
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         if lookup_type == "second":
             # Truncate fractional seconds.
             return f"EXTRACT(SECOND FROM DATE_TRUNC(%s, {sql}))", ("second", *params)
         return self.date_extract_sql(lookup_type, sql, params)
 
-    def time_trunc_sql(self, lookup_type, sql, params, tzname=None):
+    def time_trunc_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None = None,
+    ) -> tuple[str, tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         return f"DATE_TRUNC(%s, {sql})::time", (lookup_type, *params)
 
-    def deferrable_sql(self):
+    def deferrable_sql(self) -> str:
         return " DEFERRABLE INITIALLY DEFERRED"
 
-    def fetch_returned_insert_rows(self, cursor):
+    def fetch_returned_insert_rows(self, cursor: Any) -> list[Any]:
         """
         Given a cursor object that has just performed an INSERT...RETURNING
         statement into a table, return the tuple of returned data.
         """
         return cursor.fetchall()
 
-    def lookup_cast(self, lookup_type, internal_type=None):
+    def lookup_cast(self, lookup_type: str, internal_type: str | None = None) -> str:
         lookup = "%s"
 
         if lookup_type == "isnull" and internal_type in (
@@ -175,27 +218,27 @@ class DatabaseOperations(BaseDatabaseOperations):
 
         return lookup
 
-    def no_limit_value(self):
+    def no_limit_value(self) -> None:
         return None
 
-    def prepare_sql_script(self, sql):
+    def prepare_sql_script(self, sql: str) -> list[str]:
         return [sql]
 
-    def quote_name(self, name):
+    def quote_name(self, name: str) -> str:
         if name.startswith('"') and name.endswith('"'):
             return name  # Quoting once is enough.
         return f'"{name}"'
 
-    def compose_sql(self, sql, params):
+    def compose_sql(self, sql: str, params: Any) -> bytes:
         return ClientCursor(self.connection.connection).mogrify(sql, params)
 
-    def set_time_zone_sql(self):
+    def set_time_zone_sql(self) -> str:
         return "SELECT set_config('TimeZone', %s, false)"
 
-    def prep_for_iexact_query(self, x):
+    def prep_for_iexact_query(self, x: str) -> str:
         return x
 
-    def max_name_length(self):
+    def max_name_length(self) -> int:
         """
         Return the maximum length of an identifier.
 
@@ -208,20 +251,22 @@ class DatabaseOperations(BaseDatabaseOperations):
         """
         return 63
 
-    def distinct_sql(self, fields, params):
+    def distinct_sql(
+        self, fields: list[str], params: list[Any] | tuple[Any, ...]
+    ) -> tuple[list[str], list[Any]]:
         if fields:
             params = [param for param_list in params for param in param_list]
             return (["DISTINCT ON ({})".format(", ".join(fields))], params)
         else:
             return ["DISTINCT"], []
 
-    def last_executed_query(self, cursor, sql, params):
+    def last_executed_query(self, cursor: Any, sql: str, params: Any) -> bytes | None:
         try:
             return self.compose_sql(sql, params)
         except errors.DataError:
             return None
 
-    def return_insert_columns(self, fields):
+    def return_insert_columns(self, fields: list[Field]) -> tuple[str, tuple[Any, ...]]:
         if not fields:
             return "", ()
         columns = [
@@ -230,37 +275,53 @@ class DatabaseOperations(BaseDatabaseOperations):
         ]
         return "RETURNING {}".format(", ".join(columns)), ()
 
-    def bulk_insert_sql(self, fields, placeholder_rows):
+    def bulk_insert_sql(
+        self, fields: list[Field], placeholder_rows: list[list[str]]
+    ) -> str:
         placeholder_rows_sql = (", ".join(row) for row in placeholder_rows)
         values_sql = ", ".join(f"({sql})" for sql in placeholder_rows_sql)
         return "VALUES " + values_sql
 
-    def adapt_integerfield_value(self, value, internal_type):
+    def adapt_integerfield_value(
+        self, value: int | Any | None, internal_type: str
+    ) -> int | Any | None:
         if value is None or hasattr(value, "resolve_expression"):
             return value
         return self.integerfield_type_map[internal_type](value)
 
-    def adapt_datefield_value(self, value):
+    def adapt_datefield_value(self, value: Any) -> Any:
         return value
 
-    def adapt_datetimefield_value(self, value):
+    def adapt_datetimefield_value(self, value: Any) -> Any:
         return value
 
-    def adapt_timefield_value(self, value):
+    def adapt_timefield_value(self, value: Any) -> Any:
         return value
 
-    def adapt_decimalfield_value(self, value, max_digits=None, decimal_places=None):
+    def adapt_decimalfield_value(
+        self,
+        value: Any,
+        max_digits: int | None = None,
+        decimal_places: int | None = None,
+    ) -> Any:
         return value
 
-    def adapt_ipaddressfield_value(self, value):
+    def adapt_ipaddressfield_value(
+        self, value: str | None
+    ) -> ipaddress.IPv4Address | ipaddress.IPv6Address | None:
         if value:
             return ipaddress.ip_address(value)
         return None
 
-    def adapt_json_value(self, value, encoder):
+    def adapt_json_value(self, value: Any, encoder: type[json.JSONEncoder]) -> Jsonb:
         return Jsonb(value, dumps=get_json_dumps(encoder))
 
-    def subtract_temporals(self, internal_type, lhs, rhs):
+    def subtract_temporals(
+        self,
+        internal_type: str,
+        lhs: tuple[str, list[Any] | tuple[Any, ...]],
+        rhs: tuple[str, list[Any] | tuple[Any, ...]],
+    ) -> tuple[str, tuple[Any, ...]]:
         if internal_type == "DateField":
             lhs_sql, lhs_params = lhs
             rhs_sql, rhs_params = rhs
@@ -268,7 +329,7 @@ class DatabaseOperations(BaseDatabaseOperations):
             return f"(interval '1 day' * ({lhs_sql} - {rhs_sql}))", params
         return super().subtract_temporals(internal_type, lhs, rhs)
 
-    def explain_query_prefix(self, format=None, **options):
+    def explain_query_prefix(self, format: str | None = None, **options: Any) -> str:
         extra = {}
         # Normalize options.
         if options:
@@ -289,7 +350,13 @@ class DatabaseOperations(BaseDatabaseOperations):
             )
         return prefix
 
-    def on_conflict_suffix_sql(self, fields, on_conflict, update_fields, unique_fields):
+    def on_conflict_suffix_sql(
+        self,
+        fields: list[Field],
+        on_conflict: OnConflict | None,
+        update_fields: list[Field],
+        unique_fields: list[Field],
+    ) -> str:
         if on_conflict == OnConflict.IGNORE:
             return "ON CONFLICT DO NOTHING"
         if on_conflict == OnConflict.UPDATE:

plain/models/backends/postgresql/schema.py

@@ -1,9 +1,20 @@
-from psycopg import sql
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from psycopg import sql  # type: ignore[import-untyped]
 
 from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
-from plain.models.backends.ddl_references import IndexColumns
+from plain.models.backends.ddl_references import Columns, IndexColumns, Statement
 from plain.models.backends.utils import strip_quotes
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from plain.models.base import Model
+    from plain.models.fields import Field
+    from plain.models.indexes import Index
+
 
 class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     # Setting all constraints to IMMEDIATE to allow changing data in the same
@@ -39,7 +50,9 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         "ALTER TABLE %(table)s DROP CONSTRAINT %(name)s"
     )
 
-    def execute(self, sql, params=()):
+    def execute(
+        self, sql: str | Statement, params: tuple[Any, ...] | list[Any] | None = ()
+    ) -> None:
         # Merge the query client-side, as PostgreSQL won't do it server-side.
         if params is None:
             return super().execute(sql, params)
@@ -55,19 +68,19 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         "ALTER TABLE %(table)s ALTER COLUMN %(column)s DROP IDENTITY IF EXISTS"
     )
 
-    def quote_value(self, value):
+    def quote_value(self, value: Any) -> str:
         if isinstance(value, str):
             value = value.replace("%", "%%")
         return sql.quote(value, self.connection.connection)
 
-    def _field_indexes_sql(self, model, field):
+    def _field_indexes_sql(self, model: type[Model], field: Field) -> list[Statement]:
         output = super()._field_indexes_sql(model, field)
         like_index_statement = self._create_like_index_sql(model, field)
         if like_index_statement is not None:
             output.append(like_index_statement)
         return output
 
-    def _field_data_type(self, field):
+    def _field_data_type(self, field: Field) -> str | None:
         if field.is_relation:
             return field.rel_db_type(self.connection)
         return self.connection.data_types.get(
@@ -75,14 +88,16 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             field.db_type(self.connection),
         )
 
-    def _field_base_data_types(self, field):
+    def _field_base_data_types(self, field: Field) -> Generator[str | None, None, None]:
         # Yield base data types for array fields.
-        if field.base_field.get_internal_type() == "ArrayField":
-            yield from self._field_base_data_types(field.base_field)
+        if field.base_field.get_internal_type() == "ArrayField":  # type: ignore[attr-defined]
+            yield from self._field_base_data_types(field.base_field)  # type: ignore[attr-defined]
         else:
-            yield self._field_data_type(field.base_field)
+            yield self._field_data_type(field.base_field)  # type: ignore[attr-defined]
 
-    def _create_like_index_sql(self, model, field):
+    def _create_like_index_sql(
+        self, model: type[Model], field: Field
+    ) -> Statement | None:
         """
         Return the statement to create an index with varchar operator pattern
         when the column type is 'varchar' or 'text', otherwise return None.
@@ -107,18 +122,18 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                     model,
                     fields=[field],
                     suffix="_like",
-                    opclasses=["varchar_pattern_ops"],
+                    opclasses=("varchar_pattern_ops",),
                 )
             elif db_type.startswith("text"):
                 return self._create_index_sql(
                     model,
                     fields=[field],
                     suffix="_like",
-                    opclasses=["text_pattern_ops"],
+                    opclasses=("text_pattern_ops",),
                 )
         return None
 
-    def _using_sql(self, new_field, old_field):
+    def _using_sql(self, new_field: Field, old_field: Field) -> str:
         using_sql = " USING %(column)s::%(type)s"
         new_internal_type = new_field.get_internal_type()
         old_internal_type = old_field.get_internal_type()
@@ -132,7 +147,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             return using_sql
         return ""
 
-    def _get_sequence_name(self, table, column):
+    def _get_sequence_name(self, table: str, column: str) -> str | None:
         with self.connection.cursor() as cursor:
             for sequence in self.connection.introspection.get_sequences(cursor, table):
                 if sequence["column"] == column:
@@ -140,8 +155,14 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         return None
 
     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 | None,
+        new_collation: str | None,
+    ) -> tuple[tuple[str, list[Any]], list[tuple[str, list[Any]]]]:
         # Drop indexes on varchar/text/citext columns that are changing to a
         # different type.
         old_db_params = old_field.db_parameters(connection=self.connection)
@@ -248,15 +269,15 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
     def _alter_field(
         self,
-        model,
-        old_field,
-        new_field,
-        old_type,
-        new_type,
-        old_db_params,
-        new_db_params,
-        strict=False,
-    ):
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        old_type: str,
+        new_type: str,
+        old_db_params: dict[str, Any],
+        new_db_params: dict[str, Any],
+        strict: bool = False,
+    ) -> None:
         super()._alter_field(
             model,
             old_field,
@@ -270,9 +291,10 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # Added an index? Create any PostgreSQL-specific indexes.
         if (
             not (
-                (old_field.remote_field and old_field.db_index) or old_field.primary_key
+                (old_field.remote_field and old_field.db_index)  # type: ignore[attr-defined]
+                or old_field.primary_key
             )
-            and (new_field.remote_field and new_field.db_index)
+            and (new_field.remote_field and new_field.db_index)  # type: ignore[attr-defined]
         ) or (not old_field.primary_key and new_field.primary_key):
             like_index_statement = self._create_like_index_sql(model, new_field)
             if like_index_statement is not None:
@@ -280,14 +302,21 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
         # Removed an index? Drop any PostgreSQL-specific indexes.
         if old_field.primary_key and not (
-            (new_field.remote_field and new_field.db_index) or new_field.primary_key
+            (new_field.remote_field and new_field.db_index)  # type: ignore[attr-defined]
+            or new_field.primary_key
         ):
             index_to_remove = self._create_index_name(
                 model._meta.db_table, [old_field.column], suffix="_like"
             )
             self.execute(self._delete_index_sql(model, index_to_remove))
 
-    def _index_columns(self, table, columns, col_suffixes, opclasses):
+    def _index_columns(
+        self,
+        table: str,
+        columns: list[str],
+        col_suffixes: tuple[str, ...],
+        opclasses: tuple[str, ...],
+    ) -> Columns | IndexColumns:
         if opclasses:
             return IndexColumns(
                 table,
@@ -298,15 +327,25 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             )
         return super()._index_columns(table, columns, col_suffixes, opclasses)
 
-    def add_index(self, model, index, concurrently=False):
+    def add_index(
+        self, model: type[Model], index: Index, concurrently: bool = False
+    ) -> None:
         self.execute(
             index.create_sql(model, self, concurrently=concurrently), params=None
         )
 
-    def remove_index(self, model, index, concurrently=False):
+    def remove_index(
+        self, model: type[Model], index: Index, concurrently: bool = False
+    ) -> None:
         self.execute(index.remove_sql(model, self, concurrently=concurrently))
 
-    def _delete_index_sql(self, model, name, sql=None, concurrently=False):
+    def _delete_index_sql(
+        self,
+        model: type[Model],
+        name: str,
+        sql: str | None = None,
+        concurrently: bool = False,
+    ) -> Statement:
         sql = (
             self.sql_delete_index_concurrently
             if concurrently
@@ -316,20 +355,20 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
     def _create_index_sql(
         self,
-        model,
+        model: type[Model],
         *,
-        fields=None,
-        name=None,
-        suffix="",
-        using="",
-        col_suffixes=(),
-        sql=None,
-        opclasses=(),
-        condition=None,
-        concurrently=False,
-        include=None,
-        expressions=None,
-    ):
+        fields: list[Field] | None = None,
+        name: str | None = None,
+        suffix: str = "",
+        using: str = "",
+        col_suffixes: tuple[str, ...] = (),
+        sql: str | None = None,
+        opclasses: tuple[str, ...] = (),
+        condition: str | None = None,
+        concurrently: bool = False,
+        include: list[str] | None = None,
+        expressions: Any = None,
+    ) -> Statement:
         sql = sql or (
             self.sql_create_index
             if not concurrently