Merge pull request #760 from bckohan/issue759

Fix migration state check false negative

Author: bckohan

docs/changelog.rst

@@ -1,9 +1,18 @@
 Changelog
 =========
 
+v4.5.1 (2025-12-24)
+-------------------
+
+* Fixed `4.5.0 generates a lot of migrations on my project <https://github.com/jazzband/django-polymorphic/pull/759>`_
+
 v4.5.0 (2025-12-22)
 -------------------
 
+.. warning::
+
+  This version has a bug that generates unnecessary migrations - use 4.5.1 instead!
+
 * Implemented `Deletion fixes <https://github.com/jazzband/django-polymorphic/pull/746>`_
   **This release fixes the longstanding polymorphic deletion bug.** The fix should be transparent
   and not generate new migrations files. If you experience any issues, please report them.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-polymorphic"
-version = "4.5.0"
+version = "4.5.1"
 description = "Seamless polymorphic inheritance for Django models."
 readme = "README.md"
 license = "BSD-3-Clause"

src/polymorphic/__init__.py

@@ -19,7 +19,7 @@
 Seamless Polymorphic Inheritance for Django Models
 """
 
-VERSION = "4.5.0"
+VERSION = "4.5.1"
 
 __title__ = "Django Polymorphic"
 __version__ = VERSION  # version synonym for backwards compatibility

src/polymorphic/deletion.py

@@ -2,12 +2,35 @@
 Classes and utilities for handling deletions in polymorphic models.
 """
 
+from functools import cached_property
+
 from django.db.migrations.serializer import BaseSerializer, serializer_factory
 from django.db.migrations.writer import MigrationWriter
 
 from .query import PolymorphicQuerySet
 
 
+def migration_fingerprint(value):
+    """
+    Produce a stable, hashable fingerprint for a value as Django would represent
+    it in migrations, but in a structured form when possible.
+    """
+    # Canonical deconstruction path for SET(...), @deconstructible, etc.
+    deconstruct = getattr(value, "deconstruct", None)
+    if callable(deconstruct):
+        path, args, kwargs = value.deconstruct()
+        return (
+            path,
+            tuple(migration_fingerprint(a) for a in args),
+            tuple(sorted((k, migration_fingerprint(v)) for k, v in kwargs.items())),
+        )
+
+    # Fallback: canonical "code string" Django would emit in a migration.
+    # (Works for CASCADE/PROTECT/SET_NULL, primitives, etc.)
+    code, _imports = serializer_factory(value).serialize()
+    return code
+
+
 class PolymorphicGuard:
     """
     Wrap an :attr:`django.db.models.ForeignKey.on_delete` callable
@@ -43,6 +66,36 @@ class MyModel(PolymorphicModel):
             sub_objs = sub_objs.non_polymorphic()
         return self.action(collector, field, sub_objs, using)
 
+    @cached_property
+    def migration_key(self):
+        return migration_fingerprint(self.action)
+
+    def __eq__(self, other):
+        if (
+            isinstance(other, tuple)
+            and len(other) == 3
+            and callable(getattr(self.action, "deconstruct", None))
+        ):
+            # In some cases the autodetector compares us to a reconstructed,
+            # deconstruct() tuple. This has been seen for SET(...) callables.
+            # The arguments element may be a list instead of a tuple though, this
+            # handles that special case
+            return self.action.deconstruct() == (
+                other[0],
+                tuple(other[1]) if isinstance(other[1], list) else other[1],
+                other[2],
+            )
+        if isinstance(other, PolymorphicGuard):
+            return self.migration_key == other.migration_key
+        else:
+            try:
+                return self.migration_key == migration_fingerprint(other)
+            except Exception:
+                return False
+
+    def __hash__(self):
+        return hash(self.migration_key)
+
 
 class PolymorphicGuardSerializer(BaseSerializer):
     """

src/polymorphic/tests/test_migrations/test_on_delete.py

@@ -6,7 +6,7 @@
 with PolymorphicGuard and serialize correctly in migrations.
 """
 
-import shutil
+from django.core.management import call_command
 from pathlib import Path
 from django.test import TestCase, TransactionTestCase
 from django.db import models
@@ -582,3 +582,33 @@ def test_one_to_one_set_null_sets_to_null(self):
         # Verify the object still exists but the field is now null
         one_to_one_obj = ModelWithOneToOneSetNull.objects.get(id=one_to_one_obj_id)
         self.assertIsNone(one_to_one_obj.related)
+
+
+class TestMigrationStateStability(TestCase):
+    """
+    Test that unchanged models do not generate new migrations.
+    """
+
+    def test_migration_state_stability(self):
+        call_command("makemigrations")
+
+        migrations_dirs = [
+            Path(__file__).parent.parent / "deletion" / "migrations",
+            Path(__file__).parent.parent / "test_migrations" / "migrations",
+            Path(__file__).parent.parent / "migrations",
+        ]
+
+        migrations = set()
+
+        for migrations_dir in migrations_dirs:
+            migrations.update(migrations_dir.glob("00*.py"))
+
+        call_command("makemigrations")
+        call_command("makemigrations")
+
+        migrations_post = set()
+
+        for migrations_dir in migrations_dirs:
+            migrations_post.update(migrations_dir.glob("00*.py"))
+
+        self.assertEqual(migrations, migrations_post)