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

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,9 +102,12 @@ 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
+            model._model_meta.get_field(field_name).column
+            for field_name in self.include
         ]
         condition = self._get_condition_sql(model, schema_editor)
         if self.expressions:
@@ -107,19 +123,19 @@ class Index:
             col_suffixes = None
         else:
             fields = [
-                model._meta.get_field(field_name)
+                model._model_meta.get_field(field_name)
                 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 +143,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 +162,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.
 
@@ -157,9 +175,9 @@ class Index:
         (8 chars) and unique hash + suffix (10 chars). Each part is made to
         fit its size by truncating the excess length.
         """
-        _, table_name = split_identifier(model._meta.db_table)
+        _, table_name = split_identifier(model.model_options.db_table)
         column_names = [
-            model._meta.get_field(field_name).column
+            model._model_meta.get_field(field_name).column
             for field_name, order in self.fields_orders
         ]
         column_names_with_order = [
@@ -184,7 +202,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 +213,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 +225,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 +240,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 +307,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)