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

plain/models/backends/base/validation.py

@@ -1,13 +1,22 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.fields import Field
+
+
 class BaseDatabaseValidation:
     """Encapsulate backend-specific validation."""
 
-    def __init__(self, connection):
+    def __init__(self, connection: BaseDatabaseWrapper) -> None:
         self.connection = connection
 
-    def preflight(self):
+    def preflight(self) -> list[Any]:
         return []
 
-    def check_field(self, field, **kwargs):
+    def check_field(self, field: Field, **kwargs: Any) -> list[Any]:
         errors = []
         # Backends may implement a check_field_type() method.
         if (
@@ -19,7 +28,7 @@ class BaseDatabaseValidation:
             # Ignore fields with unsupported features.
             db_supports_all_required_features = all(
                 getattr(self.connection.features, feature, False)
-                for feature in field.model._meta.required_db_features
+                for feature in field.model.model_options.required_db_features
             )
             if db_supports_all_required_features:
                 field_type = field.db_type(self.connection)

plain/models/backends/ddl_references.py

@@ -3,40 +3,49 @@ Helpers to manipulate deferred DDL statements that might need to be adjusted or
 discarded within when executing a migration.
 """
 
+from __future__ import annotations
+
+from collections.abc import Callable
 from copy import deepcopy
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from plain.models.sql.compiler import SQLCompiler
 
 
 class Reference:
     """Base class that defines the reference interface."""
 
-    def references_table(self, table):
+    def references_table(self, table: str) -> bool:
         """
         Return whether or not this instance references the specified table.
         """
         return False
 
-    def references_column(self, table, column):
+    def references_column(self, table: str, column: str) -> bool:
         """
         Return whether or not this instance references the specified column.
         """
         return False
 
-    def rename_table_references(self, old_table, new_table):
+    def rename_table_references(self, old_table: str, new_table: str) -> None:
         """
         Rename all references to the old_name to the new_table.
         """
         pass
 
-    def rename_column_references(self, table, old_column, new_column):
+    def rename_column_references(
+        self, table: str, old_column: str, new_column: str
+    ) -> None:
         """
         Rename all references to the old_column to the new_column.
         """
         pass
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{self.__class__.__name__} {str(self)!r}>"
 
-    def __str__(self):
+    def __str__(self) -> str:
         raise NotImplementedError(
             "Subclasses must define how they should be converted to string."
         )
@@ -45,32 +54,34 @@ class Reference:
 class Table(Reference):
     """Hold a reference to a table."""
 
-    def __init__(self, table, quote_name):
+    def __init__(self, table: str, quote_name: Callable[[str], str]) -> None:
         self.table = table
         self.quote_name = quote_name
 
-    def references_table(self, table):
+    def references_table(self, table: str) -> bool:
         return self.table == table
 
-    def rename_table_references(self, old_table, new_table):
+    def rename_table_references(self, old_table: str, new_table: str) -> None:
         if self.table == old_table:
             self.table = new_table
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.quote_name(self.table)
 
 
 class TableColumns(Table):
     """Base class for references to multiple columns of a table."""
 
-    def __init__(self, table, columns):
+    def __init__(self, table: str, columns: list[str]) -> None:
         self.table = table
         self.columns = columns
 
-    def references_column(self, table, column):
+    def references_column(self, table: str, column: str) -> bool:
         return self.table == table and column in self.columns
 
-    def rename_column_references(self, table, old_column, new_column):
+    def rename_column_references(
+        self, table: str, old_column: str, new_column: str
+    ) -> None:
         if self.table == table:
             for index, column in enumerate(self.columns):
                 if column == old_column:
@@ -80,13 +91,19 @@ class TableColumns(Table):
 class Columns(TableColumns):
     """Hold a reference to one or many columns."""
 
-    def __init__(self, table, columns, quote_name, col_suffixes=()):
+    def __init__(
+        self,
+        table: str,
+        columns: list[str],
+        quote_name: Callable[[str], str],
+        col_suffixes: tuple[str, ...] = (),
+    ) -> None:
         self.quote_name = quote_name
         self.col_suffixes = col_suffixes
         super().__init__(table, columns)
 
-    def __str__(self):
-        def col_str(column, idx):
+    def __str__(self) -> str:
+        def col_str(column: str, idx: int) -> str:
             col = self.quote_name(column)
             try:
                 suffix = self.col_suffixes[idx]
@@ -104,22 +121,35 @@ class Columns(TableColumns):
 class IndexName(TableColumns):
     """Hold a reference to an index name."""
 
-    def __init__(self, table, columns, suffix, create_index_name):
+    def __init__(
+        self,
+        table: str,
+        columns: list[str],
+        suffix: str,
+        create_index_name: Callable[[str, list[str], str], str],
+    ) -> None:
         self.suffix = suffix
         self.create_index_name = create_index_name
         super().__init__(table, columns)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.create_index_name(self.table, self.columns, self.suffix)
 
 
 class IndexColumns(Columns):
-    def __init__(self, table, columns, quote_name, col_suffixes=(), opclasses=()):
+    def __init__(
+        self,
+        table: str,
+        columns: list[str],
+        quote_name: Callable[[str], str],
+        col_suffixes: tuple[str, ...] = (),
+        opclasses: tuple[str, ...] = (),
+    ) -> None:
         self.opclasses = opclasses
         super().__init__(table, columns, quote_name, col_suffixes)
 
-    def __str__(self):
-        def col_str(column, idx):
+    def __str__(self) -> str:
+        def col_str(column: str, idx: int) -> str:
             # Index.__init__() guarantees that self.opclasses is the same
             # length as self.columns.
             col = f"{self.quote_name(column)} {self.opclasses[idx]}"
@@ -141,13 +171,13 @@ class ForeignKeyName(TableColumns):
 
     def __init__(
         self,
-        from_table,
-        from_columns,
-        to_table,
-        to_columns,
-        suffix_template,
-        create_fk_name,
-    ):
+        from_table: str,
+        from_columns: list[str],
+        to_table: str,
+        to_columns: list[str],
+        suffix_template: str,
+        create_fk_name: Callable[[str, list[str], str], str],
+    ) -> None:
         self.to_reference = TableColumns(to_table, to_columns)
         self.suffix_template = suffix_template
         self.create_fk_name = create_fk_name
@@ -156,25 +186,27 @@ class ForeignKeyName(TableColumns):
             from_columns,
         )
 
-    def references_table(self, table):
+    def references_table(self, table: str) -> bool:
         return super().references_table(table) or self.to_reference.references_table(
             table
         )
 
-    def references_column(self, table, column):
+    def references_column(self, table: str, column: str) -> bool:
         return super().references_column(
             table, column
         ) or self.to_reference.references_column(table, column)
 
-    def rename_table_references(self, old_table, new_table):
+    def rename_table_references(self, old_table: str, new_table: str) -> None:
         super().rename_table_references(old_table, new_table)
         self.to_reference.rename_table_references(old_table, new_table)
 
-    def rename_column_references(self, table, old_column, new_column):
+    def rename_column_references(
+        self, table: str, old_column: str, new_column: str
+    ) -> None:
         super().rename_column_references(table, old_column, new_column)
         self.to_reference.rename_column_references(table, old_column, new_column)
 
-    def __str__(self):
+    def __str__(self) -> str:
         suffix = self.suffix_template % {
             "to_table": self.to_reference.table,
             "to_column": self.to_reference.columns[0],
@@ -191,38 +223,46 @@ class Statement(Reference):
     that is removed
     """
 
-    def __init__(self, template, **parts):
+    def __init__(self, template: str, **parts: Any) -> None:
         self.template = template
         self.parts = parts
 
-    def references_table(self, table):
+    def references_table(self, table: str) -> bool:
         return any(
             hasattr(part, "references_table") and part.references_table(table)
             for part in self.parts.values()
         )
 
-    def references_column(self, table, column):
+    def references_column(self, table: str, column: str) -> bool:
         return any(
             hasattr(part, "references_column") and part.references_column(table, column)
             for part in self.parts.values()
         )
 
-    def rename_table_references(self, old_table, new_table):
+    def rename_table_references(self, old_table: str, new_table: str) -> None:
         for part in self.parts.values():
             if hasattr(part, "rename_table_references"):
                 part.rename_table_references(old_table, new_table)
 
-    def rename_column_references(self, table, old_column, new_column):
+    def rename_column_references(
+        self, table: str, old_column: str, new_column: str
+    ) -> None:
         for part in self.parts.values():
             if hasattr(part, "rename_column_references"):
                 part.rename_column_references(table, old_column, new_column)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.template % self.parts
 
 
 class Expressions(TableColumns):
-    def __init__(self, table, expressions, compiler, quote_value):
+    def __init__(
+        self,
+        table: str,
+        expressions: Any,
+        compiler: SQLCompiler,
+        quote_value: Callable[[Any], str],
+    ) -> None:
         self.compiler = compiler
         self.expressions = expressions
         self.quote_value = quote_value
@@ -232,13 +272,15 @@ class Expressions(TableColumns):
         ]
         super().__init__(table, columns)
 
-    def rename_table_references(self, old_table, new_table):
+    def rename_table_references(self, old_table: str, new_table: str) -> None:
         if self.table != old_table:
             return
         self.expressions = self.expressions.relabeled_clone({old_table: new_table})
         super().rename_table_references(old_table, new_table)
 
-    def rename_column_references(self, table, old_column, new_column):
+    def rename_column_references(
+        self, table: str, old_column: str, new_column: str
+    ) -> None:
         if self.table != table:
             return
         expressions = deepcopy(self.expressions)
@@ -249,7 +291,7 @@ class Expressions(TableColumns):
             self.columns.append(col.target.column)
         self.expressions = expressions
 
-    def __str__(self):
+    def __str__(self) -> str:
         sql, params = self.compiler.compile(self.expressions)
         params = map(self.quote_value, params)
         return sql % tuple(params)

plain/models/backends/mysql/base.py

@@ -4,11 +4,14 @@ MySQL database backend for Plain.
 Requires mysqlclient: https://pypi.org/project/mysqlclient/
 """
 
+from __future__ import annotations
+
 from functools import cached_property
+from typing import Any
 
-import MySQLdb as Database
-from MySQLdb.constants import CLIENT, FIELD_TYPE
-from MySQLdb.converters import conversions
+import MySQLdb as Database  # type: ignore[import-untyped]
+from MySQLdb.constants import CLIENT, FIELD_TYPE  # type: ignore[import-untyped]
+from MySQLdb.converters import conversions  # type: ignore[import-untyped]
 
 from plain.exceptions import ImproperlyConfigured
 from plain.models.backends import utils as backend_utils
@@ -53,10 +56,10 @@ class CursorWrapper:
         4025,  # CHECK constraint failed
     )
 
-    def __init__(self, cursor):
+    def __init__(self, cursor: Any) -> None:
         self.cursor = cursor
 
-    def execute(self, query, args=None):
+    def execute(self, query: str, args: Any = None) -> int:
         try:
             # args is None means no string interpolation
             return self.cursor.execute(query, args)
@@ -67,7 +70,7 @@ class CursorWrapper:
                 raise IntegrityError(*tuple(e.args))
             raise
 
-    def executemany(self, query, args):
+    def executemany(self, query: str, args: Any) -> int:
         try:
             return self.cursor.executemany(query, args)
         except Database.OperationalError as e:
@@ -77,14 +80,14 @@ class CursorWrapper:
                 raise IntegrityError(*tuple(e.args))
             raise
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str) -> Any:
         return getattr(self.cursor, attr)
 
-    def __iter__(self):
+    def __iter__(self) -> Any:
         return iter(self.cursor)
 
 
-class DatabaseWrapper(BaseDatabaseWrapper):
+class MySQLDatabaseWrapper(BaseDatabaseWrapper):
     vendor = "mysql"
     # This dictionary maps Field objects to their associated MySQL column
     # types, as strings. Column-type strings can contain format strings; they'll
@@ -180,11 +183,11 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     ops_class = DatabaseOperations
     validation_class = DatabaseValidation
 
-    def get_database_version(self):
+    def get_database_version(self) -> tuple[int, int, int]:
         return self.mysql_version
 
-    def get_connection_params(self):
-        kwargs = {
+    def get_connection_params(self) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {
             "conv": plain_conversions,
             "charset": "utf8",
         }
@@ -221,7 +224,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         kwargs.update(options)
         return kwargs
 
-    def get_new_connection(self, conn_params):
+    def get_new_connection(self, conn_params: dict[str, Any]) -> Any:
         connection = Database.connect(**conn_params)
         # bytes encoder in mysqlclient doesn't work and was added only to
         # prevent KeyErrors in Plain < 2.0. We can remove this workaround when
@@ -231,7 +234,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             connection.encoders.pop(bytes)
         return connection
 
-    def init_connection_state(self):
+    def init_connection_state(self) -> None:
         super().init_connection_state()
         assignments = []
         if self.features.is_sql_auto_is_null_enabled:
@@ -250,21 +253,21 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             with self.cursor() as cursor:
                 cursor.execute("; ".join(assignments))
 
-    def create_cursor(self, name=None):
+    def create_cursor(self, name: str | None = None) -> CursorWrapper:
         cursor = self.connection.cursor()
         return CursorWrapper(cursor)
 
-    def _rollback(self):
+    def _rollback(self) -> None:
         try:
             BaseDatabaseWrapper._rollback(self)
         except Database.NotSupportedError:
             pass
 
-    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 ``table_names`` for rows with invalid foreign key references."""
         with self.cursor() as cursor:
             if table_names is None:
@@ -295,7 +298,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
                             f"does not have a corresponding value in {referenced_table_name}.{referenced_column_name}."
                         )
 
-    def is_usable(self):
+    def is_usable(self) -> bool:
         try:
             self.connection.ping()
         except Database.Error:
@@ -304,11 +307,11 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             return True
 
     @cached_property
-    def display_name(self):
+    def display_name(self) -> str:
         return "MariaDB" if self.mysql_is_mariadb else "MySQL"
 
     @cached_property
-    def data_type_check_constraints(self):
+    def data_type_check_constraints(self) -> dict[str, str]:
         if self.features.supports_column_check_constraints:
             check_constraints = {
                 "PositiveBigIntegerField": "`%(column)s` >= 0",
@@ -323,7 +326,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         return {}
 
     @cached_property
-    def mysql_server_data(self):
+    def mysql_server_data(self) -> dict[str, Any]:
         with self.temporary_connection() as cursor:
             # Select some server variables and test if the time zone
             # definitions are installed. CONVERT_TZ returns NULL if 'UTC'
@@ -349,11 +352,11 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         }
 
     @cached_property
-    def mysql_server_info(self):
+    def mysql_server_info(self) -> str:
         return self.mysql_server_data["version"]
 
     @cached_property
-    def mysql_version(self):
+    def mysql_version(self) -> tuple[int, int, int]:
         match = server_version_re.match(self.mysql_server_info)
         if not match:
             raise Exception(
@@ -362,10 +365,10 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         return tuple(int(x) for x in match.groups())
 
     @cached_property
-    def mysql_is_mariadb(self):
+    def mysql_is_mariadb(self) -> bool:
         return "mariadb" in self.mysql_server_info.lower()
 
     @cached_property
-    def sql_mode(self):
+    def sql_mode(self) -> set[str]:
         sql_mode = self.mysql_server_data["sql_mode"]
         return set(sql_mode.split(",") if sql_mode else ())

plain/models/backends/mysql/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 = "mysql"
 
     @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]
         env = None
         database = settings_dict["OPTIONS"].get(
@@ -61,7 +66,7 @@ class DatabaseClient(BaseDatabaseClient):
         args.extend(parameters)
         return args, env
 
-    def runshell(self, parameters):
+    def runshell(self, parameters: list[str]) -> None:
         sigint_handler = signal.getsignal(signal.SIGINT)
         try:
             # Allow SIGINT to pass to mysql to abort queries.

plain/models/backends/mysql/compiler.py

@@ -1,10 +1,19 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 from plain.models.exceptions import FieldError, FullResultSet
 from plain.models.expressions import Col
 from plain.models.sql import compiler
 
+if TYPE_CHECKING:
+    from plain.models.sql.compiler import SQLCompiler as BaseSQLCompiler
+
 
 class SQLCompiler(compiler.SQLCompiler):
-    def as_subquery_condition(self, alias, columns, compiler):
+    def as_subquery_condition(
+        self, alias: str, columns: list[str], compiler: BaseSQLCompiler
+    ) -> tuple[str, tuple[Any, ...]]:
         qn = compiler.quote_name_unless_alias
         qn2 = self.connection.ops.quote_name
         sql, params = self.as_sql()
@@ -22,7 +31,7 @@ class SQLInsertCompiler(compiler.SQLInsertCompiler, SQLCompiler):
 
 
 class SQLDeleteCompiler(compiler.SQLDeleteCompiler, SQLCompiler):
-    def as_sql(self):
+    def as_sql(self) -> tuple[str, tuple[Any, ...]]:
         # Prefer the non-standard DELETE FROM syntax over the SQL generated by
         # the SQLDeleteCompiler's default implementation when multiple tables
         # are involved since MySQL/MariaDB will generate a more efficient query
@@ -51,13 +60,13 @@ class SQLDeleteCompiler(compiler.SQLDeleteCompiler, SQLCompiler):
 
 
 class SQLUpdateCompiler(compiler.SQLUpdateCompiler, SQLCompiler):
-    def as_sql(self):
+    def as_sql(self) -> tuple[str, tuple[Any, ...]]:
         update_query, update_params = super().as_sql()
         # MySQL and MariaDB support UPDATE ... ORDER BY syntax.
         if self.query.order_by:
             order_by_sql = []
             order_by_params = []
-            db_table = self.query.get_meta().db_table
+            db_table = self.query.get_model_meta().db_table
             try:
                 for resolved, (sql, params, _) in self.get_order_by():
                     if (

plain/models/backends/mysql/creation.py

@@ -1,10 +1,13 @@
+from __future__ import annotations
+
 import sys
+from typing import Any
 
 from plain.models.backends.base.creation import BaseDatabaseCreation
 
 
 class DatabaseCreation(BaseDatabaseCreation):
-    def sql_table_creation_suffix(self):
+    def sql_table_creation_suffix(self) -> str:
         suffix = []
         test_settings = self.connection.settings_dict["TEST"]
         if test_settings["CHARSET"]:
@@ -13,7 +16,7 @@ class DatabaseCreation(BaseDatabaseCreation):
             suffix.append("COLLATE {}".format(test_settings["COLLATION"]))
         return " ".join(suffix)
 
-    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: