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

plain/models/sql/subqueries.py

@@ -2,6 +2,10 @@
 Query subclasses which provide extra functionality beyond simple data retrieval.
 """
 
+from __future__ import annotations
+
+from typing import Any
+
 from plain.models.exceptions import FieldError
 from plain.models.sql.constants import CURSOR, GET_ITERATOR_CHUNK_SIZE, NO_RESULTS
 from plain.models.sql.query import Query
@@ -14,7 +18,7 @@ class DeleteQuery(Query):
 
     compiler = "SQLDeleteCompiler"
 
-    def do_query(self, table, where):
+    def do_query(self, table: str, where: Any) -> int:
         self.alias_map = {table: self.alias_map[table]}
         self.where = where
         cursor = self.get_compiler().execute_sql(CURSOR)
@@ -23,7 +27,7 @@ class DeleteQuery(Query):
                 return cursor.rowcount
         return 0
 
-    def delete_batch(self, id_list):
+    def delete_batch(self, id_list: list[Any]) -> int:
         """
         Set up and execute delete queries for all the objects in id_list.
 
@@ -32,14 +36,14 @@ class DeleteQuery(Query):
         """
         # number of objects deleted
         num_deleted = 0
-        field = self.get_meta().get_field("id")
+        field = self.get_model_meta().get_field("id")
         for offset in range(0, len(id_list), GET_ITERATOR_CHUNK_SIZE):
             self.clear_where()
             self.add_filter(
                 f"{field.attname}__in",
                 id_list[offset : offset + GET_ITERATOR_CHUNK_SIZE],
             )
-            num_deleted += self.do_query(self.get_meta().db_table, self.where)
+            num_deleted += self.do_query(self.model.model_options.db_table, self.where)
         return num_deleted
 
 
@@ -48,25 +52,25 @@ class UpdateQuery(Query):
 
     compiler = "SQLUpdateCompiler"
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._setup_query()
 
-    def _setup_query(self):
+    def _setup_query(self) -> None:
         """
         Run on initialization and at the end of chaining. Any attributes that
         would normally be set in __init__() should go here instead.
         """
-        self.values = []
-        self.related_ids = None
-        self.related_updates = {}
+        self.values: list[tuple[Any, Any, Any]] = []
+        self.related_ids: dict[Any, list[Any]] | None = None
+        self.related_updates: dict[Any, list[tuple[Any, Any, Any]]] = {}
 
-    def clone(self):
+    def clone(self) -> UpdateQuery:
         obj = super().clone()
         obj.related_updates = self.related_updates.copy()
-        return obj
+        return obj  # type: ignore[return-value]
 
-    def update_batch(self, id_list, values):
+    def update_batch(self, id_list: list[Any], values: dict[str, Any]) -> None:
         self.add_update_values(values)
         for offset in range(0, len(id_list), GET_ITERATOR_CHUNK_SIZE):
             self.clear_where()
@@ -75,7 +79,7 @@ class UpdateQuery(Query):
             )
             self.get_compiler().execute_sql(NO_RESULTS)
 
-    def add_update_values(self, values):
+    def add_update_values(self, values: dict[str, Any]) -> list[tuple[Any, Any, Any]]:
         """
         Convert a dictionary of field name to value mappings into an update
         query. This is the entry point for the public update() method on
@@ -83,7 +87,7 @@ class UpdateQuery(Query):
         """
         values_seq = []
         for name, val in values.items():
-            field = self.get_meta().get_field(name)
+            field = self.get_model_meta().get_field(name)
             direct = (
                 not (field.auto_created and not field.concrete) or not field.concrete
             )
@@ -93,13 +97,13 @@ class UpdateQuery(Query):
                     f"Cannot update model field {field!r} (only non-relations and "
                     "foreign keys permitted)."
                 )
-            if model is not self.get_meta().model:
+            if model is not self.get_model_meta().model:
                 self.add_related_update(model, field, val)
                 continue
             values_seq.append((field, model, val))
         return self.add_update_fields(values_seq)
 
-    def add_update_fields(self, values_seq):
+    def add_update_fields(self, values_seq: list[tuple[Any, Any, Any]]) -> None:
         """
         Append a sequence of (field, model, value) triples to the internal list
         that will be used to generate the UPDATE query. Might be more usefully
@@ -111,7 +115,7 @@ class UpdateQuery(Query):
                 val = val.resolve_expression(self, allow_joins=False, for_save=True)
             self.values.append((field, model, val))
 
-    def add_related_update(self, model, field, value):
+    def add_related_update(self, model: Any, field: Any, value: Any) -> None:
         """
         Add (name, value) to an update query for an ancestor model.
 
@@ -119,7 +123,7 @@ class UpdateQuery(Query):
         """
         self.related_updates.setdefault(model, []).append((field, None, value))
 
-    def get_related_updates(self):
+    def get_related_updates(self) -> list[UpdateQuery]:
         """
         Return a list of query objects: one for each update required to an
         ancestor model. Each query will have the same filtering conditions as
@@ -141,19 +145,26 @@ class InsertQuery(Query):
     compiler = "SQLInsertCompiler"
 
     def __init__(
-        self, *args, on_conflict=None, update_fields=None, unique_fields=None, **kwargs
-    ):
+        self,
+        *args: Any,
+        on_conflict: str | None = None,
+        update_fields: list[Any] | None = None,
+        unique_fields: list[Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
         super().__init__(*args, **kwargs)
-        self.fields = []
-        self.objs = []
+        self.fields: list[Any] = []
+        self.objs: list[Any] = []
         self.on_conflict = on_conflict
         self.update_fields = update_fields or []
         self.unique_fields = unique_fields or []
 
-    def insert_values(self, fields, objs, raw=False):
+    def insert_values(
+        self, fields: list[Any], objs: list[Any], raw: bool = False
+    ) -> None:
         self.fields = fields
         self.objs = objs
-        self.raw = raw
+        self.raw = raw  # type: ignore[attr-defined]
 
 
 class AggregateQuery(Query):
@@ -164,6 +175,6 @@ class AggregateQuery(Query):
 
     compiler = "SQLAggregateCompiler"
 
-    def __init__(self, model, inner_query):
+    def __init__(self, model: Any, inner_query: Any) -> None:
         self.inner_query = inner_query
         super().__init__(model)

plain/models/sql/where.py

@@ -2,14 +2,21 @@
 Code to manage the creation and SQL rendering of 'where' constraints.
 """
 
+from __future__ import annotations
+
 import operator
 from functools import cached_property, reduce
+from typing import TYPE_CHECKING, Any
 
 from plain.models.exceptions import EmptyResultSet, FullResultSet
 from plain.models.expressions import Case, When
 from plain.models.lookups import Exact
 from plain.utils import tree
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.sql.compiler import SQLCompiler
+
 # Connection types
 AND = "AND"
 OR = "OR"
@@ -35,7 +42,9 @@ class WhereNode(tree.Node):
     resolved = False
     conditional = True
 
-    def split_having_qualify(self, negated=False, must_group_by=False):
+    def split_having_qualify(
+        self, negated: bool = False, must_group_by: bool = False
+    ) -> tuple[WhereNode | None, WhereNode | None, WhereNode | None]:
         """
         Return three possibly None nodes: one for those parts of self that
         should be included in the WHERE clause, one for those parts of self
@@ -111,7 +120,9 @@ class WhereNode(tree.Node):
         )
         return where_node, having_node, qualify_node
 
-    def as_sql(self, compiler, connection):
+    def as_sql(
+        self, compiler: SQLCompiler, connection: BaseDatabaseWrapper
+    ) -> tuple[str, list[Any]]:
         """
         Return the SQL version of the where clause and the value to be
         substituted in. Return '', [] if this node matches everything,
@@ -181,20 +192,20 @@ class WhereNode(tree.Node):
             sql_string = f"({sql_string})"
         return sql_string, result_params
 
-    def get_group_by_cols(self):
+    def get_group_by_cols(self) -> list[Any]:
         cols = []
         for child in self.children:
             cols.extend(child.get_group_by_cols())
         return cols
 
-    def get_source_expressions(self):
+    def get_source_expressions(self) -> list[Any]:
         return self.children[:]
 
-    def set_source_expressions(self, children):
+    def set_source_expressions(self, children: list[Any]) -> None:
         assert len(children) == len(self.children)
         self.children = children
 
-    def relabel_aliases(self, change_map):
+    def relabel_aliases(self, change_map: dict[str, str]) -> None:
         """
         Relabel the alias values of any children. 'change_map' is a dictionary
         mapping old (current) alias values to the new values.
@@ -206,7 +217,7 @@ class WhereNode(tree.Node):
             elif hasattr(child, "relabeled_clone"):
                 self.children[pos] = child.relabeled_clone(change_map)
 
-    def clone(self):
+    def clone(self) -> WhereNode:
         clone = self.create(connector=self.connector, negated=self.negated)
         for child in self.children:
             if hasattr(child, "clone"):
@@ -214,12 +225,12 @@ class WhereNode(tree.Node):
             clone.children.append(child)
         return clone
 
-    def relabeled_clone(self, change_map):
+    def relabeled_clone(self, change_map: dict[str, str]) -> WhereNode:
         clone = self.clone()
         clone.relabel_aliases(change_map)
         return clone
 
-    def replace_expressions(self, replacements):
+    def replace_expressions(self, replacements: dict[Any, Any]) -> WhereNode:
         if replacement := replacements.get(self):
             return replacement
         clone = self.create(connector=self.connector, negated=self.negated)
@@ -227,44 +238,44 @@ class WhereNode(tree.Node):
             clone.children.append(child.replace_expressions(replacements))
         return clone
 
-    def get_refs(self):
+    def get_refs(self) -> set[Any]:
         refs = set()
         for child in self.children:
             refs |= child.get_refs()
         return refs
 
     @classmethod
-    def _contains_aggregate(cls, obj):
+    def _contains_aggregate(cls, obj: Any) -> bool:
         if isinstance(obj, tree.Node):
             return any(cls._contains_aggregate(c) for c in obj.children)
         return obj.contains_aggregate
 
     @cached_property
-    def contains_aggregate(self):
+    def contains_aggregate(self) -> bool:
         return self._contains_aggregate(self)
 
     @classmethod
-    def _contains_over_clause(cls, obj):
+    def _contains_over_clause(cls, obj: Any) -> bool:
         if isinstance(obj, tree.Node):
             return any(cls._contains_over_clause(c) for c in obj.children)
         return obj.contains_over_clause
 
     @cached_property
-    def contains_over_clause(self):
+    def contains_over_clause(self) -> bool:
         return self._contains_over_clause(self)
 
     @property
-    def is_summary(self):
+    def is_summary(self) -> bool:
         return any(child.is_summary for child in self.children)
 
     @staticmethod
-    def _resolve_leaf(expr, query, *args, **kwargs):
+    def _resolve_leaf(expr: Any, query: Any, *args: Any, **kwargs: Any) -> Any:
         if hasattr(expr, "resolve_expression"):
             expr = expr.resolve_expression(query, *args, **kwargs)
         return expr
 
     @classmethod
-    def _resolve_node(cls, node, query, *args, **kwargs):
+    def _resolve_node(cls, node: Any, query: Any, *args: Any, **kwargs: Any) -> None:
         if hasattr(node, "children"):
             for child in node.children:
                 cls._resolve_node(child, query, *args, **kwargs)
@@ -273,23 +284,25 @@ class WhereNode(tree.Node):
         if hasattr(node, "rhs"):
             node.rhs = cls._resolve_leaf(node.rhs, query, *args, **kwargs)
 
-    def resolve_expression(self, *args, **kwargs):
+    def resolve_expression(self, *args: Any, **kwargs: Any) -> WhereNode:
         clone = self.clone()
         clone._resolve_node(clone, *args, **kwargs)
         clone.resolved = True
         return clone
 
     @cached_property
-    def output_field(self):
+    def output_field(self) -> Any:
         from plain.models.fields import BooleanField
 
         return BooleanField()
 
     @property
-    def _output_field_or_none(self):
+    def _output_field_or_none(self) -> Any:
         return self.output_field
 
-    def select_format(self, compiler, sql, params):
+    def select_format(
+        self, compiler: SQLCompiler, sql: str, params: list[Any]
+    ) -> tuple[str, list[Any]]:
         # Wrap filters with a CASE WHEN expression if a database backend
         # (e.g. Oracle) doesn't support boolean expression in SELECT or GROUP
         # BY list.
@@ -297,13 +310,13 @@ class WhereNode(tree.Node):
             sql = f"CASE WHEN {sql} THEN 1 ELSE 0 END"
         return sql, params
 
-    def get_db_converters(self, connection):
+    def get_db_converters(self, connection: BaseDatabaseWrapper) -> list[Any]:
         return self.output_field.get_db_converters(connection)
 
-    def get_lookup(self, lookup):
+    def get_lookup(self, lookup: str) -> Any:
         return self.output_field.get_lookup(lookup)
 
-    def leaves(self):
+    def leaves(self) -> Any:
         for child in self.children:
             if isinstance(child, WhereNode):
                 yield from child.leaves()
@@ -317,7 +330,11 @@ class NothingNode:
     contains_aggregate = False
     contains_over_clause = False
 
-    def as_sql(self, compiler=None, connection=None):
+    def as_sql(
+        self,
+        compiler: SQLCompiler | None = None,
+        connection: BaseDatabaseWrapper | None = None,
+    ) -> tuple[str, list[Any]]:
         raise EmptyResultSet
 
 
@@ -326,11 +343,15 @@ class ExtraWhere:
     contains_aggregate = False
     contains_over_clause = False
 
-    def __init__(self, sqls, params):
+    def __init__(self, sqls: list[str], params: list[Any] | None):
         self.sqls = sqls
         self.params = params
 
-    def as_sql(self, compiler=None, connection=None):
+    def as_sql(
+        self,
+        compiler: SQLCompiler | None = None,
+        connection: BaseDatabaseWrapper | None = None,
+    ) -> tuple[str, list[Any]]:
         sqls = [f"({sql})" for sql in self.sqls]
         return " AND ".join(sqls), list(self.params or ())
 
@@ -341,14 +362,18 @@ class SubqueryConstraint:
     contains_aggregate = False
     contains_over_clause = False
 
-    def __init__(self, alias, columns, targets, query_object):
+    def __init__(
+        self, alias: str, columns: list[str], targets: list[Any], query_object: Any
+    ):
         self.alias = alias
         self.columns = columns
         self.targets = targets
         query_object.clear_ordering(clear_default=True)
         self.query_object = query_object
 
-    def as_sql(self, compiler, connection):
+    def as_sql(
+        self, compiler: SQLCompiler, connection: BaseDatabaseWrapper
+    ) -> tuple[str, list[Any]]:
         query = self.query_object
         query.set_values(self.targets)
         query_compiler = query.get_compiler()

plain/models/test/pytest.py

@@ -1,4 +1,8 @@
+from __future__ import annotations
+
 import re
+from collections.abc import Generator
+from typing import Any
 
 import pytest
 
@@ -15,25 +19,25 @@ from .utils import (
 
 
 @pytest.fixture(autouse=True)
-def _db_disabled():
+def _db_disabled() -> Generator[None, None, None]:
     """
     Every test should use this fixture by default to prevent
     access to the normal database.
     """
 
-    def cursor_disabled(self):
+    def cursor_disabled(self: Any) -> None:
         pytest.fail("Database access not allowed without the `db` fixture")
 
-    BaseDatabaseWrapper._enabled_cursor = BaseDatabaseWrapper.cursor
-    BaseDatabaseWrapper.cursor = cursor_disabled
+    BaseDatabaseWrapper._enabled_cursor = BaseDatabaseWrapper.cursor  # type: ignore[attr-defined]
+    BaseDatabaseWrapper.cursor = cursor_disabled  # type: ignore[method-assign]
 
     yield
 
-    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._enabled_cursor
+    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._enabled_cursor  # type: ignore[method-assign]
 
 
 @pytest.fixture(scope="session")
-def setup_db(request):
+def setup_db(request: Any) -> Generator[None, None, None]:
     """
     This fixture is called automatically by `db`,
     so a test database will only be setup if the `db` fixture is used.
@@ -58,19 +62,19 @@ def setup_db(request):
 
 
 @pytest.fixture
-def db(setup_db, request):
+def db(setup_db: Any, request: Any) -> Generator[None, None, None]:
     if "isolated_db" in request.fixturenames:
         pytest.fail("The 'db' and 'isolated_db' fixtures cannot be used together")
 
     # Set .cursor() back to the original implementation to unblock it
-    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._enabled_cursor
+    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._enabled_cursor  # type: ignore[method-assign]
 
     if not db_connection.features.supports_transactions:
         pytest.fail("Database does not support transactions")
 
     with suppress_db_tracing():
         atomic = transaction.atomic()
-        atomic._from_testcase = True  # TODO remove this somehow?
+        atomic._from_testcase = True  # type: ignore[attr-defined]  # TODO remove this somehow?
         atomic.__enter__()
 
     yield
@@ -90,7 +94,7 @@ def db(setup_db, request):
 
 
 @pytest.fixture
-def isolated_db(request):
+def isolated_db(request: Any) -> Generator[None, None, None]:
     """
     Create and destroy a unique test database for each test, using a prefix
     derived from the test function name to ensure isolation from the default
@@ -99,7 +103,7 @@ def isolated_db(request):
     if "db" in request.fixturenames:
         pytest.fail("The 'db' and 'isolated_db' fixtures cannot be used together")
     # Set .cursor() back to the original implementation to unblock it
-    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._enabled_cursor
+    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._enabled_cursor  # type: ignore[method-assign]
 
     verbosity = 1
 

plain/models/test/utils.py

@@ -1,14 +1,16 @@
+from __future__ import annotations
+
 from plain.models import db_connection
 from plain.models.otel import suppress_db_tracing
 
 
-def setup_database(*, verbosity, prefix=""):
+def setup_database(*, verbosity: int, prefix: str = "") -> str:
     old_name = db_connection.settings_dict["NAME"]
     with suppress_db_tracing():
         db_connection.creation.create_test_db(verbosity=verbosity, prefix=prefix)
     return old_name
 
 
-def teardown_database(old_name, verbosity):
+def teardown_database(old_name: str, verbosity: int) -> None:
     with suppress_db_tracing():
         db_connection.creation.destroy_test_db(old_name, verbosity)

plain/models/transaction.py

@@ -1,7 +1,13 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Generator
 from contextlib import ContextDecorator, contextmanager
+from typing import Any, TypeVar
 
 from plain.models.db import DatabaseError, Error, ProgrammingError, db_connection
 
+F = TypeVar("F", bound=Callable[..., Any])
+
 
 class TransactionManagementError(ProgrammingError):
     """Transaction management is used improperly."""
@@ -10,7 +16,7 @@ class TransactionManagementError(ProgrammingError):
 
 
 @contextmanager
-def mark_for_rollback_on_error():
+def mark_for_rollback_on_error() -> Generator[None, None, None]:
     """
     Internal low-level utility to mark a transaction as "needs rollback" when
     an exception is raised while not enforcing the enclosed block to be in a
@@ -36,7 +42,7 @@ def mark_for_rollback_on_error():
         raise
 
 
-def on_commit(func, robust=False):
+def on_commit(func: Callable[[], Any], robust: bool = False) -> None:
     """
     Register `func` to be called when the current transaction is committed.
     If the current transaction is rolled back, `func` will not be called.
@@ -83,12 +89,12 @@ class Atomic(ContextDecorator):
     This is a private API.
     """
 
-    def __init__(self, savepoint, durable):
+    def __init__(self, savepoint: bool, durable: bool) -> None:
         self.savepoint = savepoint
         self.durable = durable
         self._from_testcase = False
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         if (
             self.durable
             and db_connection.atomic_blocks
@@ -127,7 +133,12 @@ class Atomic(ContextDecorator):
         if db_connection.in_atomic_block:
             db_connection.atomic_blocks.append(self)
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: Any,
+    ) -> None:
         if db_connection.in_atomic_block:
             db_connection.atomic_blocks.pop()
 
@@ -217,8 +228,10 @@ class Atomic(ContextDecorator):
                     db_connection.in_atomic_block = False
 
 
-def atomic(func=None, *, savepoint=True, durable=False):
+def atomic(
+    func: F | None = None, *, savepoint: bool = True, durable: bool = False
+) -> F | Atomic:
     """Create an atomic transaction context or decorator."""
     if callable(func):
-        return Atomic(savepoint, durable)(func)
+        return Atomic(savepoint, durable)(func)  # type: ignore[return-value]
     return Atomic(savepoint, durable)

plain/models/utils.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 import functools
 from collections import namedtuple
+from collections.abc import Generator
+from typing import Any
 
 
-def make_model_tuple(model):
+def make_model_tuple(model: Any) -> tuple[str, str]:
     """
     Take a model or a string of the form "package_label.ModelName" and return a
     corresponding ("package_label", "modelname") tuple. If a tuple is passed in,
@@ -15,7 +19,10 @@ def make_model_tuple(model):
             package_label, model_name = model.split(".")
             model_tuple = package_label, model_name.lower()
         else:
-            model_tuple = model._meta.package_label, model._meta.model_name
+            model_tuple = (
+                model.model_options.package_label,
+                model.model_options.model_name,
+            )
         assert len(model_tuple) == 2
         return model_tuple
     except (ValueError, AssertionError):
@@ -25,7 +32,9 @@ def make_model_tuple(model):
         )
 
 
-def resolve_callables(mapping):
+def resolve_callables(
+    mapping: dict[str, Any],
+) -> Generator[tuple[str, Any], None, None]:
     """
     Generate key/value pairs for the given mapping where the values are
     evaluated if they're callable.
@@ -34,15 +43,17 @@ def resolve_callables(mapping):
         yield k, v() if callable(v) else v
 
 
-def unpickle_named_row(names, values):
+def unpickle_named_row(
+    names: tuple[str, ...], values: tuple[Any, ...]
+) -> tuple[Any, ...]:
     return create_namedtuple_class(*names)(*values)
 
 
 @functools.lru_cache
-def create_namedtuple_class(*names):
+def create_namedtuple_class(*names: str) -> type[tuple[Any, ...]]:
     # Cache type() with @lru_cache since it's too slow to be called for every
     # QuerySet evaluation.
-    def __reduce__(self):
+    def __reduce__(self: Any) -> tuple[Any, tuple[tuple[str, ...], tuple[Any, ...]]]:
         return unpickle_named_row, (names, tuple(self))
 
     return type(