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

plain/models/migrations/operations/base.py

@@ -1,3 +1,13 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
+    from plain.models.migrations.state import ProjectState
+
+
 class Operation:
     """
     Base class for migration operations.
@@ -24,15 +34,15 @@ class Operation:
     # Should this operation be considered safe to elide and optimize across?
     elidable = False
 
-    serialization_expand_args = []
+    serialization_expand_args: list[str] = []
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args: Any, **kwargs: Any) -> Operation:
         # We capture the arguments to make returning them trivial
         self = object.__new__(cls)
-        self._constructor_args = (args, kwargs)
-        return self
+        self._constructor_args = (args, kwargs)  # type: ignore[attr-defined]
+        return self  # type: ignore[return-value]
 
-    def deconstruct(self):
+    def deconstruct(self) -> tuple[str, tuple[Any, ...], dict[str, Any]]:
         """
         Return a 3-tuple of class import path (or just name if it lives
         under plain.models.migrations), positional arguments, and keyword
@@ -40,11 +50,11 @@ class Operation:
         """
         return (
             self.__class__.__name__,
-            self._constructor_args[0],
-            self._constructor_args[1],
+            self._constructor_args[0],  # type: ignore[attr-defined]
+            self._constructor_args[1],  # type: ignore[attr-defined]
         )
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: ProjectState) -> None:
         """
         Take the state from the previous migration, and mutate it
         so that it matches what this migration would perform.
@@ -53,7 +63,13 @@ class Operation:
             "subclasses of Operation must provide a state_forwards() method"
         )
 
-    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:
         """
         Perform the mutation on the database schema in the normal
         (forwards) direction.
@@ -62,21 +78,21 @@ class Operation:
             "subclasses of Operation must provide a database_forwards() method"
         )
 
-    def describe(self):
+    def describe(self) -> str:
         """
         Output a brief summary of what the action does.
         """
-        return f"{self.__class__.__name__}: {self._constructor_args}"
+        return f"{self.__class__.__name__}: {self._constructor_args}"  # type: ignore[attr-defined]
 
     @property
-    def migration_name_fragment(self):
+    def migration_name_fragment(self) -> str | None:
         """
         A filename part suitable for automatically naming a migration
         containing this operation, or None if not applicable.
         """
         return None
 
-    def references_model(self, name, package_label):
+    def references_model(self, name: str, package_label: str) -> bool:
         """
         Return True if there is a chance this operation references the given
         model name (as a string), with an app label for accuracy.
@@ -88,7 +104,7 @@ class Operation:
         """
         return True
 
-    def references_field(self, model_name, name, package_label):
+    def references_field(self, model_name: str, name: str, package_label: str) -> bool:
         """
         Return True if there is a chance this operation references the given
         field name, with an app label for accuracy.
@@ -97,14 +113,16 @@ class Operation:
         """
         return self.references_model(model_name, package_label)
 
-    def allow_migrate_model(self, connection, model):
+    def allow_migrate_model(self, connection: BaseDatabaseWrapper, model: Any) -> bool:
         """Return whether or not a model may be migrated."""
-        if not model._meta.can_migrate(connection):
+        if not model.model_options.can_migrate(connection):
             return False
 
         return True
 
-    def reduce(self, operation, package_label):
+    def reduce(
+        self, operation: Operation, package_label: str
+    ) -> list[Operation] | bool:
         """
         Return either a list of operations the actual operation should be
         replaced with or a boolean that indicates whether or not the specified
@@ -116,9 +134,9 @@ class Operation:
             return [self]
         return False
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<{} {}{}>".format(
             self.__class__.__name__,
-            ", ".join(map(repr, self._constructor_args[0])),
-            ",".join(" {}={!r}".format(*x) for x in self._constructor_args[1].items()),
+            ", ".join(map(repr, self._constructor_args[0])),  # type: ignore[attr-defined]
+            ",".join(" {}={!r}".format(*x) for x in self._constructor_args[1].items()),  # type: ignore[attr-defined]
         )

plain/models/migrations/operations/fields.py

@@ -1,35 +1,43 @@
+from __future__ import annotations
+
 from functools import cached_property
+from typing import TYPE_CHECKING, Any
 
 from plain.models.fields import NOT_PROVIDED
 from plain.models.migrations.utils import field_references
 
 from .base import Operation
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
+    from plain.models.fields import Field
+    from plain.models.migrations.state import ProjectState
+
 
 class FieldOperation(Operation):
-    def __init__(self, model_name, name, field=None):
+    def __init__(self, model_name: str, name: str, field: Field | None = None) -> None:
         self.model_name = model_name
         self.name = name
         self.field = field
 
     @cached_property
-    def model_name_lower(self):
+    def model_name_lower(self) -> str:
         return self.model_name.lower()
 
     @cached_property
-    def name_lower(self):
+    def name_lower(self) -> str:
         return self.name.lower()
 
-    def is_same_model_operation(self, operation):
+    def is_same_model_operation(self, operation: FieldOperation) -> bool:
         return self.model_name_lower == operation.model_name_lower
 
-    def is_same_field_operation(self, operation):
+    def is_same_field_operation(self, operation: FieldOperation) -> bool:
         return (
             self.is_same_model_operation(operation)
             and self.name_lower == operation.name_lower
         )
 
-    def references_model(self, name, package_label):
+    def references_model(self, name: str, package_label: str) -> bool:
         name_lower = name.lower()
         if name_lower == self.model_name_lower:
             return True
@@ -43,7 +51,7 @@ class FieldOperation(Operation):
             )
         return False
 
-    def references_field(self, model_name, name, package_label):
+    def references_field(self, model_name: str, name: str, package_label: str) -> bool:
         model_name_lower = model_name.lower()
         # Check if this operation locally references the field.
         if model_name_lower == self.model_name_lower:
@@ -61,7 +69,9 @@ class FieldOperation(Operation):
             )
         )
 
-    def reduce(self, operation, package_label):
+    def reduce(
+        self, operation: Operation, package_label: str
+    ) -> list[Operation] | bool:
         return super().reduce(
             operation, package_label
         ) or not operation.references_field(self.model_name, self.name, package_label)
@@ -70,12 +80,14 @@ class FieldOperation(Operation):
 class AddField(FieldOperation):
     """Add a field to a model."""
 
-    def __init__(self, model_name, name, field, preserve_default=True):
+    def __init__(
+        self, model_name: str, name: str, field: Field, preserve_default: bool = True
+    ) -> None:
         self.preserve_default = preserve_default
         super().__init__(model_name, name, field)
 
-    def deconstruct(self):
-        kwargs = {
+    def deconstruct(self) -> tuple[str, list[Any], dict[str, Any]]:
+        kwargs: dict[str, Any] = {
             "model_name": self.model_name,
             "name": self.name,
             "field": self.field,
@@ -84,7 +96,7 @@ class AddField(FieldOperation):
             kwargs["preserve_default"] = self.preserve_default
         return (self.__class__.__name__, [], kwargs)
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: Any) -> None:
         state.add_field(
             package_label,
             self.model_name_lower,
@@ -93,13 +105,19 @@ class AddField(FieldOperation):
             self.preserve_default,
         )
 
-    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:
         to_model = to_state.models_registry.get_model(package_label, self.model_name)
         if self.allow_migrate_model(schema_editor.connection, to_model):
             from_model = from_state.models_registry.get_model(
                 package_label, self.model_name
             )
-            field = to_model._meta.get_field(self.name)
+            field = to_model._model_meta.get_field(self.name)
             if not self.preserve_default:
                 field.default = self.field.default
             schema_editor.add_field(
@@ -109,18 +127,21 @@ class AddField(FieldOperation):
             if not self.preserve_default:
                 field.default = NOT_PROVIDED
 
-    def describe(self):
+    def describe(self) -> str:
         return f"Add field {self.name} to {self.model_name}"
 
     @property
-    def migration_name_fragment(self):
+    def migration_name_fragment(self) -> str:
         return f"{self.model_name_lower}_{self.name_lower}"
 
-    def reduce(self, operation, package_label):
+    def reduce(
+        self, operation: Operation, package_label: str
+    ) -> list[Operation] | bool:
         if isinstance(operation, FieldOperation) and self.is_same_field_operation(
             operation
         ):
             if isinstance(operation, AlterField):
+                assert operation.field is not None
                 return [
                     AddField(
                         model_name=self.model_name,
@@ -144,33 +165,41 @@ class AddField(FieldOperation):
 class RemoveField(FieldOperation):
     """Remove a field from a model."""
 
-    def deconstruct(self):
-        kwargs = {
+    def deconstruct(self) -> tuple[str, list[Any], dict[str, Any]]:
+        kwargs: dict[str, Any] = {
             "model_name": self.model_name,
             "name": self.name,
         }
         return (self.__class__.__name__, [], kwargs)
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: Any) -> None:
         state.remove_field(package_label, self.model_name_lower, self.name)
 
-    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:
         from_model = from_state.models_registry.get_model(
             package_label, self.model_name
         )
         if self.allow_migrate_model(schema_editor.connection, from_model):
             schema_editor.remove_field(
-                from_model, from_model._meta.get_field(self.name)
+                from_model, from_model._model_meta.get_field(self.name)
             )
 
-    def describe(self):
+    def describe(self) -> str:
         return f"Remove field {self.name} from {self.model_name}"
 
     @property
-    def migration_name_fragment(self):
+    def migration_name_fragment(self) -> str:
         return f"remove_{self.model_name_lower}_{self.name_lower}"
 
-    def reduce(self, operation, package_label):
+    def reduce(
+        self, operation: Operation, package_label: str
+    ) -> list[Operation] | bool:
         from .models import DeleteModel
 
         if (
@@ -187,12 +216,14 @@ class AlterField(FieldOperation):
     new field.
     """
 
-    def __init__(self, model_name, name, field, preserve_default=True):
+    def __init__(
+        self, model_name: str, name: str, field: Field, preserve_default: bool = True
+    ) -> None:
         self.preserve_default = preserve_default
         super().__init__(model_name, name, field)
 
-    def deconstruct(self):
-        kwargs = {
+    def deconstruct(self) -> tuple[str, list[Any], dict[str, Any]]:
+        kwargs: dict[str, Any] = {
             "model_name": self.model_name,
             "name": self.name,
             "field": self.field,
@@ -201,7 +232,7 @@ class AlterField(FieldOperation):
             kwargs["preserve_default"] = self.preserve_default
         return (self.__class__.__name__, [], kwargs)
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: Any) -> None:
         state.alter_field(
             package_label,
             self.model_name_lower,
@@ -210,28 +241,36 @@ class AlterField(FieldOperation):
             self.preserve_default,
         )
 
-    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:
         to_model = to_state.models_registry.get_model(package_label, self.model_name)
         if self.allow_migrate_model(schema_editor.connection, to_model):
             from_model = from_state.models_registry.get_model(
                 package_label, self.model_name
             )
-            from_field = from_model._meta.get_field(self.name)
-            to_field = to_model._meta.get_field(self.name)
+            from_field = from_model._model_meta.get_field(self.name)
+            to_field = to_model._model_meta.get_field(self.name)
             if not self.preserve_default:
                 to_field.default = self.field.default
             schema_editor.alter_field(from_model, from_field, to_field)
             if not self.preserve_default:
                 to_field.default = NOT_PROVIDED
 
-    def describe(self):
+    def describe(self) -> str:
         return f"Alter field {self.name} on {self.model_name}"
 
     @property
-    def migration_name_fragment(self):
+    def migration_name_fragment(self) -> str:
         return f"alter_{self.model_name_lower}_{self.name_lower}"
 
-    def reduce(self, operation, package_label):
+    def reduce(
+        self, operation: Operation, package_label: str
+    ) -> list[Operation] | bool:
         if isinstance(
             operation, AlterField | RemoveField
         ) and self.is_same_field_operation(operation):
@@ -255,33 +294,39 @@ class AlterField(FieldOperation):
 class RenameField(FieldOperation):
     """Rename a field on the model. Might affect db_column too."""
 
-    def __init__(self, model_name, old_name, new_name):
+    def __init__(self, model_name: str, old_name: str, new_name: str) -> None:
         self.old_name = old_name
         self.new_name = new_name
         super().__init__(model_name, old_name)
 
     @cached_property
-    def old_name_lower(self):
+    def old_name_lower(self) -> str:
         return self.old_name.lower()
 
     @cached_property
-    def new_name_lower(self):
+    def new_name_lower(self) -> str:
         return self.new_name.lower()
 
-    def deconstruct(self):
-        kwargs = {
+    def deconstruct(self) -> tuple[str, list[Any], dict[str, Any]]:
+        kwargs: dict[str, Any] = {
             "model_name": self.model_name,
             "old_name": self.old_name,
             "new_name": self.new_name,
         }
         return (self.__class__.__name__, [], kwargs)
 
-    def state_forwards(self, package_label, state):
+    def state_forwards(self, package_label: str, state: Any) -> None:
         state.rename_field(
             package_label, self.model_name_lower, self.old_name, self.new_name
         )
 
-    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:
         to_model = to_state.models_registry.get_model(package_label, self.model_name)
         if self.allow_migrate_model(schema_editor.connection, to_model):
             from_model = from_state.models_registry.get_model(
@@ -289,23 +334,25 @@ class RenameField(FieldOperation):
             )
             schema_editor.alter_field(
                 from_model,
-                from_model._meta.get_field(self.old_name),
-                to_model._meta.get_field(self.new_name),
+                from_model._model_meta.get_field(self.old_name),
+                to_model._model_meta.get_field(self.new_name),
             )
 
-    def describe(self):
+    def describe(self) -> str:
         return f"Rename field {self.old_name} on {self.model_name} to {self.new_name}"
 
     @property
-    def migration_name_fragment(self):
+    def migration_name_fragment(self) -> str:
         return f"rename_{self.old_name_lower}_{self.model_name_lower}_{self.new_name_lower}"
 
-    def references_field(self, model_name, name, package_label):
+    def references_field(self, model_name: str, name: str, package_label: str) -> bool:
         return self.references_model(model_name, package_label) and (
             name.lower() == self.old_name_lower or name.lower() == self.new_name_lower
         )
 
-    def reduce(self, operation, package_label):
+    def reduce(
+        self, operation: Operation, package_label: str
+    ) -> list[Operation] | bool:
         if (
             isinstance(operation, RenameField)
             and self.is_same_model_operation(operation)