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

plain/models/cli.py

@@ -118,19 +118,19 @@ def list_models(package_labels: tuple[str, ...], app_only: bool) -> None:
 
     for model in sorted(
         models_registry.get_models(),
-        key=lambda m: (m._meta.package_label, m._meta.model_name),
+        key=lambda m: (m.model_options.package_label, m.model_options.model_name),
     ):
-        pkg = model._meta.package_label
+        pkg = model.model_options.package_label
         pkg_name = packages_registry.get_package_config(pkg).name
         if app_only and not pkg_name.startswith("app"):
             continue
         if packages and pkg not in packages:
             continue
-        fields = ", ".join(f.name for f in model._meta.get_fields())
+        fields = ", ".join(f.name for f in model._model_meta.get_fields())
         click.echo(
             f"{click.style(pkg, fg='cyan')}.{click.style(model.__name__, fg='blue')}"
         )
-        click.echo(f"  table: {model._meta.db_table}")
+        click.echo(f"  table: {model.model_options.db_table}")
         click.echo(f"  fields: {fields}")
         click.echo(f"  package: {pkg_name}\n")
 

plain/models/constraints.py

@@ -115,7 +115,7 @@ class CheckConstraint(BaseConstraint):
     def validate(
         self, model: Any, instance: Any, exclude: set[str] | None = None
     ) -> None:
-        against = instance._get_field_value_map(meta=model._meta, exclude=exclude)
+        against = instance._get_field_value_map(meta=model._model_meta, exclude=exclude)
         try:
             if not Q(self.check).check(against):
                 raise ValidationError(
@@ -260,9 +260,10 @@ class UniqueConstraint(BaseConstraint):
         )
 
     def constraint_sql(self, model: Any, schema_editor: Any) -> str:
-        fields = [model._meta.get_field(field_name) for field_name in self.fields]
+        fields = [model._model_meta.get_field(field_name) for field_name in self.fields]
         include = [
-            model._meta.get_field(field_name).column for field_name in self.include
+            model._model_meta.get_field(field_name).column
+            for field_name in self.include
         ]
         condition = self._get_condition_sql(model, schema_editor)
         expressions = self._get_index_expressions(model, schema_editor)
@@ -278,9 +279,10 @@ class UniqueConstraint(BaseConstraint):
         )
 
     def create_sql(self, model: Any, schema_editor: Any) -> str:
-        fields = [model._meta.get_field(field_name) for field_name in self.fields]
+        fields = [model._model_meta.get_field(field_name) for field_name in self.fields]
         include = [
-            model._meta.get_field(field_name).column for field_name in self.include
+            model._model_meta.get_field(field_name).column
+            for field_name in self.include
         ]
         condition = self._get_condition_sql(model, schema_editor)
         expressions = self._get_index_expressions(model, schema_editor)
@@ -298,7 +300,8 @@ class UniqueConstraint(BaseConstraint):
     def remove_sql(self, model: Any, schema_editor: Any) -> str:
         condition = self._get_condition_sql(model, schema_editor)
         include = [
-            model._meta.get_field(field_name).column for field_name in self.include
+            model._model_meta.get_field(field_name).column
+            for field_name in self.include
         ]
         expressions = self._get_index_expressions(model, schema_editor)
         return schema_editor._delete_unique_sql(
@@ -372,7 +375,7 @@ class UniqueConstraint(BaseConstraint):
             for field_name in self.fields:
                 if exclude and field_name in exclude:
                     return
-                field = model._meta.get_field(field_name)
+                field = model._model_meta.get_field(field_name)
                 lookup_value = getattr(instance, field.attname)
                 if lookup_value is None:
                     # A composite constraint containing NULL value cannot cause
@@ -393,7 +396,7 @@ class UniqueConstraint(BaseConstraint):
             replacements = {
                 F(field): value
                 for field, value in instance._get_field_value_map(
-                    meta=model._meta, exclude=exclude
+                    meta=model._model_meta, exclude=exclude
                 ).items()
             }
             expressions = []
@@ -422,7 +425,9 @@ class UniqueConstraint(BaseConstraint):
                                 instance.unique_error_message(model, self.fields),
                             )
         else:
-            against = instance._get_field_value_map(meta=model._meta, exclude=exclude)
+            against = instance._get_field_value_map(
+                meta=model._model_meta, exclude=exclude
+            )
             try:
                 if (self.condition & Exists(queryset.filter(self.condition))).check(
                     against

plain/models/deletion.py

@@ -13,6 +13,7 @@ from plain.models import (
     transaction,
 )
 from plain.models.db import IntegrityError, db_connection
+from plain.models.meta import Meta
 from plain.models.query import QuerySet
 
 if TYPE_CHECKING:
@@ -89,12 +90,12 @@ def DO_NOTHING(collector: Collector, field: Field, sub_objs: Any) -> None:
     pass
 
 
-def get_candidate_relations_to_delete(opts: Any) -> Generator[Any, None, None]:
+def get_candidate_relations_to_delete(meta: Meta) -> Generator[Any, None, None]:
     # The candidate relations are the ones that come from N-1 and 1-1 relations.
     # N-N  (i.e., many-to-many) relations aren't candidates for deletion.
     return (
         f
-        for f in opts.get_fields(include_hidden=True)
+        for f in meta.get_fields(include_hidden=True)
         if f.auto_created and not f.concrete and f.one_to_many
     )
 
@@ -208,8 +209,8 @@ class Collector:
         """
         if from_field and from_field.remote_field.on_delete is not CASCADE:
             return False
-        if hasattr(objs, "_meta"):
-            model = objs._meta.model
+        if hasattr(objs, "_model_meta"):
+            model = objs._model_meta.model
         elif hasattr(objs, "model") and hasattr(objs, "_raw_delete"):
             model = objs.model
         else:
@@ -217,12 +218,12 @@ class Collector:
 
         # The use of from_field comes from the need to avoid cascade back to
         # parent when parent delete is cascading to child.
-        opts = model._meta
+        meta = model._model_meta
         return (
             # Foreign keys pointing to this model.
             all(
                 related.field.remote_field.on_delete is DO_NOTHING
-                for related in get_candidate_relations_to_delete(opts)
+                for related in get_candidate_relations_to_delete(meta)
             )
         )
 
@@ -289,7 +290,7 @@ class Collector:
 
         model_fast_deletes = defaultdict(list)
         protected_objects = defaultdict(list)
-        for related in get_candidate_relations_to_delete(model._meta):
+        for related in get_candidate_relations_to_delete(model._model_meta):
             field = related.field
             on_delete = field.remote_field.on_delete
             if on_delete == DO_NOTHING:
@@ -312,7 +313,7 @@ class Collector:
                         chain.from_iterable(
                             (rf.attname for rf in rel.field.foreign_related_fields)
                             for rel in get_candidate_relations_to_delete(
-                                related_model._meta
+                                related_model._model_meta
                             )
                         )
                     )
@@ -373,7 +374,7 @@ class Collector:
             [(f"{related_field.name}__in", objs) for related_field in related_fields],
             connector=query_utils.Q.OR,
         )
-        return related_model._meta.base_queryset.filter(predicate)
+        return related_model._model_meta.base_queryset.filter(predicate)
 
     def sort(self) -> None:
         sorted_models = []
@@ -411,15 +412,15 @@ class Collector:
             if self.can_fast_delete(instance):
                 with transaction.mark_for_rollback_on_error():
                     count = sql.DeleteQuery(model).delete_batch([instance.id])
-                setattr(instance, model._meta.get_field("id").attname, None)
-                return count, {model._meta.label: count}
+                setattr(instance, model._model_meta.get_field("id").attname, None)
+                return count, {model.model_options.label: count}
 
         with transaction.atomic(savepoint=False):
             # fast deletes
             for qs in self.fast_deletes:
                 count = qs._raw_delete()
                 if count:
-                    deleted_counter[qs.model._meta.label] += count
+                    deleted_counter[qs.model.model_options.label] += count
 
             # update fields
             for (field, value), instances_list in self.field_updates.items():
@@ -453,9 +454,9 @@ class Collector:
                 id_list = [obj.id for obj in instances]
                 count = query.delete_batch(id_list)
                 if count:
-                    deleted_counter[model._meta.label] += count
+                    deleted_counter[model.model_options.label] += count
 
         for model, instances in self.data.items():
             for instance in instances:
-                setattr(instance, model._meta.get_field("id").attname, None)
+                setattr(instance, model._model_meta.get_field("id").attname, None)
         return sum(deleted_counter.values()), dict(deleted_counter)

plain/models/expressions.py

@@ -28,7 +28,9 @@ if TYPE_CHECKING:
 
     from plain.models.backends.base.base import BaseDatabaseWrapper
     from plain.models.fields import Field
+    from plain.models.query import QuerySet
     from plain.models.sql.compiler import SQLCompiler
+    from plain.models.sql.query import Query
 
 
 class SQLiteNumericMixin:
@@ -518,7 +520,7 @@ class Expression(BaseExpression, Combinable):
         for arg, value in arguments:
             if isinstance(value, fields.Field):
                 if value.name and value.model:
-                    value = (value.model._meta.label, value.name)
+                    value = (value.model.model_options.label, value.name)
                 else:
                     value = type(value)
             else:
@@ -1635,9 +1637,23 @@ class Subquery(BaseExpression, Combinable):
     contains_aggregate = False
     empty_result_set_value = None
 
-    def __init__(self, queryset: Any, output_field: Field | None = None, **extra: Any):
+    def __init__(
+        self,
+        query: QuerySet[Any] | Query,
+        output_field: Field | None = None,
+        **extra: Any,
+    ):
+        # Import here to avoid circular import
+        from plain.models.sql.query import Query
+
         # Allow the usage of both QuerySet and sql.Query objects.
-        self.query = getattr(queryset, "query", queryset).clone()
+        if isinstance(query, Query):
+            # It's already a Query object, use it directly
+            sql_query = query
+        else:
+            # It's a QuerySet, extract the sql.Query
+            sql_query = query.sql_query
+        self.query = sql_query.clone()
         self.query.subquery = True
         self.extra = extra
         super().__init__(output_field)
@@ -1688,8 +1704,8 @@ class Exists(Subquery):
     output_field = fields.BooleanField()
     empty_result_set_value = False
 
-    def __init__(self, queryset: Any, **kwargs: Any):
-        super().__init__(queryset, **kwargs)
+    def __init__(self, query: QuerySet[Any] | Query, **kwargs: Any):
+        super().__init__(query, **kwargs)
         self.query = self.query.exists()
 
     def select_format(

plain/models/fields/__init__.py

@@ -36,6 +36,7 @@ from ..registry import models_registry
 
 if TYPE_CHECKING:
     from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.fields.reverse_related import ForeignObjectRel
     from plain.models.sql.compiler import SQLCompiler
 
 __all__ = [
@@ -81,7 +82,7 @@ BLANK_CHOICE_DASH = [("", "---------")]
 
 
 def _load_field(package_label: str, model_name: str, field_name: str) -> Field:
-    return models_registry.get_model(package_label, model_name)._meta.get_field(
+    return models_registry.get_model(package_label, model_name)._model_meta.get_field(
         field_name
     )
 
@@ -169,7 +170,7 @@ class Field(RegisterLookupMixin):
         max_length: int | None = None,
         required: bool = True,
         allow_null: bool = False,
-        rel: Any = None,
+        rel: ForeignObjectRel | None = None,
         default: Any = NOT_PROVIDED,
         choices: Any = None,
         db_column: str | None = None,
@@ -212,7 +213,7 @@ class Field(RegisterLookupMixin):
         if not hasattr(self, "model"):
             return super().__str__()
         model = self.model
-        return f"{model._meta.label}.{self.name}"
+        return f"{model.model_options.label}.{self.name}"
 
     def __repr__(self) -> str:
         """Display the module, class, and name of the field."""
@@ -346,7 +347,7 @@ class Field(RegisterLookupMixin):
         errors = []
         if not (
             db_connection.features.supports_comments
-            or "supports_comments" in self.model._meta.required_db_features
+            or "supports_comments" in self.model.model_options.required_db_features
         ):
             errors.append(
                 PreflightResult(
@@ -399,7 +400,7 @@ class Field(RegisterLookupMixin):
         return errors
 
     def get_col(self, alias: str, output_field: Field | None = None) -> Any:
-        if alias == self.model._meta.db_table and (
+        if alias == self.model.model_options.db_table and (
             output_field is None or output_field == self
         ):
             return self.cached_col
@@ -411,7 +412,7 @@ class Field(RegisterLookupMixin):
     def cached_col(self) -> Any:
         from plain.models.expressions import Col
 
-        return Col(self.model._meta.db_table, self)
+        return Col(self.model.model_options.db_table, self)
 
     def select_format(
         self, compiler: SQLCompiler, sql: str, params: Any
@@ -528,9 +529,12 @@ class Field(RegisterLookupMixin):
                 return not hasattr(self, "model")  # Order no-model fields first
             else:
                 # creation_counter's are equal, compare only models.
-                return (self.model._meta.package_label, self.model._meta.model_name) < (
-                    other.model._meta.package_label,
-                    other.model._meta.model_name,
+                return (
+                    self.model.model_options.package_label,
+                    self.model.model_options.model_name,
+                ) < (
+                    other.model.model_options.package_label,
+                    other.model.model_options.model_name,
                 )
         return NotImplemented
 
@@ -563,7 +567,7 @@ class Field(RegisterLookupMixin):
         | tuple[Callable[..., Field], tuple[str, str, str]]
     ):
         """
-        Pickling should return the model._meta.fields instance of the field,
+        Pickling should return the model._model_meta.fields instance of the field,
         not a new copy of that field. So, use the app registry to load the
         model and then the field back.
         """
@@ -579,8 +583,8 @@ class Field(RegisterLookupMixin):
             state.pop("_get_default", None)
             return _empty, (self.__class__,), state
         return _load_field, (
-            self.model._meta.package_label,
-            self.model._meta.object_name,
+            self.model.model_options.package_label,
+            self.model.model_options.object_name,
             self.name,
         )
 
@@ -782,7 +786,7 @@ class Field(RegisterLookupMixin):
         """
         self.set_attributes_from_name(name)
         self.model = cls
-        cls._meta.add_field(self)
+        cls._model_meta.add_field(self)
         if self.column:
             setattr(cls, self.attname, self.descriptor_class(self))
 
@@ -967,7 +971,7 @@ class CharField(Field):
             if (
                 db_connection.features.supports_unlimited_charfield
                 or "supports_unlimited_charfield"
-                in self.model._meta.required_db_features
+                in self.model.model_options.required_db_features
             ):
                 return []
             return [
@@ -997,7 +1001,7 @@ class CharField(Field):
         if not (
             self.db_collation is None
             or "supports_collation_on_charfield"
-            in self.model._meta.required_db_features
+            in self.model.model_options.required_db_features
             or db_connection.features.supports_collation_on_charfield
         ):
             errors.append(
@@ -1863,7 +1867,7 @@ class TextField(Field):
         if not (
             self.db_collation is None
             or "supports_collation_on_textfield"
-            in self.model._meta.required_db_features
+            in self.model.model_options.required_db_features
             or db_connection.features.supports_collation_on_textfield
         ):
             errors.append(

plain/models/fields/json.py

@@ -59,13 +59,13 @@ class JSONField(CheckFieldDefaultMixin, Field):
         errors = []
 
         if (
-            self.model._meta.required_db_vendor
-            and self.model._meta.required_db_vendor != db_connection.vendor
+            self.model.model_options.required_db_vendor
+            and self.model.model_options.required_db_vendor != db_connection.vendor
         ):
             return errors
 
         if not (
-            "supports_json_field" in self.model._meta.required_db_features
+            "supports_json_field" in self.model.model_options.required_db_features
             or db_connection.features.supports_json_field
         ):
             errors.append(