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

plain/models/functions/text.py

@@ -1,12 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 from plain.models.expressions import Func, Value
 from plain.models.fields import CharField, IntegerField, TextField
 from plain.models.functions import Cast, Coalesce
 from plain.models.lookups import Transform
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.sql.compiler import SQLCompiler
+
 
 class MySQLSHA2Mixin:
-    def as_mysql(self, compiler, connection, **extra_context):
-        return super().as_sql(
+    def as_mysql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
+        return super().as_sql(  # type: ignore[misc]
             compiler,
             connection,
             template=f"SHA2(%(expressions)s, {self.function[3:]})",
@@ -15,8 +28,13 @@ class MySQLSHA2Mixin:
 
 
 class PostgreSQLSHAMixin:
-    def as_postgresql(self, compiler, connection, **extra_context):
-        return super().as_sql(
+    def as_postgresql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
+        return super().as_sql(  # type: ignore[misc]
             compiler,
             connection,
             template="ENCODE(DIGEST(%(expressions)s, '%(function)s'), 'hex')",
@@ -29,7 +47,12 @@ class Chr(Transform):
     function = "CHR"
     lookup_name = "chr"
 
-    def as_mysql(self, compiler, connection, **extra_context):
+    def as_mysql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return super().as_sql(
             compiler,
             connection,
@@ -38,7 +61,12 @@ class Chr(Transform):
             **extra_context,
         )
 
-    def as_sqlite(self, compiler, connection, **extra_context):
+    def as_sqlite(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return super().as_sql(compiler, connection, function="CHAR", **extra_context)
 
 
@@ -50,7 +78,12 @@ class ConcatPair(Func):
 
     function = "CONCAT"
 
-    def as_sqlite(self, compiler, connection, **extra_context):
+    def as_sqlite(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         coalesced = self.coalesce()
         return super(ConcatPair, coalesced).as_sql(
             compiler,
@@ -60,7 +93,12 @@ class ConcatPair(Func):
             **extra_context,
         )
 
-    def as_postgresql(self, compiler, connection, **extra_context):
+    def as_postgresql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         copy = self.copy()
         copy.set_source_expressions(
             [
@@ -74,7 +112,12 @@ class ConcatPair(Func):
             **extra_context,
         )
 
-    def as_mysql(self, compiler, connection, **extra_context):
+    def as_mysql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         # Use CONCAT_WS with an empty separator so that NULLs are ignored.
         return super().as_sql(
             compiler,
@@ -84,7 +127,7 @@ class ConcatPair(Func):
             **extra_context,
         )
 
-    def coalesce(self):
+    def coalesce(self) -> ConcatPair:
         # null on either side results in null for expression, wrap with coalesce
         c = self.copy()
         c.set_source_expressions(
@@ -106,13 +149,13 @@ class Concat(Func):
     function = None
     template = "%(expressions)s"
 
-    def __init__(self, *expressions, **extra):
+    def __init__(self, *expressions: Any, **extra: Any) -> None:
         if len(expressions) < 2:
             raise ValueError("Concat must take at least two expressions")
         paired = self._paired(expressions)
         super().__init__(paired, **extra)
 
-    def _paired(self, expressions):
+    def _paired(self, expressions: tuple[Any, ...]) -> ConcatPair:
         # wrap pairs of expressions in successive concat functions
         # exp = [a, b, c, d]
         # -> ConcatPair(a, ConcatPair(b, ConcatPair(c, d))))
@@ -126,7 +169,7 @@ class Left(Func):
     arity = 2
     output_field = CharField()
 
-    def __init__(self, expression, length, **extra):
+    def __init__(self, expression: Any, length: Any, **extra: Any) -> None:
         """
         expression: the name of a field, or an expression returning a string
         length: the number of characters to return from the start of the string
@@ -136,10 +179,15 @@ class Left(Func):
                 raise ValueError("'length' must be greater than 0.")
         super().__init__(expression, length, **extra)
 
-    def get_substr(self):
+    def get_substr(self) -> Substr:
         return Substr(self.source_expressions[0], Value(1), self.source_expressions[1])
 
-    def as_sqlite(self, compiler, connection, **extra_context):
+    def as_sqlite(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return self.get_substr().as_sqlite(compiler, connection, **extra_context)
 
 
@@ -150,7 +198,12 @@ class Length(Transform):
     lookup_name = "length"
     output_field = IntegerField()
 
-    def as_mysql(self, compiler, connection, **extra_context):
+    def as_mysql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return super().as_sql(
             compiler, connection, function="CHAR_LENGTH", **extra_context
         )
@@ -165,7 +218,9 @@ class LPad(Func):
     function = "LPAD"
     output_field = CharField()
 
-    def __init__(self, expression, length, fill_text=Value(" "), **extra):
+    def __init__(
+        self, expression: Any, length: Any, fill_text: Any = Value(" "), **extra: Any
+    ) -> None:
         if (
             not hasattr(length, "resolve_expression")
             and length is not None
@@ -190,10 +245,20 @@ class Ord(Transform):
     lookup_name = "ord"
     output_field = IntegerField()
 
-    def as_mysql(self, compiler, connection, **extra_context):
+    def as_mysql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return super().as_sql(compiler, connection, function="ORD", **extra_context)
 
-    def as_sqlite(self, compiler, connection, **extra_context):
+    def as_sqlite(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return super().as_sql(compiler, connection, function="UNICODE", **extra_context)
 
 
@@ -201,7 +266,7 @@ class Repeat(Func):
     function = "REPEAT"
     output_field = CharField()
 
-    def __init__(self, expression, number, **extra):
+    def __init__(self, expression: Any, number: Any, **extra: Any) -> None:
         if (
             not hasattr(number, "resolve_expression")
             and number is not None
@@ -214,7 +279,9 @@ class Repeat(Func):
 class Replace(Func):
     function = "REPLACE"
 
-    def __init__(self, expression, text, replacement=Value(""), **extra):
+    def __init__(
+        self, expression: Any, text: Any, replacement: Any = Value(""), **extra: Any
+    ) -> None:
         super().__init__(expression, text, replacement, **extra)
 
 
@@ -226,7 +293,7 @@ class Reverse(Transform):
 class Right(Left):
     function = "RIGHT"
 
-    def get_substr(self):
+    def get_substr(self) -> Substr:
         return Substr(
             self.source_expressions[0], self.source_expressions[1] * Value(-1)
         )
@@ -277,7 +344,12 @@ class StrIndex(Func):
     arity = 2
     output_field = IntegerField()
 
-    def as_postgresql(self, compiler, connection, **extra_context):
+    def as_postgresql(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return super().as_sql(compiler, connection, function="STRPOS", **extra_context)
 
 
@@ -285,7 +357,9 @@ class Substr(Func):
     function = "SUBSTRING"
     output_field = CharField()
 
-    def __init__(self, expression, pos, length=None, **extra):
+    def __init__(
+        self, expression: Any, pos: Any, length: Any = None, **extra: Any
+    ) -> None:
         """
         expression: the name of a field, or an expression returning a string
         pos: an integer > 0, or an expression returning an integer
@@ -299,7 +373,12 @@ class Substr(Func):
             expressions.append(length)
         super().__init__(*expressions, **extra)
 
-    def as_sqlite(self, compiler, connection, **extra_context):
+    def as_sqlite(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         return super().as_sql(compiler, connection, function="SUBSTR", **extra_context)
 
 

plain/models/functions/window.py

@@ -1,5 +1,9 @@
+from __future__ import annotations
+
+from typing import Any
+
 from plain.models.expressions import Func
-from plain.models.fields import FloatField, IntegerField
+from plain.models.fields import Field, FloatField, IntegerField
 
 __all__ = [
     "CumeDist",
@@ -37,7 +41,9 @@ class FirstValue(Func):
 class LagLeadFunction(Func):
     window_compatible = True
 
-    def __init__(self, expression, offset=1, default=None, **extra):
+    def __init__(
+        self, expression: Any, offset: int = 1, default: Any = None, **extra: Any
+    ) -> None:
         if expression is None:
             raise ValueError(
                 f"{self.__class__.__name__} requires a non-null source expression."
@@ -51,7 +57,7 @@ class LagLeadFunction(Func):
             args += (default,)
         super().__init__(*args, **extra)
 
-    def _resolve_output_field(self):
+    def _resolve_output_field(self) -> Field:
         sources = self.get_source_expressions()
         return sources[0].output_field
 
@@ -74,7 +80,7 @@ class NthValue(Func):
     function = "NTH_VALUE"
     window_compatible = True
 
-    def __init__(self, expression, nth=1, **extra):
+    def __init__(self, expression: Any, nth: int = 1, **extra: Any) -> None:
         if expression is None:
             raise ValueError(
                 f"{self.__class__.__name__} requires a non-null source expression."
@@ -85,7 +91,7 @@ class NthValue(Func):
             )
         super().__init__(expression, nth, **extra)
 
-    def _resolve_output_field(self):
+    def _resolve_output_field(self) -> Field:
         sources = self.get_source_expressions()
         return sources[0].output_field
 
@@ -95,7 +101,7 @@ class Ntile(Func):
     output_field = IntegerField()
     window_compatible = True
 
-    def __init__(self, num_buckets=1, **extra):
+    def __init__(self, num_buckets: int = 1, **extra: Any) -> None:
         if num_buckets <= 0:
             raise ValueError("num_buckets must be greater than 0.")
         super().__init__(num_buckets, **extra)

plain/models/indexes.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from types import NoneType
+from typing import TYPE_CHECKING, Any
 
 from plain.models.backends.utils import names_digest, split_identifier
 from plain.models.expressions import Col, ExpressionList, F, Func, OrderBy
@@ -7,6 +10,14 @@ from plain.models.query_utils import Q
 from plain.models.sql import Query
 from plain.utils.functional import partition
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
+    from plain.models.backends.ddl_references import Statement
+    from plain.models.base import Model
+    from plain.models.expressions import Expression
+    from plain.models.sql.compiler import SQLCompiler
+
 __all__ = ["Index"]
 
 
@@ -18,13 +29,13 @@ class Index:
 
     def __init__(
         self,
-        *expressions,
-        fields=(),
-        name=None,
-        opclasses=(),
-        condition=None,
-        include=None,
-    ):
+        *expressions: Any,
+        fields: tuple[str, ...] | list[str] = (),
+        name: str | None = None,
+        opclasses: tuple[str, ...] | list[str] = (),
+        condition: Q | None = None,
+        include: tuple[str, ...] | list[str] | None = None,
+    ) -> None:
         if opclasses and not name:
             raise ValueError("An index must be named to use opclasses.")
         if not isinstance(condition, NoneType | Q):
@@ -77,10 +88,12 @@ class Index:
         )
 
     @property
-    def contains_expressions(self):
+    def contains_expressions(self) -> bool:
         return bool(self.expressions)
 
-    def _get_condition_sql(self, model, schema_editor):
+    def _get_condition_sql(
+        self, model: type[Model], schema_editor: BaseDatabaseSchemaEditor
+    ) -> str | None:
         if self.condition is None:
             return None
         query = Query(model=model, alias_cols=False)
@@ -89,7 +102,9 @@ class Index:
         sql, params = where.as_sql(compiler, schema_editor.connection)
         return sql % tuple(schema_editor.quote_value(p) for p in params)
 
-    def create_sql(self, model, schema_editor, **kwargs):
+    def create_sql(
+        self, model: type[Model], schema_editor: BaseDatabaseSchemaEditor, **kwargs: Any
+    ) -> Statement:
         include = [
             model._meta.get_field(field_name).column for field_name in self.include
         ]
@@ -111,15 +126,15 @@ class Index:
                 for field_name, _ in self.fields_orders
             ]
             if schema_editor.connection.features.supports_index_column_ordering:
-                col_suffixes = [order[1] for order in self.fields_orders]
+                col_suffixes = tuple(order[1] for order in self.fields_orders)
             else:
-                col_suffixes = [""] * len(self.fields_orders)
+                col_suffixes = ("",) * len(self.fields_orders)
             expressions = None
         return schema_editor._create_index_sql(
             model,
             fields=fields,
             name=self.name,
-            col_suffixes=col_suffixes,
+            col_suffixes=col_suffixes,  # type: ignore[arg-type]
             opclasses=self.opclasses,
             condition=condition,
             include=include,
@@ -127,10 +142,12 @@ class Index:
             **kwargs,
         )
 
-    def remove_sql(self, model, schema_editor, **kwargs):
+    def remove_sql(
+        self, model: type[Model], schema_editor: BaseDatabaseSchemaEditor, **kwargs: Any
+    ) -> Statement:
         return schema_editor._delete_index_sql(model, self.name, **kwargs)
 
-    def deconstruct(self):
+    def deconstruct(self) -> tuple[str, tuple[Expression, ...], dict[str, Any]]:
         path = f"{self.__class__.__module__}.{self.__class__.__name__}"
         path = path.replace("plain.models.indexes", "plain.models")
         kwargs = {"name": self.name}
@@ -144,12 +161,12 @@ class Index:
             kwargs["include"] = self.include
         return (path, self.expressions, kwargs)
 
-    def clone(self):
+    def clone(self) -> Index:
         """Create a copy of this Index."""
         _, args, kwargs = self.deconstruct()
         return self.__class__(*args, **kwargs)
 
-    def set_name_with_model(self, model):
+    def set_name_with_model(self, model: type[Model]) -> None:
         """
         Generate a unique name for the index.
 
@@ -184,7 +201,7 @@ class Index:
         if self.name[0] == "_" or self.name[0].isdigit():
             self.name = f"D{self.name[1:]}"
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<{}:{}{}{}{}{}{}>".format(
             self.__class__.__qualname__,
             "" if not self.fields else f" fields={repr(self.fields)}",
@@ -195,9 +212,9 @@ class Index:
             "" if not self.opclasses else f" opclasses={repr(self.opclasses)}",
         )
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if self.__class__ == other.__class__:
-            return self.deconstruct() == other.deconstruct()
+            return self.deconstruct() == other.deconstruct()  # type: ignore[attr-defined]
         return NotImplemented
 
 
@@ -207,7 +224,9 @@ class IndexExpression(Func):
     template = "%(expressions)s"
     wrapper_classes = (OrderBy, Collate)
 
-    def set_wrapper_classes(self, connection=None):
+    def set_wrapper_classes(
+        self, connection: BaseDatabaseWrapper | None = None
+    ) -> None:
         # Some databases (e.g. MySQL) treats COLLATE as an indexed expression.
         if connection and connection.features.collate_as_index_expression:
             self.wrapper_classes = tuple(
@@ -220,12 +239,12 @@ class IndexExpression(Func):
 
     def resolve_expression(
         self,
-        query=None,
-        allow_joins=True,
-        reuse=None,
-        summarize=False,
-        for_save=False,
-    ):
+        query: Any = None,
+        allow_joins: bool = True,
+        reuse: Any = None,
+        summarize: bool = False,
+        for_save: bool = False,
+    ) -> Expression:
         expressions = list(self.flatten())
         # Split expressions and wrappers.
         index_expressions, wrappers = partition(
@@ -287,6 +306,11 @@ class IndexExpression(Func):
             query, allow_joins, reuse, summarize, for_save
         )
 
-    def as_sqlite(self, compiler, connection, **extra_context):
+    def as_sqlite(
+        self,
+        compiler: SQLCompiler,
+        connection: BaseDatabaseWrapper,
+        **extra_context: Any,
+    ) -> tuple[str, tuple[Any, ...]]:
         # Casting to numeric is unnecessary.
         return self.as_sql(compiler, connection, **extra_context)