plain.models 0.38.0__tar.gz → 0.39.0__tar.gz

{plain_models-0.38.0 → plain_models-0.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.models
-Version: 0.38.0
+Version: 0.39.0
 Summary: Database models for Plain.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE
@@ -30,6 +30,9 @@ class User(models.Model):
         return self.email
 ```
 
+Every model automatically includes an `id` field which serves as the primary
+key. The name `id` is reserved and can't be used for other fields.
+
 Create, update, and delete instances of your models:
 
 ```python

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/CHANGELOG.md

@@ -1,5 +1,24 @@
 # plain-models changelog
 
+## [0.39.0](https://github.com/dropseed/plain/releases/plain-models@0.39.0) (2025-07-22)
+
+### What's changed
+
+- Models now use a single automatic `id` field as the primary key, replacing the previous `pk` alias and automatic field system ([4b8fa6a](https://github.com/dropseed/plain/commit/4b8fa6a))
+- Removed the `to_field` option for ForeignKey - foreign keys now always reference the primary key of the related model ([7fc3c88](https://github.com/dropseed/plain/commit/7fc3c88))
+- Removed the internal `from_fields` and `to_fields` system used for multi-column foreign keys ([0e9eda3](https://github.com/dropseed/plain/commit/0e9eda3))
+- Removed the `parent_link` parameter on ForeignKey and ForeignObject ([6658647](https://github.com/dropseed/plain/commit/6658647))
+- Removed `InlineForeignKeyField` from forms ([ede6265](https://github.com/dropseed/plain/commit/ede6265))
+- Merged ForeignObject functionality into ForeignKey, simplifying the foreign key implementation ([e6d9aaa](https://github.com/dropseed/plain/commit/e6d9aaa))
+- Cleaned up unused code in ForeignKey and fixed ForeignObjectRel imports ([b656ee6](https://github.com/dropseed/plain/commit/b656ee6))
+
+### Upgrade instructions
+
+- Replace any direct references to `pk` with `id` in your models and queries (e.g., `user.pk` becomes `user.id`)
+- Remove any `to_field` arguments from ForeignKey definitions - they are no longer supported
+- Remove any `parent_link=True` arguments from ForeignKey definitions - they are no longer supported
+- Replace any usage of `InlineForeignKeyField` in forms with standard form fields
+
 ## [0.38.0](https://github.com/dropseed/plain/releases/plain-models@0.38.0) (2025-07-21)
 
 ### What's changed

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/README.md

@@ -19,6 +19,9 @@ class User(models.Model):
         return self.email
 ```
 
+Every model automatically includes an `id` field which serves as the primary
+key. The name `id` is reserved and can't be used for other fields.
+
 Create, update, and delete instances of your models:
 
 ```python

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/__init__.py

@@ -68,8 +68,9 @@ from .registry import models_registry, register_model
 from .base import DEFERRED, Model  # isort:skip
 from .fields.related import (  # isort:skip
     ForeignKey,
-    ForeignObject,
     ManyToManyField,
+)
+from .fields.reverse_related import (  # isort:skip
     ForeignObjectRel,
     ManyToOneRel,
     ManyToManyRel,
@@ -116,7 +117,6 @@ __all__ += [
     "Model",
     "FilteredRelation",
     "ForeignKey",
-    "ForeignObject",
     "ManyToManyField",
     "ForeignObjectRel",
     "ManyToOneRel",

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/base/creation.py

@@ -96,7 +96,7 @@ class BaseDatabaseCreation:
     #                     ) and router.allow_migrate_model(self.connection.alias, model):
     #                         queryset = model._base_manager.using(
     #                             self.connection.alias,
-    #                         ).order_by(model._meta.pk.name)
+    #                         ).order_by("id")
     #                         yield from queryset.iterator()
 
     #     # Serialize to a string

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/base/operations.py

@@ -28,9 +28,7 @@ class BaseDatabaseOperations:
         "PositiveBigIntegerField": (0, 9223372036854775807),
         "PositiveSmallIntegerField": (0, 32767),
         "PositiveIntegerField": (0, 2147483647),
-        "SmallAutoField": (-32768, 32767),
-        "AutoField": (-2147483648, 2147483647),
-        "BigAutoField": (-9223372036854775808, 9223372036854775807),
+        "PrimaryKeyField": (-9223372036854775808, 9223372036854775807),
     }
     set_operators = {
         "union": "UNION",

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/base/schema.py

@@ -29,11 +29,11 @@ def _is_relevant_relation(relation, altered_field):
     if field.many_to_many:
         # M2M reverse field
         return False
-    if altered_field.primary_key and field.to_fields == [None]:
+    if altered_field.primary_key:
         # Foreign key constraint on the primary key, which is being altered.
         return True
-    # Is the constraint targeting the field being altered?
-    return altered_field.name in field.to_fields
+    # ForeignKey always targets 'id'
+    return altered_field.name == "id"
 
 
 def _all_related_fields(model):
@@ -239,11 +239,7 @@ class BaseDatabaseSchemaEditor:
             column_sqls.append(f"{self.quote_name(field.column)} {definition}")
             # Autoincrement SQL (for backends with post table definition
             # variant).
-            if field.get_internal_type() in (
-                "AutoField",
-                "BigAutoField",
-                "SmallAutoField",
-            ):
+            if field.get_internal_type() in ("PrimaryKeyField",):
                 autoinc_sql = self.connection.ops.autoinc_sql(
                     model._meta.db_table, field.column
                 )

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/mysql/base.py

@@ -91,8 +91,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     # be interpolated against the values of Field.__dict__ before being output.
     # If a column type is set to None, it won't be included in the output.
     data_types = {
-        "AutoField": "integer AUTO_INCREMENT",
-        "BigAutoField": "bigint AUTO_INCREMENT",
+        "PrimaryKeyField": "bigint AUTO_INCREMENT",
         "BinaryField": "longblob",
         "BooleanField": "bool",
         "CharField": "varchar(%(max_length)s)",
@@ -109,7 +108,6 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "PositiveBigIntegerField": "bigint UNSIGNED",
         "PositiveIntegerField": "integer UNSIGNED",
         "PositiveSmallIntegerField": "smallint UNSIGNED",
-        "SmallAutoField": "smallint AUTO_INCREMENT",
         "SmallIntegerField": "smallint",
         "TextField": "longtext",
         "TimeField": "time(6)",

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/mysql/introspection.py

@@ -49,12 +49,8 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
     def get_field_type(self, data_type, description):
         field_type = super().get_field_type(data_type, description)
         if "auto_increment" in description.extra:
-            if field_type == "IntegerField":
-                return "AutoField"
-            elif field_type == "BigIntegerField":
-                return "BigAutoField"
-            elif field_type == "SmallIntegerField":
-                return "SmallAutoField"
+            if field_type == "BigIntegerField":
+                return "PrimaryKeyField"
         if description.is_unsigned:
             if field_type == "BigIntegerField":
                 return "PositiveBigIntegerField"

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/mysql/operations.py

@@ -21,9 +21,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         "PositiveBigIntegerField": (0, 18446744073709551615),
     }
     cast_data_types = {
-        "AutoField": "signed integer",
-        "BigAutoField": "signed integer",
-        "SmallAutoField": "signed integer",
+        "PrimaryKeyField": "signed integer",
         "CharField": "char(%(max_length)s)",
         "DecimalField": "decimal(%(max_digits)s, %(decimal_places)s)",
         "TextField": "char",
@@ -201,7 +199,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         # NO_AUTO_VALUE_ON_ZERO SQL mode.
         if value == 0 and not self.connection.features.allows_auto_pk_0:
             raise ValueError(
-                "The database backend does not accept 0 as a value for AutoField."
+                "The database backend does not accept 0 as a value for PrimaryKeyField."
             )
         return value
 

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/postgresql/base.py

@@ -89,8 +89,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     # be interpolated against the values of Field.__dict__ before being output.
     # If a column type is set to None, it won't be included in the output.
     data_types = {
-        "AutoField": "integer",
-        "BigAutoField": "bigint",
+        "PrimaryKeyField": "bigint",
         "BinaryField": "bytea",
         "BooleanField": "boolean",
         "CharField": _get_varchar_column,
@@ -107,7 +106,6 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "PositiveBigIntegerField": "bigint",
         "PositiveIntegerField": "integer",
         "PositiveSmallIntegerField": "smallint",
-        "SmallAutoField": "smallint",
         "SmallIntegerField": "smallint",
         "TextField": "text",
         "TimeField": "time",
@@ -119,9 +117,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "PositiveSmallIntegerField": '"%(column)s" >= 0',
     }
     data_types_suffix = {
-        "AutoField": "GENERATED BY DEFAULT AS IDENTITY",
-        "BigAutoField": "GENERATED BY DEFAULT AS IDENTITY",
-        "SmallAutoField": "GENERATED BY DEFAULT AS IDENTITY",
+        "PrimaryKeyField": "GENERATED BY DEFAULT AS IDENTITY",
     }
     operators = {
         "exact": "= %s",

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/postgresql/introspection.py

@@ -44,12 +44,8 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             # Required for pre-Plain 4.1 serial columns.
             description.default and "nextval" in description.default
         ):
-            if field_type == "IntegerField":
-                return "AutoField"
-            elif field_type == "BigIntegerField":
-                return "BigAutoField"
-            elif field_type == "SmallIntegerField":
-                return "SmallAutoField"
+            if field_type == "BigIntegerField":
+                return "PrimaryKeyField"
         return field_type
 
     def get_table_list(self, cursor):

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/postgresql/operations.py

@@ -35,9 +35,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         ]
     )
     cast_data_types = {
-        "AutoField": "integer",
-        "BigAutoField": "bigint",
-        "SmallAutoField": "smallint",
+        "PrimaryKeyField": "bigint",
     }
 
     integerfield_type_map = {

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/postgresql/schema.py

@@ -166,11 +166,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         old_internal_type = old_field.get_internal_type()
         # Make ALTER TYPE with IDENTITY make sense.
         table = strip_quotes(model._meta.db_table)
-        auto_field_types = {
-            "AutoField",
-            "BigAutoField",
-            "SmallAutoField",
-        }
+        auto_field_types = {"PrimaryKeyField"}
         old_is_auto = old_internal_type in auto_field_types
         new_is_auto = new_internal_type in auto_field_types
         if new_is_auto and not old_is_auto:
@@ -229,11 +225,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                 model, old_field, new_field, new_type, old_collation, new_collation
             )
             column = strip_quotes(new_field.column)
-            db_types = {
-                "AutoField": "integer",
-                "BigAutoField": "bigint",
-                "SmallAutoField": "smallint",
-            }
+            db_types = {"PrimaryKeyField": "bigint"}
             # Alter the sequence type if exists (Plain 4.1+ identity columns
             # don't have it).
             other_actions = []

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/sqlite3/base.py

@@ -57,8 +57,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     # thing" given more verbose field definitions, so leave them as is so that
     # schema inspection is more useful.
     data_types = {
-        "AutoField": "integer",
-        "BigAutoField": "integer",
+        "PrimaryKeyField": "integer",
         "BinaryField": "BLOB",
         "BooleanField": "bool",
         "CharField": "varchar(%(max_length)s)",
@@ -75,7 +74,6 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "PositiveBigIntegerField": "bigint unsigned",
         "PositiveIntegerField": "integer unsigned",
         "PositiveSmallIntegerField": "smallint unsigned",
-        "SmallAutoField": "integer",
         "SmallIntegerField": "smallint",
         "TextField": "text",
         "TimeField": "time",
@@ -88,9 +86,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "PositiveSmallIntegerField": '"%(column)s" >= 0',
     }
     data_types_suffix = {
-        "AutoField": "AUTOINCREMENT",
-        "BigAutoField": "AUTOINCREMENT",
-        "SmallAutoField": "AUTOINCREMENT",
+        "PrimaryKeyField": "AUTOINCREMENT",
     }
     # SQLite requires LIKE statements to include an ESCAPE clause if the value
     # being escaped has a percent or underscore in it.

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/backends/sqlite3/introspection.py

@@ -63,14 +63,8 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
 
     def get_field_type(self, data_type, description):
         field_type = super().get_field_type(data_type, description)
-        if description.pk and field_type in {
-            "BigIntegerField",
-            "IntegerField",
-            "SmallIntegerField",
-        }:
-            # No support for BigAutoField or SmallAutoField as SQLite treats
-            # all integer primary keys as signed 64-bit integers.
-            return "AutoField"
+        if description.pk and field_type == "BigIntegerField":
+            return "PrimaryKeyField"
         if description.has_json_constraint:
             return "JSONField"
         return field_type

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/base.py

@@ -23,9 +23,7 @@ from plain.models.db import (
 from plain.models.deletion import Collector
 from plain.models.expressions import RawSQL, Value
 from plain.models.fields import NOT_PROVIDED
-from plain.models.fields.related import (
-    ForeignObjectRel,
-)
+from plain.models.fields.reverse_related import ForeignObjectRel
 from plain.models.manager import Manager
 from plain.models.options import Options
 from plain.models.query import F, Q
@@ -334,22 +332,22 @@ class Model(metaclass=ModelBase):
         return f"<{self.__class__.__name__}: {self}>"
 
     def __str__(self):
-        return f"{self.__class__.__name__} object ({self.pk})"
+        return f"{self.__class__.__name__} object ({self.id})"
 
     def __eq__(self, other):
         if not isinstance(other, Model):
             return NotImplemented
         if self._meta.concrete_model != other._meta.concrete_model:
             return False
-        my_pk = self.pk
-        if my_pk is None:
+        my_id = self.id
+        if my_id is None:
             return self is other
-        return my_pk == other.pk
+        return my_id == other.id
 
     def __hash__(self):
-        if self.pk is None:
+        if self.id is None:
             raise TypeError("Model instances without primary key value are unhashable")
-        return hash(self.pk)
+        return hash(self.id)
 
     def __reduce__(self):
         data = self.__getstate__()
@@ -395,15 +393,6 @@ class Model(metaclass=ModelBase):
                 state[attr] = memoryview(value)
         self.__dict__.update(state)
 
-    def _get_pk_val(self, meta=None):
-        meta = meta or self._meta
-        return getattr(self, meta.pk.attname)
-
-    def _set_pk_val(self, value):
-        return setattr(self, self._meta.pk.attname, value)
-
-    pk = property(_get_pk_val, _set_pk_val)
-
     def get_deferred_fields(self):
         """
         Return a set containing names of deferred fields for this instance.
@@ -445,7 +434,7 @@ class Model(metaclass=ModelBase):
                     "are not allowed in fields."
                 )
 
-        db_instance_qs = self.__class__._base_manager.get_queryset().filter(pk=self.pk)
+        db_instance_qs = self.__class__._base_manager.get_queryset().filter(id=self.id)
 
         # Use provided fields, if not set then reload all non-deferred fields.
         deferred_fields = self.get_deferred_fields()
@@ -608,12 +597,13 @@ class Model(metaclass=ModelBase):
                 if f.name in update_fields or f.attname in update_fields
             ]
 
-        pk_val = self._get_pk_val(meta)
-        if pk_val is None:
-            pk_val = meta.pk.get_pk_value_on_save(self)
-            setattr(self, meta.pk.attname, pk_val)
-        pk_set = pk_val is not None
-        if not pk_set and (force_update or update_fields):
+        id_val = self.id
+        if id_val is None:
+            id_field = meta.get_field("id")
+            id_val = id_field.get_id_value_on_save(self)
+            setattr(self, id_field.attname, id_val)
+        id_set = id_val is not None
+        if not id_set and (force_update or update_fields):
             raise ValueError("Cannot force an update in save() with no primary key.")
         updated = False
         # Skip an UPDATE when adding an instance and primary key has a default.
@@ -621,12 +611,12 @@ class Model(metaclass=ModelBase):
             not raw
             and not force_insert
             and self._state.adding
-            and meta.pk.default
-            and meta.pk.default is not NOT_PROVIDED
+            and meta.get_field("id").default
+            and meta.get_field("id").default is not NOT_PROVIDED
         ):
             force_insert = True
         # If possible, try an UPDATE. If that doesn't update anything, do an INSERT.
-        if pk_set and not force_insert:
+        if id_set and not force_insert:
             base_qs = cls._base_manager
             values = [
                 (
@@ -638,7 +628,7 @@ class Model(metaclass=ModelBase):
             ]
             forced_update = update_fields or force_update
             updated = self._do_update(
-                base_qs, pk_val, values, update_fields, forced_update
+                base_qs, id_val, values, update_fields, forced_update
             )
             if force_update and not updated:
                 raise DatabaseError("Forced update did not affect any rows.")
@@ -646,8 +636,9 @@ class Model(metaclass=ModelBase):
                 raise DatabaseError("Save with update_fields did not affect any rows.")
         if not updated:
             fields = meta.local_concrete_fields
-            if not pk_set:
-                fields = [f for f in fields if f is not meta.auto_field]
+            if not id_set:
+                id_field = meta.get_field("id")
+                fields = [f for f in fields if f is not id_field]
 
             returning_fields = meta.db_returning_fields
             results = self._do_insert(cls._base_manager, fields, returning_fields, raw)
@@ -656,12 +647,12 @@ class Model(metaclass=ModelBase):
                     setattr(self, field.attname, value)
         return updated
 
-    def _do_update(self, base_qs, pk_val, values, update_fields, forced_update):
+    def _do_update(self, base_qs, id_val, values, update_fields, forced_update):
         """
         Try to update the model. Return True if the model was updated (if an
         update query was done and a matching row was found in the DB).
         """
-        filtered = base_qs.filter(pk=pk_val)
+        filtered = base_qs.filter(id=id_val)
         if not values:
             # We can end up here when saving a model in inheritance chain where
             # update_fields doesn't target any field in current model. In that
@@ -701,7 +692,7 @@ class Model(metaclass=ModelBase):
                 # database to raise an IntegrityError if applicable. If
                 # constraints aren't supported by the database, there's the
                 # unavoidable risk of data corruption.
-                if obj.pk is None:
+                if obj.id is None:
                     # Remove the object from a related instance cache.
                     if not field.remote_field.multiple:
                         field.remote_field.delete_cached_value(obj)
@@ -721,9 +712,9 @@ class Model(metaclass=ModelBase):
                     field.delete_cached_value(self)
 
     def delete(self):
-        if self.pk is None:
+        if self.id is None:
             raise ValueError(
-                f"{self._meta.object_name} object can't be deleted because its {self._meta.pk.attname} attribute is set "
+                f"{self._meta.object_name} object can't be deleted because its id attribute is set "
                 "to None."
             )
         collector = Collector(origin=self)
@@ -739,17 +730,17 @@ class Model(metaclass=ModelBase):
         )
 
     def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
-        if not self.pk:
+        if not self.id:
             raise ValueError("get_next/get_previous cannot be used on unsaved objects.")
         op = "gt" if is_next else "lt"
         order = "" if is_next else "-"
         param = getattr(self, field.attname)
-        q = Q.create([(field.name, param), (f"pk__{op}", self.pk)], connector=Q.AND)
+        q = Q.create([(field.name, param), (f"id__{op}", self.id)], connector=Q.AND)
         q = Q.create([q, (f"{field.name}__{op}", param)], connector=Q.OR)
         qs = (
             self.__class__._default_manager.filter(**kwargs)
             .filter(q)
-            .order_by(f"{order}{field.name}", f"{order}pk")
+            .order_by(f"{order}{field.name}", f"{order}id")
         )
         try:
             return qs[0]
@@ -769,7 +760,7 @@ class Model(metaclass=ModelBase):
         }
 
     def prepare_database_save(self, field):
-        if self.pk is None:
+        if self.id is None:
             raise ValueError(
                 f"Unsaved model instance {self!r} cannot be used in an ORM query."
             )
@@ -849,13 +840,11 @@ class Model(metaclass=ModelBase):
 
             # Exclude the current object from the query if we are editing an
             # instance (as opposed to creating a new one)
-            # Note that we need to use the pk as defined by model_class, not
-            # self.pk. These can be different fields because model inheritance
-            # allows single model to have effectively multiple primary keys.
-            # Refs #17615.
-            model_class_pk = self._get_pk_val(model_class._meta)
-            if not self._state.adding and model_class_pk is not None:
-                qs = qs.exclude(pk=model_class_pk)
+            # Use the primary key defined by model_class. In previous versions
+            # this could differ from `self.id` due to model inheritance.
+            model_class_id = getattr(self, "id")
+            if not self._state.adding and model_class_id is not None:
+                qs = qs.exclude(id=model_class_id)
             if qs.exists():
                 if len(unique_check) == 1:
                     key = unique_check[0]
@@ -1111,22 +1100,18 @@ class Model(metaclass=ModelBase):
 
     @classmethod
     def _check_id_field(cls):
-        """Check if `id` field is a primary key."""
-        fields = [
-            f for f in cls._meta.local_fields if f.name == "id" and f != cls._meta.pk
-        ]
-        # fields is empty or consists of the invalid "id" field
-        if fields and not fields[0].primary_key and cls._meta.pk.name == "id":
+        """Disallow user-defined fields named ``id``."""
+        if any(
+            f for f in cls._meta.local_fields if f.name == "id" and not f.auto_created
+        ):
             return [
                 preflight.Error(
-                    "'id' can only be used as a field name if the field also "
-                    "sets 'primary_key=True'.",
+                    "'id' is a reserved word that cannot be used as a field name.",
                     obj=cls,
                     id="models.E004",
                 )
             ]
-        else:
-            return []
+        return []
 
     @classmethod
     def _check_field_name_clashes(cls):
@@ -1428,11 +1413,7 @@ class Model(metaclass=ModelBase):
             fld = None
             for part in field.split(LOOKUP_SEP):
                 try:
-                    # pk is an alias that won't be found by opts.get_field.
-                    if part == "pk":
-                        fld = _cls._meta.pk
-                    else:
-                        fld = _cls._meta.get_field(part)
+                    fld = _cls._meta.get_field(part)
                     if fld.is_relation:
                         _cls = fld.path_infos[-1].to_opts.model
                     else:
@@ -1450,10 +1431,6 @@ class Model(metaclass=ModelBase):
                             )
                         )
 
-        # Skip ordering on pk. This is always a valid order_by field
-        # but is an alias and therefore won't be found by opts.get_field.
-        fields = {f for f in fields if f != "pk"}
-
         # Check for invalid or nonexistent fields in ordering.
         invalid_fields = []
 
@@ -1469,7 +1446,7 @@ class Model(metaclass=ModelBase):
             )
         )
 
-        invalid_fields.extend(fields - valid_fields)
+        invalid_fields.extend(set(fields) - valid_fields)
 
         for invalid_field in invalid_fields:
             errors.append(
@@ -1712,17 +1689,12 @@ class Model(metaclass=ModelBase):
                             ),
                         )
         for field_name, *lookups in references:
-            # pk is an alias that won't be found by opts.get_field.
-            if field_name != "pk":
-                fields.add(field_name)
+            fields.add(field_name)
             if not lookups:
                 # If it has no lookups it cannot result in a JOIN.
                 continue
             try:
-                if field_name == "pk":
-                    field = cls._meta.pk
-                else:
-                    field = cls._meta.get_field(field_name)
+                field = cls._meta.get_field(field_name)
                 if not field.is_relation or field.many_to_many or field.one_to_many:
                     continue
             except FieldDoesNotExist:

{plain_models-0.38.0 → plain_models-0.39.0}/plain/models/constraints.py

@@ -384,9 +384,9 @@ class UniqueConstraint(BaseConstraint):
                     expr = expr.expression
                 expressions.append(Exact(expr, expr.replace_expressions(replacements)))
             queryset = queryset.filter(*expressions)
-        model_class_pk = instance._get_pk_val(model._meta)
-        if not instance._state.adding and model_class_pk is not None:
-            queryset = queryset.exclude(pk=model_class_pk)
+        model_class_id = instance.id
+        if not instance._state.adding and model_class_id is not None:
+            queryset = queryset.exclude(id=model_class_id)
         if not self.condition:
             if queryset.exists():
                 if self.expressions: