plain.models 0.50.0__py3-none-any.whl → 0.51.1__py3-none-any.whl

plain/models/migrations/operations/fields.py

@@ -117,7 +117,7 @@ class AddField(FieldOperation):
             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(
@@ -187,7 +187,7 @@ class RemoveField(FieldOperation):
         )
         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) -> str:
@@ -253,8 +253,8 @@ class AlterField(FieldOperation):
             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)
@@ -334,8 +334,8 @@ 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) -> str:

plain/models/migrations/operations/models.py

@@ -70,8 +70,10 @@ class CreateModel(ModelOperation):
         _check_for_duplicates(
             "bases",
             (
-                base._meta.label_lower  # type: ignore[attr-defined]
-                if hasattr(base, "_meta")
+                base.model_options.label_lower
+                if not isinstance(base, str)
+                and base is not models.Model
+                and hasattr(base, "_model_meta")
                 else base.lower()
                 if isinstance(base, str)
                 else base
@@ -312,26 +314,26 @@ class RenameModel(ModelOperation):
             # Move the main table
             schema_editor.alter_db_table(
                 new_model,
-                old_model._meta.db_table,  # type: ignore[attr-defined]
-                new_model._meta.db_table,  # type: ignore[attr-defined]
+                old_model.model_options.db_table,
+                new_model.model_options.db_table,
             )
             # Alter the fields pointing to us
-            for related_object in old_model._meta.related_objects:  # type: ignore[attr-defined]
+            for related_object in old_model._model_meta.related_objects:
                 if related_object.related_model == old_model:  # type: ignore[attr-defined]
                     model = new_model
                     related_key = (package_label, self.new_name_lower)
                 else:
                     model = related_object.related_model  # type: ignore[attr-defined]
                     related_key = (
-                        related_object.related_model._meta.package_label,  # type: ignore[attr-defined]
-                        related_object.related_model._meta.model_name,  # type: ignore[attr-defined]
+                        related_object.related_model.model_options.package_label,
+                        related_object.related_model.model_options.model_name,
                     )
-                to_field = to_state.models_registry.get_model(  # type: ignore[attr-defined]
+                to_field = to_state.models_registry.get_model(
                     *related_key
-                )._meta.get_field(related_object.field.name)  # type: ignore[attr-defined]
+                )._model_meta.get_field(related_object.field.name)
                 schema_editor.alter_field(
                     model,
-                    related_object.field,  # type: ignore[attr-defined]
+                    related_object.field,
                     to_field,
                 )
 
@@ -410,8 +412,8 @@ class AlterModelTable(ModelOptionOperation):
             old_model = from_state.models_registry.get_model(package_label, self.name)  # type: ignore[attr-defined]
             schema_editor.alter_db_table(
                 new_model,
-                old_model._meta.db_table,  # type: ignore[attr-defined]
-                new_model._meta.db_table,  # type: ignore[attr-defined]
+                old_model.model_options.db_table,
+                new_model.model_options.db_table,
             )
 
     def describe(self) -> str:
@@ -454,8 +456,8 @@ class AlterModelTableComment(ModelOptionOperation):
             old_model = from_state.models_registry.get_model(package_label, self.name)  # type: ignore[attr-defined]
             schema_editor.alter_db_table_comment(
                 new_model,
-                old_model._meta.db_table_comment,  # type: ignore[attr-defined]
-                new_model._meta.db_table_comment,  # type: ignore[attr-defined]
+                old_model.model_options.db_table_comment,
+                new_model.model_options.db_table_comment,
             )
 
     def describe(self) -> str:
@@ -693,7 +695,7 @@ class RenameIndex(IndexOperation):
                 package_label, self.model_name
             )
             columns = [
-                from_model._meta.get_field(field).column  # type: ignore[attr-defined]
+                from_model._model_meta.get_field(field).column
                 for field in self.old_fields
             ]
             matching_index_name = schema_editor._constraint_names(
@@ -703,7 +705,7 @@ class RenameIndex(IndexOperation):
                 raise ValueError(
                     "Found wrong number ({}) of indexes for {}({}).".format(
                         len(matching_index_name),
-                        from_model._meta.db_table,  # type: ignore[attr-defined]
+                        from_model.model_options.db_table,
                         ", ".join(columns),
                     )
                 )

plain/models/migrations/recorder.py

@@ -4,6 +4,7 @@ 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
@@ -44,10 +45,13 @@ 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) -> str:
                     return f"Migration {self.name} for {self.app}"
@@ -66,7 +70,7 @@ class MigrationRecorder:
         """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) -> None:
         """Ensure the table exists and has the correct schema."""

plain/models/migrations/state.py

@@ -10,8 +10,8 @@ from plain import models
 from plain.models.exceptions import FieldDoesNotExist
 from plain.models.fields import NOT_PROVIDED
 from plain.models.fields.related import RECURSIVE_RELATIONSHIP_CONSTANT
+from plain.models.meta import Meta
 from plain.models.migrations.utils import field_is_referenced, get_references
-from plain.models.options import DEFAULT_NAMES
 from plain.models.registry import ModelsRegistry
 from plain.models.registry import models_registry as global_models
 from plain.packages import packages_registry
@@ -32,7 +32,7 @@ def _get_package_label_and_model_name(
         split = model.split(".", 1)
         return tuple(split) if len(split) == 2 else (package_label, split[0])  # type: ignore[return-value]
     else:
-        return model._meta.package_label, model._meta.model_name  # type: ignore[attr-defined]
+        return model.model_options.package_label, model.model_options.model_name
 
 
 def _get_related_models(m: type[models.Model]) -> list[type[models.Model]]:
@@ -43,7 +43,7 @@ def _get_related_models(m: type[models.Model]) -> list[type[models.Model]]:
         if issubclass(subclass, models.Model)
     ]
     related_fields_models = set()
-    for f in m._meta.get_fields(include_hidden=True):  # type: ignore[attr-defined]
+    for f in m._model_meta.get_fields(include_hidden=True):
         if (
             f.is_relation  # type: ignore[attr-defined]
             and f.related_model is not None  # type: ignore[attr-defined]
@@ -60,7 +60,7 @@ def get_related_models_tuples(model: type[models.Model]) -> set[tuple[str, str]]
     models for the given model.
     """
     return {
-        (rel_mod._meta.package_label, rel_mod._meta.model_name)  # type: ignore[attr-defined]
+        (rel_mod.model_options.package_label, rel_mod.model_options.model_name)
         for rel_mod in _get_related_models(model)
     }
 
@@ -78,14 +78,14 @@ def get_related_models_recursive(model: type[models.Model]) -> set[tuple[str, st
     queue = _get_related_models(model)
     for rel_mod in queue:
         rel_package_label, rel_model_name = (
-            rel_mod._meta.package_label,  # type: ignore[attr-defined]
-            rel_mod._meta.model_name,  # type: ignore[attr-defined]
+            rel_mod.model_options.package_label,
+            rel_mod.model_options.model_name,
         )
         if (rel_package_label, rel_model_name) in seen:
             continue
         seen.add((rel_package_label, rel_model_name))
         queue.extend(_get_related_models(rel_mod))
-    return seen - {(model._meta.package_label, model._meta.model_name)}  # type: ignore[attr-defined]
+    return seen - {(model.model_options.package_label, model.model_options.model_name)}
 
 
 class ProjectState:
@@ -362,7 +362,7 @@ class ProjectState:
             pass
         else:
             # Get all relations to and from the old model before reloading,
-            # as _meta.models_registry may change
+            # as _model_meta.models_registry may change
             if delay:
                 related_models = get_related_models_tuples(old_model)
             else:
@@ -645,7 +645,7 @@ class StateModelsRegistry(ModelsRegistry):
         return clone
 
     def register_model(self, package_label: str, model: type[models.Model]) -> None:
-        self.all_models[package_label][model._meta.model_name] = model  # type: ignore[attr-defined]
+        self.all_models[package_label][model.model_options.model_name] = model
         self.do_pending_operations(model)
         self.clear_cache()
 
@@ -689,12 +689,14 @@ class ModelState:
                     f'ModelState.fields cannot be bound to a model - "{name}" is.'
                 )
             # Sanity-check that relation fields are NOT referring to a model class.
-            if field.is_relation and hasattr(field.related_model, "_meta"):  # type: ignore[attr-defined]
+            if field.is_relation and hasattr(field.related_model, "_model_meta"):
                 raise ValueError(
                     f'ModelState.fields cannot refer to a model class - "{name}.to" does. '
                     "Use a string reference instead."
                 )
-            if field.many_to_many and hasattr(field.remote_field.through, "_meta"):  # type: ignore[attr-defined]
+            if field.many_to_many and hasattr(
+                field.remote_field.through, "_model_meta"
+            ):
                 raise ValueError(
                     f'ModelState.fields cannot refer to a model class - "{name}.through" '
                     "does. Use a string reference instead."
@@ -721,7 +723,7 @@ class ModelState:
         """Given a model, return a ModelState representing it."""
         # Deconstruct the fields
         fields = []
-        for field in model._meta.local_fields:  # type: ignore[attr-defined]
+        for field in model._model_meta.local_fields:
             if getattr(field, "remote_field", None) and exclude_rels:
                 continue
             name = field.name  # type: ignore[attr-defined]
@@ -729,37 +731,17 @@ class ModelState:
                 fields.append((name, field.clone()))  # type: ignore[attr-defined]
             except TypeError as e:
                 raise TypeError(
-                    f"Couldn't reconstruct field {name} on {model._meta.label}: {e}"  # type: ignore[attr-defined]
+                    f"Couldn't reconstruct field {name} on {model.model_options.label}: {e}"
                 )
         if not exclude_rels:
-            for field in model._meta.local_many_to_many:  # type: ignore[attr-defined]
+            for field in model._model_meta.local_many_to_many:
                 name = field.name  # type: ignore[attr-defined]
                 try:
                     fields.append((name, field.clone()))  # type: ignore[attr-defined]
                 except TypeError as e:
                     raise TypeError(
-                        f"Couldn't reconstruct m2m field {name} on {model._meta.object_name}: {e}"  # type: ignore[attr-defined]
+                        f"Couldn't reconstruct m2m field {name} on {model.model_options.object_name}: {e}"
                     )
-        # Extract the options
-        options = {}
-        for name in DEFAULT_NAMES:
-            # Ignore some special options
-            if name in ["models_registry", "package_label"]:
-                continue
-            elif name in model._meta.original_attrs:  # type: ignore[attr-defined]
-                if name == "indexes":
-                    indexes = [idx.clone() for idx in model._meta.indexes]  # type: ignore[attr-defined]
-                    for index in indexes:
-                        if not index.name:  # type: ignore[attr-defined]
-                            index.set_name_with_model(model)  # type: ignore[attr-defined]
-                    options["indexes"] = indexes
-                elif name == "constraints":
-                    options["constraints"] = [
-                        con.clone()
-                        for con in model._meta.constraints  # type: ignore[attr-defined]
-                    ]
-                else:
-                    options[name] = model._meta.original_attrs[name]  # type: ignore[attr-defined]
 
         def flatten_bases(model: type[models.Model]) -> list[type[models.Model]]:
             bases = []
@@ -778,7 +760,13 @@ class ModelState:
 
         # Make our record
         bases = tuple(
-            (base._meta.label_lower if hasattr(base, "_meta") else base)  # type: ignore[attr-defined]
+            (
+                base.model_options.label_lower
+                if not isinstance(base, str)
+                and base is not models.Model
+                and hasattr(base, "_model_meta")
+                else base
+            )
             for base in flattened_bases
         )
         # Ensure at least one base inherits from models.Model
@@ -789,10 +777,10 @@ class ModelState:
 
         # Construct the new ModelState
         return cls(
-            model._meta.package_label,  # type: ignore[attr-defined]
-            model._meta.object_name,  # type: ignore[attr-defined]
+            model.model_options.package_label,
+            model.model_options.object_name,
             fields,
-            options,
+            model.model_options.export_for_migrations(),
             bases,
         )
 
@@ -811,13 +799,11 @@ class ModelState:
 
     def render(self, models_registry: ModelsRegistry) -> type[models.Model]:
         """Create a Model object from our current state into the given packages."""
-        # First, make a Meta object
-        meta_contents = {
-            "package_label": self.package_label,
-            "models_registry": models_registry,
+        # Create Options instance with metadata
+        meta_options = models.Options(
+            package_label=self.package_label,
             **self.options,
-        }
-        meta = type("Meta", (), meta_contents)
+        )
         # Then, work out our bases
         try:
             bases = tuple(
@@ -830,7 +816,10 @@ class ModelState:
             )
         # Clone fields for the body, add other bits.
         body = {name: field.clone() for name, field in self.fields.items()}  # type: ignore[attr-defined]
-        body["Meta"] = meta
+        body["model_options"] = meta_options
+        body["_model_meta"] = Meta(
+            models_registry=models_registry
+        )  # Use custom registry
         body["__module__"] = "__fake__"
 
         # Then, make a Model object (models_registry.register_model is called in __new__)

plain/models/migrations/utils.py

@@ -56,7 +56,7 @@ def resolve_relation(
                 "package_label must be provided to resolve unscoped model relationships."
             )
         return package_label, model.lower()
-    return model._meta.package_label, model._meta.model_name
+    return model.model_options.package_label, model.model_options.model_name
 
 
 def field_references(