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

plain/models/backends/sqlite3/schema.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import copy
 from decimal import Decimal
+from typing import TYPE_CHECKING, Any
 
-from plain.models import register_model
+from plain.models import Options
 from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
 from plain.models.backends.ddl_references import Statement
 from plain.models.backends.utils import strip_quotes
@@ -10,6 +13,13 @@ from plain.models.db import NotSupportedError
 from plain.models.registry import ModelsRegistry
 from plain.models.transaction import atomic
 
+if TYPE_CHECKING:
+    from plain.models.base import Model
+    from plain.models.constraints import BaseConstraint
+    from plain.models.fields import Field
+    from plain.models.fields.related import ManyToManyField
+    from plain.models.fields.reverse_related import ManyToManyRel
+
 
 class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     sql_delete_table = "DROP TABLE %(table)s"
@@ -22,7 +32,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     sql_create_unique = "CREATE UNIQUE INDEX %(name)s ON %(table)s (%(columns)s)"
     sql_delete_unique = "DROP INDEX %(name)s"
 
-    def __enter__(self):
+    def __enter__(self) -> DatabaseSchemaEditor:
         # Some SQLite schema alterations need foreign key constraints to be
         # disabled. Enforce it here for the duration of the schema edition.
         if not self.connection.disable_constraint_checking():
@@ -35,19 +45,19 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             )
         return super().__enter__()
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         self.connection.check_constraints()
         super().__exit__(exc_type, exc_value, traceback)
         self.connection.enable_constraint_checking()
 
-    def quote_value(self, value):
+    def quote_value(self, value: Any) -> str:
         # The backend "mostly works" without this function and there are use
         # cases for compiling Python without the sqlite3 libraries (e.g.
         # security hardening).
         try:
             import sqlite3
 
-            value = sqlite3.adapt(value)
+            value = sqlite3.adapt(value)  # type: ignore[call-overload]
         except ImportError:
             pass
         except sqlite3.ProgrammingError:
@@ -71,12 +81,12 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                 f"Cannot quote parameter value {value!r} of type {type(value)}"
             )
 
-    def prepare_default(self, value):
+    def prepare_default(self, value: Any) -> str:
         return self.quote_value(value)
 
     def _is_referenced_by_fk_constraint(
-        self, table_name, column_name=None, ignore_self=False
-    ):
+        self, table_name: str, column_name: str | None = None, ignore_self: bool = False
+    ) -> bool:
         """
         Return whether or not the provided table name is referenced by another
         one. If `column_name` is specified, only references pointing to that
@@ -98,8 +108,12 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         return False
 
     def alter_db_table(
-        self, model, old_db_table, new_db_table, disable_constraints=True
-    ):
+        self,
+        model: type[Model],
+        old_db_table: str,
+        new_db_table: str,
+        disable_constraints: bool = True,
+    ) -> None:
         if (
             not self.connection.features.supports_atomic_references_rename
             and disable_constraints
@@ -117,11 +131,17 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             super().alter_db_table(model, old_db_table, new_db_table)
 
-    def alter_field(self, model, old_field, new_field, strict=False):
+    def alter_field(
+        self,
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        strict: bool = False,
+    ) -> None:
         if not self._field_should_be_altered(old_field, new_field):
             return
         old_field_name = old_field.name
-        table_name = model._meta.db_table
+        table_name = model.model_options.db_table
         _, old_column_name = old_field.get_attname_column()
         if (
             new_field.name != old_field_name
@@ -132,7 +152,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         ):
             if self.connection.in_atomic_block:
                 raise NotSupportedError(
-                    f"Renaming the {model._meta.db_table!r}.{old_field_name!r} column while in a transaction is not "
+                    f"Renaming the {model.model_options.db_table!r}.{old_field_name!r} column while in a transaction is not "
                     "supported on SQLite < 3.26 because it would break referential "
                     "integrity. Try adding `atomic = False` to the Migration class."
                 )
@@ -168,8 +188,12 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             super().alter_field(model, old_field, new_field, strict=strict)
 
     def _remake_table(
-        self, model, create_field=None, delete_field=None, alter_fields=None
-    ):
+        self,
+        model: type[Model],
+        create_field: Field | None = None,
+        delete_field: Field | None = None,
+        alter_fields: list[tuple[Field, Field]] | None = None,
+    ) -> None:
         """
         Shortcut to transform a model from old_model into new_model
 
@@ -189,19 +213,19 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # Self-referential fields must be recreated rather than copied from
         # the old model to ensure their remote_field.field_name doesn't refer
         # to an altered field.
-        def is_self_referential(f):
-            return f.is_relation and f.remote_field.model is model
+        def is_self_referential(f: Field) -> bool:
+            return f.is_relation and f.remote_field.model is model  # type: ignore[attr-defined]
 
         # Work out the new fields dict / mapping
         body = {
             f.name: f.clone() if is_self_referential(f) else f
-            for f in model._meta.local_concrete_fields
+            for f in model._model_meta.local_concrete_fields
         }
         # Since mapping might mix column names and default values,
         # its values must be already quoted.
         mapping = {
             f.column: self.quote_name(f.column)
-            for f in model._meta.local_concrete_fields
+            for f in model._model_meta.local_concrete_fields
         }
         # If any of the new or altered fields is introducing a new PK,
         # remove the old one
@@ -248,13 +272,13 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # Work inside a new app registry
         models_registry = ModelsRegistry()
 
-        indexes = model._meta.indexes
+        indexes = model.model_options.indexes
         if delete_field:
             indexes = [
                 index for index in indexes if delete_field.name not in index.fields
             ]
 
-        constraints = list(model._meta.constraints)
+        constraints = list(model.model_options.constraints)
 
         # Provide isolated instances of the fields to the new model body so
         # that the existing model's internals aren't interfered with when
@@ -266,32 +290,33 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # table and solely exists for foreign key reference resolution purposes.
         # This wouldn't be required if the schema editor was operating on model
         # states instead of rendered models.
-        meta_contents = {
-            "package_label": model._meta.package_label,
-            "db_table": model._meta.db_table,
-            "indexes": indexes,
-            "constraints": constraints,
-            "models_registry": models_registry,
-        }
-        meta = type("Meta", (), meta_contents)
-        body_copy["Meta"] = meta
+        meta_options = Options(
+            package_label=model.model_options.package_label,
+            db_table=model.model_options.db_table,
+            indexes=indexes,
+            constraints=constraints,
+        )
+        body_copy["model_options"] = meta_options
         body_copy["__module__"] = model.__module__
-        register_model(type(model._meta.object_name, model.__bases__, body_copy))
+        temp_model: type[Model] = type(  # type: ignore[assignment]
+            model.model_options.object_name, model.__bases__, body_copy
+        )
+        models_registry.register_model(model.model_options.package_label, temp_model)
 
         # Construct a model with a renamed table name.
         body_copy = copy.deepcopy(body)
-        meta_contents = {
-            "package_label": model._meta.package_label,
-            "db_table": f"new__{strip_quotes(model._meta.db_table)}",
-            "indexes": indexes,
-            "constraints": constraints,
-            "models_registry": models_registry,
-        }
-        meta = type("Meta", (), meta_contents)
-        body_copy["Meta"] = meta
+        meta_options = Options(
+            package_label=model.model_options.package_label,
+            db_table=f"new__{strip_quotes(model.model_options.db_table)}",
+            indexes=indexes,
+            constraints=constraints,
+        )
+        body_copy["model_options"] = meta_options
         body_copy["__module__"] = model.__module__
-        new_model = type(f"New{model._meta.object_name}", model.__bases__, body_copy)
-        register_model(new_model)
+        new_model: type[Model] = type(  # type: ignore[assignment]
+            f"New{model.model_options.object_name}", model.__bases__, body_copy
+        )
+        models_registry.register_model(model.model_options.package_label, new_model)
 
         # Create a new table with the updated schema.
         self.create_model(new_model)
@@ -299,10 +324,10 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # Copy data from the old table into the new table
         self.execute(
             "INSERT INTO {} ({}) SELECT {} FROM {}".format(
-                self.quote_name(new_model._meta.db_table),
+                self.quote_name(new_model.model_options.db_table),
                 ", ".join(self.quote_name(x) for x in mapping),
                 ", ".join(mapping.values()),
-                self.quote_name(model._meta.db_table),
+                self.quote_name(model.model_options.db_table),
             )
         )
 
@@ -311,9 +336,9 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
         # Rename the new table to take way for the old
         self.alter_db_table(
-            new_model,
-            new_model._meta.db_table,
-            model._meta.db_table,
+            new_model,  # type: ignore[arg-type]
+            new_model.model_options.db_table,
+            model.model_options.db_table,
             disable_constraints=False,
         )
 
@@ -325,7 +350,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         if restore_pk_field:
             restore_pk_field.primary_key = True
 
-    def delete_model(self, model, handle_autom2m=True):
+    def delete_model(self, model: type[Model], handle_autom2m: bool = True) -> None:
         if handle_autom2m:
             super().delete_model(model)
         else:
@@ -333,17 +358,17 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             self.execute(
                 self.sql_delete_table
                 % {
-                    "table": self.quote_name(model._meta.db_table),
+                    "table": self.quote_name(model.model_options.db_table),
                 }
             )
             # Remove all deferred statements referencing the deleted table.
             for sql in list(self.deferred_sql):
                 if isinstance(sql, Statement) and sql.references_table(
-                    model._meta.db_table
+                    model.model_options.db_table
                 ):
                     self.deferred_sql.remove(sql)
 
-    def add_field(self, model, field):
+    def add_field(self, model: type[Model], field: Field) -> None:
         """Create a field on a model."""
         if (
             # Primary keys are not supported in ALTER TABLE
@@ -360,7 +385,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             super().add_field(model, field)
 
-    def remove_field(self, model, field):
+    def remove_field(self, model: type[Model], field: Field) -> None:
         """
         Remove a field from a model. Usually involves deleting a column,
         but for M2Ms may involve deleting a table.
@@ -374,8 +399,8 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             # Primary keys, unique fields, indexed fields, and foreign keys are
             # not supported in ALTER TABLE DROP COLUMN.
             and not field.primary_key
-            and not (field.remote_field and field.db_index)
-            and not (field.remote_field and field.db_constraint)
+            and not (field.remote_field and field.db_index)  # type: ignore[attr-defined]
+            and not (field.remote_field and field.db_constraint)  # type: ignore[attr-defined]
         ):
             super().remove_field(model, field)
         # For everything else, remake.
@@ -387,15 +412,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:
         """Perform a "physical" (non-ManyToMany) field update."""
         # Use "ALTER TABLE ... RENAME COLUMN" if only the column name
         # changed and there aren't any constraints.
@@ -405,14 +430,14 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             and self.column_sql(model, old_field) == self.column_sql(model, new_field)
             and not (
                 old_field.remote_field
-                and old_field.db_constraint
+                and old_field.db_constraint  # type: ignore[attr-defined]
                 or new_field.remote_field
-                and new_field.db_constraint
+                and new_field.db_constraint  # type: ignore[attr-defined]
             )
         ):
             return self.execute(
                 self._rename_field_sql(
-                    model._meta.db_table, old_field, new_field, new_type
+                    model.model_options.db_table, old_field, new_field, new_type
                 )
             )
         # Alter by remaking table
@@ -424,8 +449,8 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             old_type != new_type or old_collation != new_collation
         ):
             related_models = set()
-            opts = new_field.model._meta
-            for remote_field in opts.related_objects:
+            meta = new_field.model._model_meta
+            for remote_field in meta.related_objects:
                 # Ignore self-relationship since the table was already rebuilt.
                 if remote_field.related_model == model:
                     continue
@@ -433,44 +458,54 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                     if remote_field.field_name == new_field.name:
                         related_models.add(remote_field.related_model)
             if new_field.primary_key:
-                for many_to_many in opts.many_to_many:
+                for many_to_many in meta.many_to_many:
                     # Ignore self-relationship since the table was already rebuilt.
                     if many_to_many.related_model == model:
                         continue
             for related_model in related_models:
                 self._remake_table(related_model)
 
-    def _alter_many_to_many(self, model, old_field, new_field, strict):
+    def _alter_many_to_many(
+        self,
+        model: type[Model],
+        old_field: ManyToManyField,
+        new_field: ManyToManyField,
+        strict: bool,
+    ) -> None:
         """Alter M2Ms to repoint their to= endpoints."""
+        # Type narrow for ManyToManyField.remote_field
+        old_rel: ManyToManyRel = old_field.remote_field  # type: ignore[assignment]
+        new_rel: ManyToManyRel = new_field.remote_field  # type: ignore[assignment]
+
         if (
-            old_field.remote_field.through._meta.db_table
-            == new_field.remote_field.through._meta.db_table
+            old_rel.through.model_options.db_table
+            == new_rel.through.model_options.db_table
         ):
             # The field name didn't change, but some options did, so we have to
             # propagate this altering.
             self._remake_table(
-                old_field.remote_field.through,
+                old_rel.through,
                 alter_fields=[
                     (
                         # The field that points to the target model is needed,
                         # so that table can be remade with the new m2m field -
                         # this is m2m_reverse_field_name().
-                        old_field.remote_field.through._meta.get_field(
-                            old_field.m2m_reverse_field_name()
+                        old_rel.through._model_meta.get_field(
+                            old_field.m2m_reverse_field_name()  # type: ignore[attr-defined]
                         ),
-                        new_field.remote_field.through._meta.get_field(
-                            new_field.m2m_reverse_field_name()
+                        new_rel.through._model_meta.get_field(
+                            new_field.m2m_reverse_field_name()  # type: ignore[attr-defined]
                         ),
                     ),
                     (
                         # The field that points to the model itself is needed,
                         # so that table can be remade with the new self field -
                         # this is m2m_field_name().
-                        old_field.remote_field.through._meta.get_field(
-                            old_field.m2m_field_name()
+                        old_rel.through._model_meta.get_field(
+                            old_field.m2m_field_name()  # type: ignore[attr-defined]
                         ),
-                        new_field.remote_field.through._meta.get_field(
-                            new_field.m2m_field_name()
+                        new_rel.through._model_meta.get_field(
+                            new_field.m2m_field_name()  # type: ignore[attr-defined]
                         ),
                     ),
                 ],
@@ -478,32 +513,32 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             return
 
         # Make a new through table
-        self.create_model(new_field.remote_field.through)
+        self.create_model(new_rel.through)
         # Copy the data across
         self.execute(
             "INSERT INTO {} ({}) SELECT {} FROM {}".format(
-                self.quote_name(new_field.remote_field.through._meta.db_table),
+                self.quote_name(new_rel.through.model_options.db_table),
                 ", ".join(
                     [
                         "id",
-                        new_field.m2m_column_name(),
-                        new_field.m2m_reverse_name(),
+                        new_field.m2m_column_name(),  # type: ignore[attr-defined]
+                        new_field.m2m_reverse_name(),  # type: ignore[attr-defined]
                     ]
                 ),
                 ", ".join(
                     [
                         "id",
-                        old_field.m2m_column_name(),
-                        old_field.m2m_reverse_name(),
+                        old_field.m2m_column_name(),  # type: ignore[attr-defined]
+                        old_field.m2m_reverse_name(),  # type: ignore[attr-defined]
                     ]
                 ),
-                self.quote_name(old_field.remote_field.through._meta.db_table),
+                self.quote_name(old_rel.through.model_options.db_table),
             )
         )
         # Delete the old through table
-        self.delete_model(old_field.remote_field.through)
+        self.delete_model(old_rel.through)
 
-    def add_constraint(self, model, constraint):
+    def add_constraint(self, model: type[Model], constraint: BaseConstraint) -> None:
         if isinstance(constraint, UniqueConstraint) and (
             constraint.condition
             or constraint.contains_expressions
@@ -514,7 +549,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             self._remake_table(model)
 
-    def remove_constraint(self, model, constraint):
+    def remove_constraint(self, model: type[Model], constraint: BaseConstraint) -> None:
         if isinstance(constraint, UniqueConstraint) and (
             constraint.condition
             or constraint.contains_expressions
@@ -525,5 +560,5 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             self._remake_table(model)
 
-    def _collate_sql(self, collation):
+    def _collate_sql(self, collation: str) -> str:
         return "COLLATE " + collation