plain.postgres 0.116.0__tar.gz → 0.117.0__tar.gz

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: plain.postgres
-Version: 0.116.0
+Version: 0.117.0
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,31 @@
 # plain-postgres changelog
 
+## [0.117.0](https://github.com/dropseed/plain/releases/plain-postgres@0.117.0) (2026-09-04)
+
+### What's changed
+
+- Fixed `QuerySet.ordered`, which raised `AttributeError: 'Meta' object has no attribute 'ordering'` for any queryset without an explicit `order_by()`. It was reading the model's default ordering off `_model_meta` instead of `model_options`, so the property only ever worked on the one branch that never reached the lookup. It now correctly reports `True` when the model declares `Meta.ordering` and `False` when it doesn't ([d9406dfc6f](https://github.com/dropseed/plain/commit/d9406dfc6f))
+- Unresolved relation references are now separate attributes from resolved model classes. `rel.model` and `ManyToManyRel.through` used to hold whatever you passed to the field — a `"package.Model"` string early on, the class after `lazy_related_operation` overwrote it — so every reader had to guess which it had, and the guessing was done inconsistently (`isinstance(..., str)` in some places, `isinstance(..., ModelBase)` in others, `hasattr(..., "_model_meta")` in others still). The raw reference now lives on `rel.model_ref` and `rel.through_ref`, and `rel.model` / `rel.through` are read-only properties that return the resolved class or raise `TypeError` if it isn't resolved yet. The `TypeError` is deliberate: an `AttributeError` would be swallowed by `hasattr`/`getattr` and silently read as "no model" ([a3962f7255](https://github.com/dropseed/plain/commit/a3962f7255))
+- `ForeignKeyField.target_field` dropped its own unresolved-reference `TypeError` — the `rel.model` property raises it now, with a message naming the field ([a3962f7255](https://github.com/dropseed/plain/commit/a3962f7255))
+- `ManyToManyField._check_through_fields` reports an unresolved target by name instead of crashing on `related_model.model_options.object_name`, so a `through_fields` mistake on a not-yet-resolved relation produces the intended preflight message ([a3962f7255](https://github.com/dropseed/plain/commit/a3962f7255))
+- `ModelState` now raises `TypeError` (was `ValueError`) when a field's `to` or `through` refers to a model class instead of a string reference, and detects it by checking the reference directly rather than probing for `_model_meta` ([a3962f7255](https://github.com/dropseed/plain/commit/a3962f7255))
+- Removed `Field.concrete`. It was set to `self.column is not None` right after `column` was assigned the field's name, so it was `True` on every forward field and the checks that consulted it were dead. `bulk_create()` and `bulk_update()` now say what they actually reject — "bulk_update() cannot be used with many-to-many fields." rather than "can only be used with concrete fields." — and `Model.save(update_fields=...)` drops "non-concrete fields" from its error message. `ForeignObjectRel.concrete` and the unreachable virtual-field skip in `Model.__init__` are gone too ([af56244677](https://github.com/dropseed/plain/commit/af56244677))
+- `OrderBy.asc()` and `.desc()` return the `OrderBy` instead of `None`, matching every other expression's `asc`/`desc` and making `expr.desc().asc()` and inline use work. They still take no options — passing `nulls_first` or `nulls_last` raises `TypeError` pointing you at the attributes on the `OrderBy` itself, rather than being silently ignored ([f00e707ed0](https://github.com/dropseed/plain/commit/f00e707ed0))
+- Preflight expression checks no longer crash when a lookup path continues past a non-relation field — for example `Meta.ordering = ("name__nope",)` on a text field. The traversal now raises `FieldDoesNotExist` for the trailing part, which preflight already reports, instead of an `AttributeError` on `None` ([d9406dfc6f](https://github.com/dropseed/plain/commit/d9406dfc6f))
+- `MigrationGraph.make_state()` raises `NodeNotFoundError` when the plan hits a placeholder node, instead of an `AttributeError` on `None` ([d9406dfc6f](https://github.com/dropseed/plain/commit/d9406dfc6f))
+- The migration autodetector and `ProjectState` narrow on `RelatedField` / `ManyToManyField` / `ManyToManyRel` instead of `hasattr(field, "remote_field")` and `getattr(remote_field, "through", None)`. Rename handling only rewrites a reference when the old field is the same kind of relation, so a field swapped between a plain relation and an M2M during a rename no longer copies a mismatched reference across ([a3962f7255](https://github.com/dropseed/plain/commit/a3962f7255))
+- `ProjectState._get_related_models` reads a forward relation's target from `remote_field.model_ref` rather than `f.model` — which returned the model the field is _declared on_, not the one it points at ([a3962f7255](https://github.com/dropseed/plain/commit/a3962f7255))
+- `Meta._expire_cache` propagation to a related model no longer swallows `AttributeError` to handle the unresolved-string case; it checks `model_ref` up front, so a genuine `AttributeError` inside `_expire_cache` surfaces ([a3962f7255](https://github.com/dropseed/plain/commit/a3962f7255))
+
+### Upgrade instructions
+
+- If you read `rel.model` or `rel.through` (via `field.remote_field`) in code that runs before models are fully loaded — preflight checks, `contribute_to_class`, custom fields, migration operations — switch to `rel.model_ref` / `rel.through_ref` and check `isinstance(ref, str)`. After model loading completes, `rel.model` and `rel.through` behave as before.
+- If you _assigned_ to `rel.model` or `rel.through`, assign to `rel.model_ref` / `rel.through_ref` instead — the plain names are now read-only properties.
+- If you referenced `Field.concrete` or `ForeignObjectRel.concrete`, remove the check. `concrete` was `True` for every forward field and `False` only on reverse relations, which `get_fields()` doesn't return unless you pass `include_reverse=True`.
+- If you asserted on the exact text of the `bulk_create()`, `bulk_update()`, or `save(update_fields=...)` errors, update the expected strings.
+- If you caught `ValueError` from `ModelState` for a model-class `to`/`through` reference, catch `TypeError`.
+- `OrderBy.asc()`/`.desc()` returning `self` is additive — existing calls that discarded the return value are unaffected.
+
 ## [0.116.0](https://github.com/dropseed/plain/releases/plain-postgres@0.116.0) (2026-09-04)
 
 ### What's changed

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/base.py

@@ -123,9 +123,6 @@ class Model(metaclass=ModelBase):
             from plain.postgres.fields.related import RelatedField
 
             is_related_object = False
-            # Virtual field
-            if field.name not in kwargs and field.column is None:
-                continue
             if isinstance(field, RelatedField) and isinstance(
                 field.remote_field, ForeignObjectRel
             ):
@@ -395,8 +392,8 @@ class Model(metaclass=ModelBase):
             non_model_fields = fields.difference(field_names)
             if non_model_fields:
                 raise ValueError(
-                    "The following fields do not exist in this model, are m2m "
-                    "fields, or are non-concrete fields: "
+                    "The following fields do not exist in this model or are m2m "
+                    "fields: "
                     f"{', '.join(sorted(non_model_fields))}"
                 )
             deferred_in_update = fields & deferred_fields
@@ -755,11 +752,14 @@ class Model(metaclass=ModelBase):
 
         fields = cls._model_meta.many_to_many
 
-        # Skip when the target model wasn't found.
-        fields = (f for f in fields if isinstance(f.remote_field.model, ModelBase))
-
-        # Skip when the relationship model wasn't found.
-        fields = (f for f in fields if isinstance(f.remote_field.through, ModelBase))
+        # Skip when the target or relationship model wasn't found; the field's
+        # own preflight reports those.
+        fields = (
+            f
+            for f in fields
+            if not isinstance(f.remote_field.model_ref, str)
+            and not isinstance(f.remote_field.through_ref, str)
+        )
 
         for f in fields:
             signature = (
@@ -1033,7 +1033,11 @@ class Model(metaclass=ModelBase):
             fld = None
             for part in field.split(LOOKUP_SEP):
                 try:
-                    fld = _cls._model_meta.get_field(part)  # ty: ignore[unresolved-attribute]
+                    if _cls is None:
+                        # The previous part was not a relation, so there is
+                        # no model left to look the next part up on.
+                        raise FieldDoesNotExist(part)
+                    fld = _cls._model_meta.get_field(part)
                     if isinstance(fld, RelatedField):
                         _cls = fld.path_infos[-1].to_meta.model
                     else:
@@ -1111,11 +1115,11 @@ class Model(metaclass=ModelBase):
 
         for f in cls._model_meta.many_to_many:
             # Skip nonexistent models.
-            if isinstance(f.remote_field.through, str):
+            if isinstance(f.remote_field.through_ref, str):
                 continue
 
             # Check if column name for the M2M field is too long for the database.
-            for m2m in f.remote_field.through._model_meta.fields:
+            for m2m in f.remote_field.through_ref._model_meta.fields:
                 rel_name = m2m.column
                 if rel_name is not None and len(rel_name) > allowed_len:
                     errors.append(

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/expressions.py

@@ -1698,11 +1698,23 @@ class OrderBy(Expression):
             self.nulls_last = None
         return self
 
-    def asc(self) -> None:  # ty: ignore[invalid-method-override]
+    def asc(self, **kwargs: Any) -> OrderBy:
+        if kwargs:
+            raise TypeError(
+                "OrderBy.asc() takes no options; set nulls_first/nulls_last on "
+                "the OrderBy itself."
+            )
         self.descending = False
+        return self
 
-    def desc(self) -> None:  # ty: ignore[invalid-method-override]
+    def desc(self, **kwargs: Any) -> OrderBy:
+        if kwargs:
+            raise TypeError(
+                "OrderBy.desc() takes no options; set nulls_first/nulls_last on "
+                "the OrderBy itself."
+            )
         self.descending = True
+        return self
 
 
 class Window(Expression):

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/fields/base.py

@@ -115,7 +115,6 @@ class Field[T](RegisterLookupMixin):
     name: str
     # Set by set_attributes_from_name (called by contribute_to_class)
     column: str
-    concrete: bool
     # Set by contribute_to_class
     model: type[Model]
 
@@ -376,7 +375,6 @@ class Field[T](RegisterLookupMixin):
         # The database column is the field name. A foreign key overrides this
         # method only to append the "_id" suffix to `column`.
         self.column = self.name
-        self.concrete = self.column is not None
 
     def contribute_to_class(self, cls: type[Model], name: str) -> None:
         """

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/fields/related.py

@@ -166,13 +166,13 @@ class RelatedField(FieldCacheMixin, Field):
 
     def _check_relation_model_exists(self) -> list[PreflightResult]:
         rel_is_missing = (
-            self.remote_field.model not in self.meta.models_registry.get_models()
+            self.remote_field.model_ref not in self.meta.models_registry.get_models()
         )
-        rel_is_string = isinstance(self.remote_field.model, str)
+        rel_is_string = isinstance(self.remote_field.model_ref, str)
         model_name = (
-            self.remote_field.model
+            self.remote_field.model_ref
             if rel_is_string
-            else self.remote_field.model.model_options.object_name
+            else self.remote_field.model_ref.model_options.object_name
         )
         if rel_is_missing and rel_is_string:
             return [
@@ -189,13 +189,11 @@ class RelatedField(FieldCacheMixin, Field):
 
     def _check_clashes(self) -> list[PreflightResult]:
         """Check accessor and reverse query name clashes."""
-        from plain.postgres.base import ModelBase
-
         errors: list[PreflightResult] = []
 
-        # f.remote_field.model may be a string instead of a model. Skip if
-        # model name is not resolved.
-        if not isinstance(self.remote_field.model, ModelBase):
+        # Skip if the target model is still an unresolved string reference;
+        # _check_relation_model_exists reports that case.
+        if isinstance(self.remote_field.model_ref, str):
             return []
 
         # Consider that we are checking field `Model.foreign` and the models
@@ -259,13 +257,13 @@ class RelatedField(FieldCacheMixin, Field):
         def resolve_related_class(
             model: type[Model], related: type[Model], field: RelatedField
         ) -> None:
-            field.remote_field.model = related
+            field.remote_field.model_ref = related
             field.do_related_class(related, model)
 
         lazy_related_operation(
             resolve_related_class,
             cls,
-            self.remote_field.model,
+            self.remote_field.model_ref,
             field=self,
         )
 
@@ -456,14 +454,14 @@ class ForeignKeyField(ColumnField, RelatedField):
         name, path, args, kwargs = super().deconstruct()
         kwargs["on_delete"] = self.remote_field.on_delete
 
-        if isinstance(self.remote_field.model, str):
-            if "." in self.remote_field.model:
-                package_label, model_name = self.remote_field.model.split(".")
+        if isinstance(self.remote_field.model_ref, str):
+            if "." in self.remote_field.model_ref:
+                package_label, model_name = self.remote_field.model_ref.split(".")
                 kwargs["to"] = f"{package_label}.{model_name.lower()}"
             else:
-                kwargs["to"] = self.remote_field.model.lower()
+                kwargs["to"] = self.remote_field.model_ref.lower()
         else:
-            kwargs["to"] = self.remote_field.model.model_options.label_lower
+            kwargs["to"] = self.remote_field.model_ref.model_options.label_lower
 
         return name, path, args, kwargs
 
@@ -473,10 +471,6 @@ class ForeignKeyField(ColumnField, RelatedField):
     @cached_property
     def target_field(self) -> Field:
         """A foreign key points at exactly one column: the remote model's id."""
-        if isinstance(self.remote_field.model, str):
-            raise TypeError(
-                f"Related model {self.remote_field.model!r} cannot be resolved"
-            )
         return self.remote_field.model._model_meta.get_forward_field("id")
 
     def set_attributes_from_name(self, name: str) -> None:
@@ -640,14 +634,17 @@ class ManyToManyField(RelatedField):
     def _check_relationship_model(
         self, from_model: type[Model] | None = None, **kwargs: Any
     ) -> list[PreflightResult]:
-        if hasattr(self.remote_field.through, "_model_meta"):
-            qualified_model_name = f"{self.remote_field.through.model_options.package_label}.{self.remote_field.through.__name__}"
+        through_ref = self.remote_field.through_ref
+        if isinstance(through_ref, str):
+            qualified_model_name = through_ref
         else:
-            qualified_model_name = self.remote_field.through
+            qualified_model_name = (
+                f"{through_ref.model_options.package_label}.{through_ref.__name__}"
+            )
 
         errors = []
 
-        if self.remote_field.through not in self.meta.models_registry.get_models():
+        if through_ref not in self.meta.models_registry.get_models():
             # The relationship model is not installed.
             errors.append(
                 PreflightResult(
@@ -668,7 +665,7 @@ class ManyToManyField(RelatedField):
                 "where the field is attached to."
             )
             # Set some useful local variables
-            to_model = resolve_relation(from_model, self.remote_field.model)
+            to_model = resolve_relation(from_model, self.remote_field.model_ref)
             from_model_name = from_model.model_options.object_name
             if isinstance(to_model, str):
                 to_model_name = to_model
@@ -681,7 +678,7 @@ class ManyToManyField(RelatedField):
             # Count foreign keys in intermediate model
             if self_referential:
                 seen_self = sum(
-                    from_model == field.remote_field.model
+                    from_model == field.remote_field.model_ref
                     for field in self.remote_field.through._model_meta.fields
                     if isinstance(field, RelatedField)
                 )
@@ -704,12 +701,12 @@ class ManyToManyField(RelatedField):
             else:
                 # Count foreign keys in relationship model
                 seen_from = sum(
-                    from_model == field.remote_field.model
+                    from_model == field.remote_field.model_ref
                     for field in self.remote_field.through._model_meta.fields
                     if isinstance(field, RelatedField)
                 )
                 seen_to = sum(
-                    to_model == field.remote_field.model
+                    to_model == field.remote_field.model_ref
                     for field in self.remote_field.through._model_meta.fields
                     if isinstance(field, RelatedField)
                 )
@@ -797,7 +794,7 @@ class ManyToManyField(RelatedField):
                 source, through, target = (
                     from_model,
                     self.remote_field.through,
-                    self.remote_field.model,
+                    self.remote_field.model_ref,
                 )
                 source_field_name, target_field_name = self.remote_field.through_fields[
                     :2
@@ -807,18 +804,24 @@ class ManyToManyField(RelatedField):
                     (source_field_name, source),
                     (target_field_name, target),
                 ):
+                    # The target may still be an unresolved "package.Model" string.
+                    related_model_name = (
+                        related_model
+                        if isinstance(related_model, str)
+                        else related_model.model_options.object_name
+                    )
                     possible_field_names: list[str] = []
                     for f in through._model_meta.fields:
                         if (
-                            hasattr(f, "remote_field")
-                            and getattr(f.remote_field, "model", None) == related_model
+                            isinstance(f, RelatedField)
+                            and f.remote_field.model_ref == related_model
                         ):
                             possible_field_names.append(f.name)
                     if possible_field_names:
                         fix = (
                             "Did you mean one of the following foreign keys to '{}': "
                             "{}?".format(
-                                related_model.model_options.object_name,
+                                related_model_name,
                                 ", ".join(possible_field_names),
                             )
                         )
@@ -838,11 +841,11 @@ class ManyToManyField(RelatedField):
                     else:
                         if not (
                             isinstance(field, RelatedField)
-                            and field.remote_field.model == related_model
+                            and field.remote_field.model_ref == related_model
                         ):
                             errors.append(
                                 PreflightResult(
-                                    fix=f"'{through.model_options.object_name}.{field_name}' is not a foreign key to '{related_model.model_options.object_name}'. {fix}",
+                                    fix=f"'{through.model_options.object_name}.{field_name}' is not a foreign key to '{related_model_name}'. {fix}",
                                     obj=self,
                                     id="fields.m2m_through_field_not_fk_to_model",
                                 )
@@ -851,7 +854,7 @@ class ManyToManyField(RelatedField):
         return errors
 
     def _check_table_uniqueness(self, **kwargs: Any) -> list[PreflightResult]:
-        if isinstance(self.remote_field.through, str):
+        if isinstance(self.remote_field.through_ref, str):
             return []
         registered_tables = {
             model.model_options.db_table: model
@@ -880,19 +883,19 @@ class ManyToManyField(RelatedField):
         name, path, args, kwargs = super().deconstruct()
 
         # Lowercase model names as they should be treated as case-insensitive.
-        if isinstance(self.remote_field.model, str):
-            if "." in self.remote_field.model:
-                package_label, model_name = self.remote_field.model.split(".")
+        if isinstance(self.remote_field.model_ref, str):
+            if "." in self.remote_field.model_ref:
+                package_label, model_name = self.remote_field.model_ref.split(".")
                 kwargs["to"] = f"{package_label}.{model_name.lower()}"
             else:
-                kwargs["to"] = self.remote_field.model.lower()
+                kwargs["to"] = self.remote_field.model_ref.lower()
         else:
-            kwargs["to"] = self.remote_field.model.model_options.label_lower
+            kwargs["to"] = self.remote_field.model_ref.model_options.label_lower
 
-        if isinstance(self.remote_field.through, str):
-            kwargs["through"] = self.remote_field.through
+        if isinstance(self.remote_field.through_ref, str):
+            kwargs["through"] = self.remote_field.through_ref
         else:
-            kwargs["through"] = self.remote_field.through.model_options.label
+            kwargs["through"] = self.remote_field.through_ref.model_options.label
 
         return name, path, args, kwargs
 
@@ -990,12 +993,12 @@ class ManyToManyField(RelatedField):
         def resolve_through_model(
             _: Any, model: type[Model], field: ManyToManyField
         ) -> None:
-            field.remote_field.through = model
+            field.remote_field.through_ref = model
 
         lazy_related_operation(
             resolve_through_model,
             cls,
-            self.remote_field.through,
+            self.remote_field.through_ref,
             field=self,
         )
 

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/fields/reverse_related.py

@@ -41,7 +41,6 @@ class ForeignObjectRel(FieldCacheMixin):
 
     # Field flags
     auto_created = True
-    concrete = False
 
     # Reverse relations are always nullable (Plain can't enforce that a
     # foreign key on the related model points to this model).
@@ -49,8 +48,11 @@ class ForeignObjectRel(FieldCacheMixin):
     empty_strings_allowed = False
 
     # Type annotations for instance attributes
-    model: type[Model]
     on_delete: OnDelete | None
+    # The target model as given to the field: a "package.Model" string (or
+    # "self") until lazy_related_operation resolves it to the class. Read
+    # `model` for the resolved class.
+    model_ref: str | type[Model]
 
     def __init__(
         self,
@@ -65,9 +67,7 @@ class ForeignObjectRel(FieldCacheMixin):
         # route every `self.field` read through its __get__. ForeignKeyRel
         # and ManyToManyRel below narrow this further, the same way.
         self.field: RelatedField = field
-        # Initially may be a string, gets resolved to type[Model] by lazy_related_operation
-        # (see related.py:250 where field.remote_field.model is overwritten)
-        self.model = to  # ty: ignore[invalid-assignment]
+        self.model_ref = to
         self.related_query_name = related_query_name
         self.on_delete = on_delete
 
@@ -77,6 +77,18 @@ class ForeignObjectRel(FieldCacheMixin):
     # __init__ as the field doesn't have its model yet. Calling these methods
     # before field.contribute_to_class() has been called will result in
     # AttributeError
+    @property
+    def model(self) -> type[Model]:
+        """The resolved target model class."""
+        # Deliberately not AttributeError: getattr(rel, "model", None) and
+        # hasattr() would swallow that and silently report "no model".
+        if isinstance(self.model_ref, str):
+            raise TypeError(
+                f"Related model {self.model_ref!r} for {self.field!r} has not been "
+                "resolved yet; use model_ref to read the unresolved reference."
+            )
+        return self.model_ref
+
     @cached_property
     def name(self) -> str:
         return self.field.related_query_name()
@@ -113,7 +125,7 @@ class ForeignObjectRel(FieldCacheMixin):
     def identity(self) -> tuple[Any, ...]:
         return (
             self.field,
-            self.model,
+            self.model_ref,
             self.related_query_name,
             self.on_delete,
             self.symmetrical,
@@ -203,8 +215,10 @@ class ManyToManyRel(ForeignObjectRel):
     """
 
     # Type annotations for instance attributes
-    through: type[Model]
     through_fields: tuple[str, str] | None
+    # The intermediary model as given to the field; a string until
+    # lazy_related_operation resolves it. Read `through` for the class.
+    through_ref: str | type[Model]
 
     def __init__(
         self,
@@ -226,9 +240,7 @@ class ManyToManyRel(ForeignObjectRel):
         # annotation).
         self.field: ManyToManyField
 
-        # Initially may be a string, gets resolved to type[Model] by lazy_related_operation
-        # (see related.py:1143 where field.remote_field.through is overwritten)
-        self.through = through  # ty: ignore[invalid-assignment]
+        self.through_ref = through
         self.through_fields = through_fields
 
         self.symmetrical = symmetrical
@@ -236,6 +248,17 @@ class ManyToManyRel(ForeignObjectRel):
     @property
     def identity(self) -> tuple[Any, ...]:
         return super().identity + (
-            self.through,
+            self.through_ref,
             make_hashable(self.through_fields),
         )
+
+    @property
+    def through(self) -> type[Model]:
+        """The resolved intermediary model class."""
+        # Deliberately not AttributeError, for the same reason as `model`.
+        if isinstance(self.through_ref, str):
+            raise TypeError(
+                f"Through model {self.through_ref!r} for {self.field!r} has not been "
+                "resolved yet; use through_ref to read the unresolved reference."
+            )
+        return self.through_ref

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/meta.py

@@ -178,11 +178,10 @@ class Meta:
         # ideally, we'd just ask for field.related_model. However, related_model
         # is a cached property, and all the models haven't been loaded yet, so
         # we need to make sure we don't cache a string reference.
-        if isinstance(field, RelatedField) and field.remote_field.model:
-            try:
-                field.remote_field.model._model_meta._expire_cache(forward=False)
-            except AttributeError:
-                pass
+        if isinstance(field, RelatedField):
+            remote_model = field.remote_field.model_ref
+            if not isinstance(remote_model, str):
+                remote_model._model_meta._expire_cache(forward=False)
             self._expire_cache()
         else:
             self._expire_cache(reverse=False)
@@ -326,8 +325,8 @@ class Meta:
                 if isinstance(f, RelatedField)
             )
             for f in fields_with_relations:
-                if not isinstance(f.remote_field.model, str):
-                    remote_label = f.remote_field.model.model_options.label
+                if not isinstance(f.remote_field.model_ref, str):
+                    remote_label = f.remote_field.model_ref.model_options.label
                     related_objects_graph[remote_label].append(f)
 
         for model in all_models:

{plain_postgres-0.116.0 → plain_postgres-0.117.0}/plain/postgres/migrations/autodetector.py

@@ -139,7 +139,7 @@ class MigrationAutodetector:
         fields_def = []
         for name, field in sorted(fields.items()):
             deconstruction = self.deep_deconstruct(field)
-            if isinstance(field, RelatedField) and field.remote_field.model:
+            if isinstance(field, RelatedField) and field.remote_field.model_ref:
                 deconstruction[2].pop("to", None)
             fields_def.append(deconstruction)
         return fields_def
@@ -244,11 +244,9 @@ class MigrationAutodetector:
             )
             old_model_state = self.from_state.models[package_label, old_model_name]
             for field_name, field in old_model_state.fields.items():
-                if hasattr(field, "remote_field") and getattr(
-                    field.remote_field, "through", None
-                ):
+                if isinstance(field, ManyToManyField):
                     through_key = resolve_relation(
-                        field.remote_field.through,  # ty: ignore[unresolved-attribute]
+                        field.remote_field.through_ref,
                         package_label,
                         model_name,
                     )
@@ -537,7 +535,7 @@ class MigrationAutodetector:
             related_fields = {}
             for field_name, field in model_state.fields.items():
                 if isinstance(field, RelatedField):
-                    if field.remote_field.model:
+                    if field.remote_field.model_ref:
                         related_fields[field_name] = field
                     if isinstance(field.remote_field, ManyToManyRel):
                         related_fields[field_name] = field
@@ -639,7 +637,7 @@ class MigrationAutodetector:
             related_fields = {}
             for field_name, field in model_state.fields.items():
                 if isinstance(field, RelatedField):
-                    if field.remote_field.model:
+                    if field.remote_field.model_ref:
                         related_fields[field_name] = field
                     if isinstance(field.remote_field, ManyToManyRel):
                         related_fields[field_name] = field
@@ -720,7 +718,7 @@ class MigrationAutodetector:
                     if (
                         isinstance(field, RelatedField)
                         and field.remote_field
-                        and field.remote_field.model
+                        and field.remote_field.model_ref
                         and "to" in old_field_dec[2]
                     ):
                         old_rel_to = old_field_dec[2]["to"]
@@ -790,7 +788,7 @@ class MigrationAutodetector:
             (package_label, model_name, field_name, False)
         ]
         # Fields that are foreignkeys/m2ms depend on stuff.
-        if isinstance(field, RelatedField) and field.remote_field.model:
+        if isinstance(field, RelatedField) and field.remote_field.model_ref:
             dependencies.extend(
                 self._get_dependencies_for_foreign_key(
                     package_label,
@@ -888,16 +886,16 @@ class MigrationAutodetector:
             dependencies: list[tuple[str, str, str | None, bool | str]] = []
             # Implement any model renames on relations; these are handled by RenameModel
             # so we need to exclude them from the comparison
-            if hasattr(new_field, "remote_field") and getattr(
-                new_field.remote_field, "model", None
-            ):
+            if isinstance(new_field, RelatedField):
                 rename_key = resolve_relation(
-                    new_field.remote_field.model,  # ty: ignore[unresolved-attribute]
+                    new_field.remote_field.model_ref,
                     package_label,
                     model_name,
                 )
-                if rename_key in self.renamed_models:
-                    new_field.remote_field.model = old_field.remote_field.model  # ty: ignore[unresolved-attribute]
+                if rename_key in self.renamed_models and isinstance(
+                    old_field, RelatedField
+                ):
+                    new_field.remote_field.model_ref = old_field.remote_field.model_ref
                 dependencies.extend(
                     self._get_dependencies_for_foreign_key(
                         package_label,
@@ -906,16 +904,18 @@ class MigrationAutodetector:
                         self.to_state,
                     )
                 )
-            if hasattr(new_field, "remote_field") and getattr(
-                new_field.remote_field, "through", None
-            ):
+            if isinstance(new_field, ManyToManyField):
                 rename_key = resolve_relation(
-                    new_field.remote_field.through,  # ty: ignore[unresolved-attribute]
+                    new_field.remote_field.through_ref,
                     package_label,
                     model_name,
                 )
-                if rename_key in self.renamed_models:
-                    new_field.remote_field.through = old_field.remote_field.through  # ty: ignore[unresolved-attribute]
+                if rename_key in self.renamed_models and isinstance(
+                    old_field, ManyToManyField
+                ):
+                    new_field.remote_field.through_ref = (
+                        old_field.remote_field.through_ref
+                    )
             old_field_dec = self.deep_deconstruct(old_field)
             new_field_dec = self.deep_deconstruct(new_field)
             # Exclude non_migration_attrs (allow_null, default, on_delete, choices,
@@ -1004,7 +1004,7 @@ class MigrationAutodetector:
     ) -> list[tuple[str, str, str | None, bool | str]]:
         remote_field_model = None
         if isinstance(field, RelatedField):
-            remote_field_model = field.remote_field.model
+            remote_field_model = field.remote_field.model_ref
         else:
             relations = project_state.relations[package_label, model_name]
             for (remote_package_label, remote_model_name), fields in relations.items():
@@ -1027,7 +1027,7 @@ class MigrationAutodetector:
             field.remote_field, ManyToManyRel
         ):
             through_package_label, through_object_name = resolve_relation(
-                field.remote_field.through,
+                field.remote_field.through_ref,
                 package_label,
                 model_name,
             )