plain.postgres 0.115.0__tar.gz → 0.117.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: plain.postgres
-Version: 0.115.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.115.0 → plain_postgres-0.117.0}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,51 @@
 # 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
+
+- **`Meta` now exposes exactly two forward-field collections: `fields` and `many_to_many`.** `local_fields`, `local_many_to_many`, `concrete_fields`, and `local_concrete_fields` are gone. Plain has no model inheritance and no non-concrete forward fields, so "local" and "concrete" drew distinctions that could never differ — four names for two lists, each with its own cached property and its own filtering pass. `fields` is every column-backed field (primary key first, then sorted by name) and `many_to_many` is every `ManyToManyField` (sorted by name); both now read straight from the storage `add_field()` fills, instead of re-filtering `_get_fields()` on each access ([9f0d0da22d](https://github.com/dropseed/plain/commit/9f0d0da22d))
+- `Meta.fields` is typed as `ImmutableList[ColumnField]` and `Meta.many_to_many` as `ImmutableList[ManyToManyField]`, so the column attributes (`column`, `db_type()`, `primary_key`) are readable off a field without an `isinstance` check first. `add_field()` enforces that by raising `TypeError` for a field that is neither a `ColumnField` nor a `ManyToManyField` ([996c099e2b](https://github.com/dropseed/plain/commit/996c099e2b), [9f0d0da22d](https://github.com/dropseed/plain/commit/9f0d0da22d))
+- The `postgres.non_local_field_reference` preflight check is removed. It rejected an `indexes` or `constraints` entry naming a field "not local to" the model — unreachable without inheritance, since a forward field found on the model is always the model's own ([9f0d0da22d](https://github.com/dropseed/plain/commit/9f0d0da22d))
+- `Field.name` is typed `str` instead of `str | None` — it starts as `""` and becomes the real name in `set_attributes_from_name()`. That drops roughly twenty `assert self.name is not None` guards from the field descriptor, save, and preflight paths. `Field.deconstruct()` (and the `ColumnField`, `DefaultableField`, `ChoicesField`, `RelatedField`, `ForeignKeyField`, and `ManyToManyField` overrides) returns `tuple[str, str, list, dict]` accordingly ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+- `get_joining_columns()` moved from `ForeignObjectRel` to `ForeignKeyRel`. It delegates to `field.get_joining_columns(reverse_join=True)`, which only a foreign key has ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+- `PathInfo.join_field` is typed `ForeignKeyField | ForeignKeyRel` (was `ForeignKeyField | ForeignObjectRel`), and `select_related_descend()` is a `TypeGuard[RelatedField]` so a passing field narrows at the call site ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+- `QuerySet._update()`, `_insert()`, `_batched_insert()`, `UpdateQuery.add_update_fields()`, and `InsertQuery.insert_values()` accept a `Sequence` of fields rather than requiring a `list`, so an `ImmutableList` from `Meta` can be passed straight through ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+
+### Upgrade instructions
+
+- Replace `_model_meta.local_fields`, `_model_meta.concrete_fields`, and `_model_meta.local_concrete_fields` with `_model_meta.fields`. In Plain these were always the same set of fields.
+- Replace `_model_meta.local_many_to_many` with `_model_meta.many_to_many`.
+- Replace `_model_meta._non_pk_concrete_field_names` with `_model_meta._non_pk_field_names`.
+- If you have a custom `Field` subclass, `deconstruct()` now returns `str` as its first element rather than `str | None`, and `self.name` is `""` (not `None`) before the field is contributed to a model class. Update any annotation or `is None` check accordingly.
+- If you called `get_joining_columns()` on a reverse relation, it is now available on `ForeignKeyRel` only.
+
 ## [0.115.0](https://github.com/dropseed/plain/releases/plain-postgres@0.115.0) (2026-09-02)
 
 ### What's changed

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

@@ -27,7 +27,6 @@ from plain.postgres.exceptions import (
 )
 from plain.postgres.expressions import RawSQL, Value
 from plain.postgres.fields import DATABASE_DEFAULT, Field
-from plain.postgres.fields.base import ColumnField
 from plain.postgres.fields.related import RelatedField
 from plain.postgres.fields.reverse_related import ForeignObjectRel
 from plain.postgres.meta import Meta
@@ -123,14 +122,7 @@ class Model(metaclass=ModelBase):
         for field in meta.fields:
             from plain.postgres.fields.related import RelatedField
 
-            # meta.fields excludes ManyToManyField, so every iterated field
-            # is column-backed and exposes the ColumnField surface.
-            assert isinstance(field, ColumnField)
-
             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
             ):
@@ -193,16 +185,14 @@ class Model(metaclass=ModelBase):
 
     @classmethod
     def from_db(cls, field_names: Iterable[str], values: Sequence[Any]) -> Model:
-        if len(values) != len(cls._model_meta.concrete_fields):
+        if len(values) != len(cls._model_meta.fields):
             values_iter = iter(values)
             values = [
                 next(values_iter) if f.name in field_names else DEFERRED
-                for f in cls._model_meta.concrete_fields
+                for f in cls._model_meta.fields
             ]
         # Build kwargs dict from field names and values
-        field_dict = dict(
-            zip((f.name for f in cls._model_meta.concrete_fields), values)
-        )
+        field_dict = dict(zip((f.name for f in cls._model_meta.fields), values))
         new = cls(_from_db=True, **field_dict)
         new._state.adding = False
         return new
@@ -279,11 +269,7 @@ class Model(metaclass=ModelBase):
         """
         Return a set containing names of deferred fields for this instance.
         """
-        return {
-            f.name
-            for f in self._model_meta.concrete_fields
-            if f.name not in self.__dict__
-        }
+        return {f.name for f in self._model_meta.fields if f.name not in self.__dict__}
 
     def refresh_from_db(self, fields: list[str] | None = None) -> None:
         """
@@ -320,15 +306,13 @@ class Model(metaclass=ModelBase):
             db_instance_qs = db_instance_qs.only(*fields)
         elif deferred_fields:
             fields = [
-                f.name
-                for f in self._model_meta.concrete_fields
-                if f.name not in deferred_fields
+                f.name for f in self._model_meta.fields if f.name not in deferred_fields
             ]
             db_instance_qs = db_instance_qs.only(*fields)
 
         db_instance = db_instance_qs.get()
         non_loaded_fields = db_instance.get_deferred_fields()
-        for field in self._model_meta.concrete_fields:
+        for field in self._model_meta.fields:
             if field.name in non_loaded_fields:
                 # This field wasn't refreshed - skip ahead.
                 continue
@@ -404,12 +388,12 @@ class Model(metaclass=ModelBase):
             if not fields:
                 return self  # explicit "update nothing" -- no-op
             fields = frozenset(fields)
-            field_names = self._model_meta._non_pk_concrete_field_names
+            field_names = self._model_meta._non_pk_field_names
             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
@@ -420,7 +404,7 @@ class Model(metaclass=ModelBase):
                 )
         elif deferred_fields:
             # Loaded via .only()/.defer() -- write just the loaded fields.
-            loaded = self._model_meta._non_pk_concrete_field_names - deferred_fields
+            loaded = self._model_meta._non_pk_field_names - deferred_fields
             if loaded:
                 fields = loaded
         self._prepare_related_fields_for_save(
@@ -484,7 +468,7 @@ class Model(metaclass=ModelBase):
         fields from RETURNING. Omits id from the INSERT when unset so Postgres
         generates the identity value."""
         meta = self._model_meta
-        fields = list(meta.local_concrete_fields)
+        fields = list(meta.fields)
         if self.id is None:
             id_field = meta.get_forward_field("id")
             fields = [f for f in fields if f is not id_field]
@@ -494,7 +478,6 @@ class Model(metaclass=ModelBase):
         )
         if results:
             for value, field in zip(results[0], returning_fields):
-                assert field.name is not None
                 setattr(self, field.name, value)
 
     def _update_row(self, fields: Iterable[str] | None) -> None:
@@ -502,7 +485,7 @@ class Model(metaclass=ModelBase):
         row matched -- update() targets an existing row and has no INSERT
         fallback (that's create())."""
         meta = self._model_meta
-        non_pks = [f for f in meta.local_concrete_fields if not f.primary_key]
+        non_pks = [f for f in meta.fields if not f.primary_key]
         if fields:
             non_pks = [f for f in non_pks if f.name in fields]
         values = [(f, f.pre_save(self, False)) for f in non_pks]
@@ -525,7 +508,7 @@ class Model(metaclass=ModelBase):
     ) -> None:
         # Ensure that a model instance without a PK hasn't been assigned to
         # a ForeignKeyField on this model. If the field is nullable, allowing the save would result in silent data loss.
-        for field in self._model_meta.concrete_fields:
+        for field in self._model_meta.fields:
             if field_names and field.name not in field_names:
                 continue
             # If the related field isn't cached, then an instance hasn't been
@@ -578,7 +561,6 @@ class Model(metaclass=ModelBase):
         with transaction.mark_for_rollback_on_error():
             count = self._model_meta.base_queryset.filter(id=self.id)._raw_delete()
         id_field = self._model_meta.get_forward_field("id")
-        assert id_field.name is not None
         setattr(self, id_field.name, None)
         # Only the id is cleared -- every other field value survives so callers
         # can still reference a deleted row (correlate it, log it, check it's
@@ -611,7 +593,7 @@ class Model(metaclass=ModelBase):
         meta = meta or self._model_meta
         return {
             field.name: Value(field.value_from_object(self), field)
-            for field in meta.local_concrete_fields
+            for field in meta.fields
             if field.name not in exclude
         }
 
@@ -755,9 +737,9 @@ class Model(metaclass=ModelBase):
     def _check_fields(cls) -> list[PreflightResult]:
         """Perform all field checks."""
         errors: list[PreflightResult] = []
-        for field in cls._model_meta.local_fields:
+        for field in cls._model_meta.fields:
             errors.extend(field.preflight(from_model=cls))
-        for field in cls._model_meta.local_many_to_many:
+        for field in cls._model_meta.many_to_many:
             errors.extend(field.preflight(from_model=cls))
         return errors
 
@@ -768,13 +750,16 @@ class Model(metaclass=ModelBase):
         errors: list[PreflightResult] = []
         seen_intermediary_signatures = []
 
-        fields = cls._model_meta.local_many_to_many
+        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 = (
@@ -800,9 +785,7 @@ class Model(metaclass=ModelBase):
     def _check_id_field(cls) -> list[PreflightResult]:
         """Disallow user-defined fields named ``id``."""
         if any(
-            f
-            for f in cls._model_meta.local_fields
-            if f.name == "id" and not f.auto_created
+            f for f in cls._model_meta.fields if f.name == "id" and not f.auto_created
         ):
             return [
                 PreflightResult(
@@ -819,7 +802,7 @@ class Model(metaclass=ModelBase):
         errors: list[PreflightResult] = []
         used_fields = {}  # name -> field
 
-        for f in cls._model_meta.local_fields:
+        for f in cls._model_meta.fields:
             clash = used_fields.get(f.name)
             # Note that we may detect clash between user-defined non-unique
             # field "id" and automatically added unique field "id", both
@@ -847,7 +830,7 @@ class Model(metaclass=ModelBase):
         used_column_names: list[str] = []
         errors: list[PreflightResult] = []
 
-        for f in cls._model_meta.local_fields:
+        for f in cls._model_meta.fields:
             column_name = f.column
 
             # Ensure the column name is not already in use.
@@ -915,7 +898,7 @@ class Model(metaclass=ModelBase):
     @classmethod
     def _check_single_primary_key(cls) -> list[PreflightResult]:
         errors: list[PreflightResult] = []
-        if sum(1 for f in cls._model_meta.local_fields if f.primary_key) > 1:
+        if sum(1 for f in cls._model_meta.fields if f.primary_key) > 1:
             errors.append(
                 PreflightResult(
                     fix="The model cannot have more than one field with "
@@ -966,11 +949,11 @@ class Model(metaclass=ModelBase):
             include for index in cls.model_options.indexes for include in index.include
         ]
         fields += references
-        errors.extend(cls._check_local_fields(fields, "indexes"))
+        errors.extend(cls._check_referenced_fields(fields, "indexes"))
         return errors
 
     @classmethod
-    def _check_local_fields(
+    def _check_referenced_fields(
         cls, fields: Iterable[str], option: str
     ) -> list[PreflightResult]:
         # In order to avoid hitting the relation tree prematurely, we use our
@@ -1003,15 +986,6 @@ class Model(metaclass=ModelBase):
                             id="postgres.m2m_field_in_meta_option",
                         )
                     )
-                elif field not in cls._model_meta.local_fields:
-                    errors.append(
-                        PreflightResult(
-                            fix=f"'{option}' refers to field '{field_name}' which is not local to model "
-                            f"'{cls.model_options.object_name}'.",
-                            obj=cls,
-                            id="postgres.non_local_field_reference",
-                        )
-                    )
         return errors
 
     @classmethod
@@ -1059,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:
@@ -1089,9 +1067,9 @@ class Model(metaclass=ModelBase):
         meta = cls._model_meta
         valid_fields = set(
             chain.from_iterable(
-                (f.name,)
-                if not (f.auto_created and not f.concrete)
-                else (f.field.related_query_name(),)
+                (f.field.related_query_name(),)
+                if isinstance(f, ForeignObjectRel)
+                else (f.name,)
                 for f in chain(meta.fields, meta.related_objects)
             )
         )
@@ -1121,7 +1099,7 @@ class Model(metaclass=ModelBase):
         # silently truncate, so we check for names that are too long
         allowed_len = MAX_NAME_LENGTH
 
-        for f in cls._model_meta.local_fields:
+        for f in cls._model_meta.fields:
             column_name = f.column
 
             # Check if column name is too long for the database.
@@ -1135,13 +1113,13 @@ class Model(metaclass=ModelBase):
                     )
                 )
 
-        for f in cls._model_meta.local_many_to_many:
+        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.local_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(
@@ -1235,7 +1213,7 @@ class Model(metaclass=ModelBase):
                         id="postgres.constraint_refers_to_joined_field",
                     )
                 )
-        errors.extend(cls._check_local_fields(fields, "constraints"))
+        errors.extend(cls._check_referenced_fields(fields, "constraints"))
         return errors
 
 

{plain_postgres-0.115.0 → plain_postgres-0.117.0}/plain/postgres/connection.py

@@ -535,9 +535,7 @@ class DatabaseConnection:
         tables = set()
         for model in get_migratable_models():
             tables.add(model.model_options.db_table)
-            tables.update(
-                f.m2m_db_table() for f in model._model_meta.local_many_to_many
-            )
+            tables.update(f.m2m_db_table() for f in model._model_meta.many_to_many)
         tables = list(tables)
         if only_existing:
             existing_tables = set(self.table_names(include_views=include_views))

{plain_postgres-0.115.0 → plain_postgres-0.117.0}/plain/postgres/constraints.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from types import NoneType
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from plain.exceptions import ValidationError
 from plain.postgres.constants import LOOKUP_SEP
@@ -454,7 +454,7 @@ class UniqueConstraint(BaseConstraint):
         field_names[-1] = f"and {field_names[-1]}"
         # Comma-join when more than two, otherwise just space-join.
         sep = ", " if len(field_names) > 2 else " "
-        params["field_label"] = sep.join(cast(list[str], field_names))
+        params["field_label"] = sep.join(field_names)
 
         # Use the first field's message format.
         message = meta.get_forward_field(unique_check[0]).unique_error_message

{plain_postgres-0.115.0 → plain_postgres-0.117.0}/plain/postgres/convergence/analysis.py

@@ -21,7 +21,6 @@ from ..ddl import (
     compile_literal_default_sql,
 )
 from ..dialect import quote_name
-from ..fields.base import ColumnField
 from ..fields.related import ForeignKeyField
 from ..indexes import Index
 from ..introspection import (
@@ -586,9 +585,7 @@ def _compare_columns(
     statuses: list[ColumnStatus] = []
     expected_col_names: set[str] = set()
 
-    for f in model._model_meta.local_fields:
-        if not isinstance(f, ColumnField):
-            continue
+    for f in model._model_meta.fields:
         db_type = f.db_type()
         if db_type is None:
             continue
@@ -635,8 +632,6 @@ def _compare_columns(
         if f.primary_key:
             pk_suffix = f.db_type_suffix() or ""
 
-        # Fields reached via local_fields are always contributed (name set).
-        assert f.name is not None
         statuses.append(
             ColumnStatus(
                 name=f.column,
@@ -1193,7 +1188,7 @@ def _compare_check_constraints(
     # ignored rather than surfaced as undeclared user constraints.
     internal_checks = {
         generate_notnull_check_name(table, f.column)
-        for f in model._model_meta.local_fields
+        for f in model._model_meta.fields
         if f.db_type() is not None
     }
 
@@ -1245,7 +1240,7 @@ def _compare_foreign_keys(
     # Expected FKs from model fields, keyed by shape (column, target_table,
     # target_column) — the DB-side identity, since names can lag a rename.
     expected_fks: dict[tuple[str, str, str], ForeignKeyField] = {}
-    for f in model._model_meta.local_fields:
+    for f in model._model_meta.fields:
         if isinstance(f, ForeignKeyField):
             to_table = f.target_field.model.model_options.db_table
             expected_fks[(f.column, to_table, f.target_field.column)] = f

{plain_postgres-0.115.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.115.0 → plain_postgres-0.117.0}/plain/postgres/fields/base.py

@@ -110,11 +110,11 @@ class Field[T](RegisterLookupMixin):
     cast_db_type_sql: str | None = None
 
     # Instance attributes set during field lifecycle
-    # Set by __init__
-    name: str | None
+    # Set by __init__; becomes the real field name once contributed to a
+    # model class (set_attributes_from_name, called by contribute_to_class)
+    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]
 
@@ -134,7 +134,7 @@ class Field[T](RegisterLookupMixin):
     non_migration_attrs: tuple[str, ...] = ()
 
     def __init__(self) -> None:
-        self.name = None  # Set by set_attributes_from_name
+        self.name = ""  # Set by set_attributes_from_name
         self.primary_key = False
         self.auto_created = False
 
@@ -151,8 +151,8 @@ class Field[T](RegisterLookupMixin):
     def __repr__(self) -> str:
         """Display the module, class, and name of the field."""
         path = f"{self.__class__.__module__}.{self.__class__.__qualname__}"
-        name = getattr(self, "name", None)
-        if name is not None:
+        name = getattr(self, "name", "")
+        if name:
             return f"<{path}: {name}>"
         return f"<{path}>"
 
@@ -164,7 +164,6 @@ class Field[T](RegisterLookupMixin):
         Check if field name is valid, i.e. 1) does not end with an
         underscore, 2) does not contain "__" and 3) is not "id".
         """
-        assert self.name is not None, "Field name must be set before checking"
         if self.name.endswith("_"):
             return [
                 PreflightResult(
@@ -215,7 +214,7 @@ class Field[T](RegisterLookupMixin):
         """
         return sql, params
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         """
         Return enough information to recreate the field as a 4-tuple:
 
@@ -259,7 +258,6 @@ class Field[T](RegisterLookupMixin):
             cls_name = self.__class__.__qualname__
             if getattr(_postgres_root, cls_name, None) is self.__class__:
                 path = f"plain.postgres.{cls_name}"
-        # Note: self.name can be None during migration state rendering when fields are cloned
         return (self.name, path, [], keywords)
 
     def clone(self) -> Self:
@@ -305,7 +303,6 @@ class Field[T](RegisterLookupMixin):
             # values - so, this is very close to normal pickle.
             state = self.__dict__.copy()
             return _empty, (self.__class__,), state
-        assert self.name is not None
         options = model.model_options
         return _load_field, (
             options.package_label,
@@ -378,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:
         """
@@ -394,7 +390,6 @@ class Field[T](RegisterLookupMixin):
         # Field is its own descriptor; make sure it is set on the class so
         # attribute access hits __get__/__set__.
         if self.column:
-            assert self.name is not None
             setattr(cls, self.name, self)
 
     # Descriptor protocol implementation
@@ -422,7 +417,6 @@ class Field[T](RegisterLookupMixin):
             return self
 
         # Instance access - get value from instance dict
-        assert self.name is not None
         data = instance.__dict__
         field_name = self.name
 
@@ -432,9 +426,7 @@ class Field[T](RegisterLookupMixin):
         # instance cheap to use beyond its primary key.
         if field_name not in data:
             missing = [
-                f.name
-                for f in instance._model_meta.concrete_fields
-                if f.name not in data
+                f.name for f in instance._model_meta.fields if f.name not in data
             ]
             instance.refresh_from_db(fields=missing)
 
@@ -472,7 +464,6 @@ class Field[T](RegisterLookupMixin):
             stored = self.to_python(value)
 
         # Store in instance dict
-        assert self.name is not None
         instance.__dict__[self.name] = stored
 
     def __delete__(self, instance: Model) -> None:
@@ -481,7 +472,6 @@ class Field[T](RegisterLookupMixin):
 
         Removes the value from instance.__dict__.
         """
-        assert self.name is not None
         try:
             del instance.__dict__[self.name]
         except KeyError:
@@ -491,7 +481,6 @@ class Field[T](RegisterLookupMixin):
 
     def pre_save(self, model_instance: Model, add: bool) -> T | None:
         """Return field's value just before saving."""
-        assert self.name is not None
         return getattr(model_instance, self.name)
 
     def get_prep_value(self, value: Any) -> Any:
@@ -544,12 +533,10 @@ class Field[T](RegisterLookupMixin):
         return self.get_db_default_expression() is not None
 
     def save_form_data(self, instance: Model, data: Any) -> None:
-        assert self.name is not None
         setattr(instance, self.name, data)
 
     def value_from_object(self, obj: Model) -> T | None:
         """Return the value of this field in the given model instance."""
-        assert self.name is not None
         return getattr(obj, self.name)
 
 
@@ -653,7 +640,7 @@ class ColumnField[T](Field[T]):
             return None
         return self._default_empty_value
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.required is not True:
             kwargs["required"] = self.required
@@ -750,7 +737,7 @@ class DefaultableField[T](ColumnField[T]):
         # shared state across instances.
         return copy.deepcopy(self.default)
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.default is not NOT_PROVIDED:
             kwargs["default"] = self.default
@@ -891,7 +878,7 @@ class ChoicesField[T](DefaultableField[T]):
             )
         super().validate(value, model_instance)
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.choices is not None:
             choices = self.choices

{plain_postgres-0.115.0 → plain_postgres-0.117.0}/plain/postgres/fields/binary.py

@@ -41,7 +41,7 @@ class BinaryField[
         if self.max_length is not None:
             self.validators.append(MaxLengthValidator(self.max_length))
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         name, path, args, kwargs = super().deconstruct()
         if self.max_length is not None:
             kwargs["max_length"] = self.max_length

{plain_postgres-0.115.0 → plain_postgres-0.117.0}/plain/postgres/fields/encrypted.py

@@ -14,7 +14,7 @@ except ImportError:
     InvalidToken = None  # ty: ignore[invalid-assignment]
     MultiFernet = None  # ty: ignore[invalid-assignment]
     hashes = None  # ty: ignore[invalid-assignment]
-    PBKDF2HMAC = None  # ty: ignore[invalid-assignment]
+    PBKDF2HMAC = None
 
 from plain.postgres.lookups import Exact, IsNull
 from plain.runtime import settings