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

plain/models/migrations/operations/special.py

@@ -1,5 +1,14 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, cast
+
 from .base import Operation
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
+    from plain.models.migrations.state import ProjectState
+
 
 class SeparateDatabaseAndState(Operation):
     """
@@ -11,23 +20,33 @@ class SeparateDatabaseAndState(Operation):
 
     serialization_expand_args = ["database_operations", "state_operations"]
 
-    def __init__(self, database_operations=None, state_operations=None):
+    def __init__(
+        self,
+        database_operations: list[Operation] | None = None,
+        state_operations: list[Operation] | None = None,
+    ) -> None:
         self.database_operations = database_operations or []
         self.state_operations = state_operations or []
 
-    def deconstruct(self):
-        kwargs = {}
+    def deconstruct(self) -> tuple[str, list[Any], dict[str, list[Operation]]]:
+        kwargs: dict[str, list[Operation]] = {}
         if self.database_operations:
             kwargs["database_operations"] = self.database_operations
         if self.state_operations:
             kwargs["state_operations"] = self.state_operations
         return (self.__class__.__qualname__, [], kwargs)
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: ProjectState) -> None:
         for state_operation in self.state_operations:
             state_operation.state_forwards(package_label, state)
 
-    def database_forwards(self, package_label, schema_editor, from_state, to_state):
+    def database_forwards(
+        self,
+        package_label: str,
+        schema_editor: BaseDatabaseSchemaEditor,
+        from_state: ProjectState,
+        to_state: ProjectState,
+    ) -> None:
         # We calculate state separately in here since our state functions aren't useful
         for database_operation in self.database_operations:
             to_state = from_state.clone()
@@ -37,7 +56,7 @@ class SeparateDatabaseAndState(Operation):
             )
             from_state = to_state
 
-    def describe(self):
+    def describe(self) -> str:
         return "Custom state/database change combination"
 
 
@@ -49,42 +68,68 @@ class RunSQL(Operation):
     by this SQL change, in case it's custom column/table creation/deletion.
     """
 
-    def __init__(self, sql, *, state_operations=None, elidable=False):
+    def __init__(
+        self,
+        sql: str
+        | list[str | tuple[str, list[Any]]]
+        | tuple[str | tuple[str, list[Any]], ...],
+        *,
+        state_operations: list[Operation] | None = None,
+        elidable: bool = False,
+    ) -> None:
         self.sql = sql
         self.state_operations = state_operations or []
         self.elidable = elidable
 
-    def deconstruct(self):
-        kwargs = {
+    def deconstruct(self) -> tuple[str, list[Any], dict[str, Any]]:
+        kwargs: dict[str, Any] = {
             "sql": self.sql,
         }
         if self.state_operations:
             kwargs["state_operations"] = self.state_operations
         return (self.__class__.__qualname__, [], kwargs)
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: ProjectState) -> None:
         for state_operation in self.state_operations:
             state_operation.state_forwards(package_label, state)
 
-    def database_forwards(self, package_label, schema_editor, from_state, to_state):
+    def database_forwards(
+        self,
+        package_label: str,
+        schema_editor: BaseDatabaseSchemaEditor,
+        from_state: ProjectState,
+        to_state: ProjectState,
+    ) -> None:
         self._run_sql(schema_editor, self.sql)
 
-    def describe(self):
+    def describe(self) -> str:
         return "Raw SQL operation"
 
-    def _run_sql(self, schema_editor, sqls):
+    def _run_sql(
+        self,
+        schema_editor: BaseDatabaseSchemaEditor,
+        sqls: str
+        | list[str | tuple[str, list[Any]]]
+        | tuple[str | tuple[str, list[Any]], ...],
+    ) -> None:
         if isinstance(sqls, list | tuple):
-            for sql in sqls:
-                params = None
-                if isinstance(sql, list | tuple):
-                    elements = len(sql)
+            for sql_item in sqls:
+                params: list[Any] | None = None
+                sql: str
+                if isinstance(sql_item, list | tuple):
+                    elements = len(sql_item)
                     if elements == 2:
-                        sql, params = sql
+                        sql, params = sql_item  # type: ignore[misc]
                     else:
                         raise ValueError("Expected a 2-tuple but got %d" % elements)  # noqa: UP031
+                else:
+                    sql = sql_item
                 schema_editor.execute(sql, params=params)
         else:
-            statements = schema_editor.connection.ops.prepare_sql_script(sqls)
+            # sqls is a str in this branch
+            statements = schema_editor.connection.ops.prepare_sql_script(
+                cast(str, sqls)
+            )
             for statement in statements:
                 schema_editor.execute(statement, params=None)
 
@@ -96,7 +141,13 @@ class RunPython(Operation):
 
     reduces_to_sql = False
 
-    def __init__(self, code, *, atomic=None, elidable=False):
+    def __init__(
+        self,
+        code: Callable[..., Any],
+        *,
+        atomic: bool | None = None,
+        elidable: bool = False,
+    ) -> None:
         self.atomic = atomic
         # Forwards code
         if not callable(code):
@@ -104,20 +155,26 @@ class RunPython(Operation):
         self.code = code
         self.elidable = elidable
 
-    def deconstruct(self):
-        kwargs = {
+    def deconstruct(self) -> tuple[str, list[Any], dict[str, Any]]:
+        kwargs: dict[str, Any] = {
             "code": self.code,
         }
         if self.atomic is not None:
             kwargs["atomic"] = self.atomic
         return (self.__class__.__qualname__, [], kwargs)
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: Any) -> None:
         # RunPython objects have no state effect. To add some, combine this
         # with SeparateDatabaseAndState.
         pass
 
-    def database_forwards(self, package_label, schema_editor, from_state, to_state):
+    def database_forwards(
+        self,
+        package_label: str,
+        schema_editor: BaseDatabaseSchemaEditor,
+        from_state: ProjectState,
+        to_state: ProjectState,
+    ) -> None:
         # RunPython has access to all models. Ensure that all models are
         # reloaded in case any are delayed.
         from_state.clear_delayed_models_cache()
@@ -127,5 +184,5 @@ class RunPython(Operation):
         # use direct imports, so we go with a documentation approach instead.
         self.code(from_state.models_registry, schema_editor)
 
-    def describe(self):
+    def describe(self) -> str:
         return "Raw Python operation"

plain/models/migrations/optimizer.py

@@ -1,3 +1,8 @@
+from __future__ import annotations
+
+from typing import Any
+
+
 class MigrationOptimizer:
     """
     Power the optimization process, where you provide a list of Operations
@@ -9,7 +14,7 @@ class MigrationOptimizer:
     nothing.
     """
 
-    def optimize(self, operations, package_label):
+    def optimize(self, operations: list[Any], package_label: str) -> list[Any]:
         """
         Main optimization entry point. Pass in a list of Operation instances,
         get out a new list of Operation instances.
@@ -35,7 +40,7 @@ class MigrationOptimizer:
                 return result
             operations = result
 
-    def optimize_inner(self, operations, package_label):
+    def optimize_inner(self, operations: list[Any], package_label: str) -> list[Any]:
         """Inner optimization loop."""
         new_operations = []
         for i, operation in enumerate(operations):

plain/models/migrations/questioner.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
+
 import datetime
 import importlib
 import os
 import sys
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
 import click
 
@@ -11,6 +15,9 @@ from plain.utils import timezone
 
 from .loader import MigrationLoader
 
+if TYPE_CHECKING:
+    from plain.models.fields import Field
+
 
 class MigrationQuestioner:
     """
@@ -19,12 +26,17 @@ class MigrationQuestioner:
     interactive subclass is what the command-line arguments will use.
     """
 
-    def __init__(self, defaults=None, specified_packages=None, dry_run=None):
+    def __init__(
+        self,
+        defaults: dict[str, Any] | None = None,
+        specified_packages: set[str] | None = None,
+        dry_run: bool | None = None,
+    ) -> None:
         self.defaults = defaults or {}
         self.specified_packages = specified_packages or set()
         self.dry_run = dry_run
 
-    def ask_initial(self, package_label):
+    def ask_initial(self, package_label: str) -> bool:
         """Should we create an initial migration for the app?"""
         # If it was specified on the command line, definitely true
         if package_label in self.specified_packages:
@@ -49,52 +61,61 @@ class MigrationQuestioner:
             return self.defaults.get("ask_initial", False)
         else:
             if getattr(migrations_module, "__file__", None):
-                filenames = os.listdir(os.path.dirname(migrations_module.__file__))
+                filenames = os.listdir(os.path.dirname(migrations_module.__file__))  # type: ignore[arg-type]
             elif hasattr(migrations_module, "__path__"):
                 if len(migrations_module.__path__) > 1:
                     return False
                 filenames = os.listdir(list(migrations_module.__path__)[0])
             return not any(x.endswith(".py") for x in filenames if x != "__init__.py")
 
-    def ask_not_null_addition(self, field_name, model_name):
+    def ask_not_null_addition(self, field_name: str, model_name: str) -> Any:
         """Adding a NOT NULL field to a model."""
         # None means quit
         return None
 
-    def ask_not_null_alteration(self, field_name, model_name):
+    def ask_not_null_alteration(self, field_name: str, model_name: str) -> Any:
         """Changing a NULL field to NOT NULL."""
         # None means quit
         return None
 
-    def ask_rename(self, model_name, old_name, new_name, field_instance):
+    def ask_rename(
+        self, model_name: str, old_name: str, new_name: str, field_instance: Field
+    ) -> bool:
         """Was this field really renamed?"""
         return self.defaults.get("ask_rename", False)
 
-    def ask_rename_model(self, old_model_state, new_model_state):
+    def ask_rename_model(self, old_model_state: Any, new_model_state: Any) -> bool:
         """Was this model really renamed?"""
         return self.defaults.get("ask_rename_model", False)
 
-    def ask_auto_now_add_addition(self, field_name, model_name):
+    def ask_auto_now_add_addition(self, field_name: str, model_name: str) -> Any:
         """Adding an auto_now_add field to a model."""
         # None means quit
         return None
 
-    def ask_unique_callable_default_addition(self, field_name, model_name):
+    def ask_unique_callable_default_addition(
+        self, field_name: str, model_name: str
+    ) -> Any:
         """Adding a unique field with a callable default."""
         # None means continue.
         return None
 
 
 class InteractiveMigrationQuestioner(MigrationQuestioner):
-    def __init__(self, defaults=None, specified_packages=None, dry_run=None):
+    def __init__(
+        self,
+        defaults: dict[str, Any] | None = None,
+        specified_packages: set[str] | None = None,
+        dry_run: bool | None = None,
+    ) -> None:
         super().__init__(
             defaults=defaults, specified_packages=specified_packages, dry_run=dry_run
         )
 
-    def _boolean_input(self, question, default=None):
+    def _boolean_input(self, question: str, default: bool | None = None) -> bool:
         return click.confirm(question, default=default)
 
-    def _choice_input(self, question, choices):
+    def _choice_input(self, question: str, choices: list[str]) -> int:
         choice_map = {str(i + 1): choice for i, choice in enumerate(choices)}
         choice_map_str = "\n".join(
             [f"{i}) {choice}" for i, choice in choice_map.items()]
@@ -105,7 +126,7 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
         )
         return int(choice)
 
-    def _ask_default(self, default=""):
+    def _ask_default(self, default: str = "") -> Any:
         """
         Prompt for a default value.
 
@@ -144,7 +165,7 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
                 except (SyntaxError, NameError) as e:
                     click.echo(f"Invalid input: {e}")
 
-    def ask_not_null_addition(self, field_name, model_name):
+    def ask_not_null_addition(self, field_name: str, model_name: str) -> Any:
         """Adding a NOT NULL field to a model."""
         if not self.dry_run:
             choice = self._choice_input(
@@ -167,7 +188,7 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
                 return self._ask_default()
         return None
 
-    def ask_not_null_alteration(self, field_name, model_name):
+    def ask_not_null_alteration(self, field_name: str, model_name: str) -> Any:
         """Changing a NULL field to NOT NULL."""
         if not self.dry_run:
             choice = self._choice_input(
@@ -195,7 +216,9 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
                 return self._ask_default()
         return None
 
-    def ask_rename(self, model_name, old_name, new_name, field_instance):
+    def ask_rename(
+        self, model_name: str, old_name: str, new_name: str, field_instance: Field
+    ) -> bool:
         """Was this field really renamed?"""
         msg = "Was %s.%s renamed to %s.%s (a %s)?"
         return self._boolean_input(
@@ -210,7 +233,7 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
             default=False,
         )
 
-    def ask_rename_model(self, old_model_state, new_model_state):
+    def ask_rename_model(self, old_model_state: Any, new_model_state: Any) -> bool:
         """Was this model really renamed?"""
         msg = "Was the model %s.%s renamed to %s?"
         return self._boolean_input(
@@ -223,7 +246,7 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
             default=False,
         )
 
-    def ask_auto_now_add_addition(self, field_name, model_name):
+    def ask_auto_now_add_addition(self, field_name: str, model_name: str) -> Any:
         """Adding an auto_now_add field to a model."""
         if not self.dry_run:
             choice = self._choice_input(
@@ -243,7 +266,9 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
                 return self._ask_default(default="timezone.now")
         return None
 
-    def ask_unique_callable_default_addition(self, field_name, model_name):
+    def ask_unique_callable_default_addition(
+        self, field_name: str, model_name: str
+    ) -> Any:
         """Adding a unique field with a callable default."""
         if not self.dry_run:
             choice = self._choice_input(
@@ -264,12 +289,12 @@ class InteractiveMigrationQuestioner(MigrationQuestioner):
 class NonInteractiveMigrationQuestioner(MigrationQuestioner):
     def __init__(
         self,
-        defaults=None,
-        specified_packages=None,
-        dry_run=None,
-        verbosity=1,
-        log=None,
-    ):
+        defaults: dict[str, Any] | None = None,
+        specified_packages: set[str] | None = None,
+        dry_run: bool | None = None,
+        verbosity: int = 1,
+        log: Callable[[str], Any] | None = None,
+    ) -> None:
         self.verbosity = verbosity
         self.log = log
         super().__init__(
@@ -278,13 +303,15 @@ class NonInteractiveMigrationQuestioner(MigrationQuestioner):
             dry_run=dry_run,
         )
 
-    def log_lack_of_migration(self, field_name, model_name, reason):
+    def log_lack_of_migration(
+        self, field_name: str, model_name: str, reason: str
+    ) -> None:
         if self.verbosity > 0:
-            self.log(
+            self.log(  # type: ignore[misc]
                 f"Field '{field_name}' on model '{model_name}' not migrated: {reason}."
             )
 
-    def ask_not_null_addition(self, field_name, model_name):
+    def ask_not_null_addition(self, field_name: str, model_name: str) -> Any:
         # We can't ask the user, so act like the user aborted.
         self.log_lack_of_migration(
             field_name,
@@ -293,15 +320,15 @@ class NonInteractiveMigrationQuestioner(MigrationQuestioner):
         )
         sys.exit(3)
 
-    def ask_not_null_alteration(self, field_name, model_name):
+    def ask_not_null_alteration(self, field_name: str, model_name: str) -> Any:
         # We can't ask the user, so set as not provided.
-        self.log(
+        self.log(  # type: ignore[misc]
             f"Field '{field_name}' on model '{model_name}' given a default of "
             f"NOT PROVIDED and must be corrected."
         )
         return NOT_PROVIDED
 
-    def ask_auto_now_add_addition(self, field_name, model_name):
+    def ask_auto_now_add_addition(self, field_name: str, model_name: str) -> Any:
         # We can't ask the user, so act like the user aborted.
         self.log_lack_of_migration(
             field_name,

plain/models/migrations/recorder.py

@@ -1,11 +1,19 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 from plain import models
 from plain.models.db import DatabaseError
+from plain.models.meta import Meta
 from plain.models.registry import ModelsRegistry
 from plain.utils.functional import classproperty
 from plain.utils.timezone import now
 
 from .exceptions import MigrationSchemaMissing
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+
 
 class MigrationRecorder:
     """
@@ -20,10 +28,10 @@ class MigrationRecorder:
     a row in the table always means a migration is applied.
     """
 
-    _migration_class = None
+    _migration_class: type[models.Model] | None = None
 
     @classproperty
-    def Migration(cls):
+    def Migration(cls) -> type[models.Model]:  # type: ignore[misc]
         """
         Lazy load to avoid PackageRegistryNotReady if installed packages import
         MigrationRecorder.
@@ -37,31 +45,34 @@ class MigrationRecorder:
                 name = models.CharField(max_length=255)
                 applied = models.DateTimeField(default=now)
 
-                class Meta:
-                    models_registry = _models_registry
-                    package_label = "migrations"
-                    db_table = "plainmigrations"
+                # Use isolated models registry for migrations
+                _model_meta = Meta(models_registry=_models_registry)
+
+                model_options = models.Options(
+                    package_label="migrations",
+                    db_table="plainmigrations",
+                )
 
-                def __str__(self):
+                def __str__(self) -> str:
                     return f"Migration {self.name} for {self.app}"
 
             cls._migration_class = Migration
         return cls._migration_class
 
-    def __init__(self, connection):
+    def __init__(self, connection: BaseDatabaseWrapper) -> None:
         self.connection = connection
 
     @property
-    def migration_qs(self):
+    def migration_qs(self) -> Any:
         return self.Migration.query.all()
 
-    def has_table(self):
+    def has_table(self) -> bool:
         """Return True if the plainmigrations table exists."""
         with self.connection.cursor() as cursor:
             tables = self.connection.introspection.table_names(cursor)
-        return self.Migration._meta.db_table in tables
+        return self.Migration.model_options.db_table in tables
 
-    def ensure_schema(self):
+    def ensure_schema(self) -> None:
         """Ensure the table exists and has the correct schema."""
         # If the table's there, that's fine - we've never changed its schema
         # in the codebase.
@@ -76,7 +87,7 @@ class MigrationRecorder:
                 f"Unable to create the plainmigrations table ({exc})"
             )
 
-    def applied_migrations(self):
+    def applied_migrations(self) -> dict[tuple[str, str], Any]:
         """
         Return a dict mapping (package_name, migration_name) to Migration instances
         for all applied migrations.
@@ -91,16 +102,16 @@ class MigrationRecorder:
             # are applied.
             return {}
 
-    def record_applied(self, app, name):
+    def record_applied(self, app: str, name: str) -> None:
         """Record that a migration was applied."""
         self.ensure_schema()
         self.migration_qs.create(app=app, name=name)
 
-    def record_unapplied(self, app, name):
+    def record_unapplied(self, app: str, name: str) -> None:
         """Record that a migration was unapplied."""
         self.ensure_schema()
         self.migration_qs.filter(app=app, name=name).delete()
 
-    def flush(self):
+    def flush(self) -> None:
         """Delete all migration records. Useful for testing migrations."""
         self.migration_qs.all().delete()