plain.postgres 0.115.0__tar.gz → 0.116.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: plain.postgres
-Version: 0.115.0
+Version: 0.116.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.116.0}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,25 @@
 # plain-postgres changelog
 
+## [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.116.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,10 +122,6 @@ 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:
@@ -193,16 +188,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 +272,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 +309,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,7 +391,7 @@ 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(
@@ -420,7 +407,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 +471,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 +481,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 +488,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 +511,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 +564,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 +596,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 +740,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,7 +753,7 @@ 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))
@@ -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
@@ -1089,9 +1063,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 +1095,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 +1109,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):
                 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._model_meta.fields:
                 rel_name = m2m.column
                 if rel_name is not None and len(rel_name) > allowed_len:
                     errors.append(
@@ -1235,7 +1209,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.116.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.116.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.116.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.116.0}/plain/postgres/fields/base.py

@@ -110,8 +110,9 @@ 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
@@ -134,7 +135,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 +152,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 +165,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 +215,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 +259,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 +304,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,
@@ -394,7 +392,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 +419,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 +428,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 +466,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 +474,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 +483,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 +535,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 +642,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 +739,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 +880,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.116.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.116.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

{plain_postgres-0.115.0 → plain_postgres-0.116.0}/plain/postgres/fields/json.py

@@ -54,7 +54,7 @@ class JSONField(DefaultableField):
             validators=validators,
         )
 
-    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.encoder is not None:
             kwargs["encoder"] = self.encoder

{plain_postgres-0.115.0 → plain_postgres-0.116.0}/plain/postgres/fields/network.py

@@ -63,7 +63,7 @@ class GenericIPAddressField[T: (str, str | None) = str](DefaultableField[T]):
             ]
         return []
 
-    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.unpack_ipv4 is not False:
             kwargs["unpack_ipv4"] = self.unpack_ipv4

{plain_postgres-0.115.0 → plain_postgres-0.116.0}/plain/postgres/fields/numeric.py

@@ -238,7 +238,7 @@ class DecimalField[T: (decimal.Decimal, decimal.Decimal | None) = decimal.Decima
     def context(self) -> decimal.Context:
         return decimal.Context(prec=self.max_digits)
 
-    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_digits is not None:
             kwargs["max_digits"] = self.max_digits

{plain_postgres-0.115.0 → plain_postgres-0.116.0}/plain/postgres/fields/primary_key.py

@@ -41,7 +41,7 @@ class PrimaryKeyField(ColumnField[int]):
         # for every other field type.
         return [e for e in errors if e.id != "fields.reserved_field_name_id"]
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
+    def deconstruct(self) -> tuple[str, str, list[Any], dict[str, Any]]:
         return (
             self.name,
             "plain.postgres.PrimaryKeyField",