Merge pull request #858 from bckohan/manager_caching

Fix default PolymorphicManager for base_manager being overridden by apps registry cache clear.

Author: bckohan

docs/changelog/index.rst

@@ -1,6 +1,13 @@
 Changelog
 =========
 
+v4.9.2, v4.10.5 (2026-01-26)
+----------------------------
+
+* Fixed `Bad warning messages polymorphic.W001 and polymorphic.W002 when deriving from PolymorphicModel <https://github.com/jazzband/django-polymorphic/issues/857>`_
+* Fixed `Unexpected return type of polymorphic data since 4.9.1 <https://github.com/jazzband/django-polymorphic/issues/855>`_
+* Fixed `related item missing <https://github.com/jazzband/django-polymorphic/issues/851>`_
+
 v4.10.4 (2026-01-19)
 --------------------
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-polymorphic"
-version = "4.10.4"
+version = "4.10.5"
 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.10.4"
+VERSION = "4.10.5"
 
 __title__ = "Django Polymorphic"
 __version__ = VERSION  # version synonym for backwards compatibility

src/polymorphic/base.py

@@ -7,6 +7,7 @@
 
 from django.db import models
 from django.db.models.base import ModelBase
+from django.db.models.options import Options
 
 from .deletion import PolymorphicGuard
 from .managers import PolymorphicManager
@@ -29,8 +30,36 @@ class ManagerInheritanceWarning(RuntimeWarning):
 check_dump = hasattr(sys, "_getframe")
 
 
-###################################################################################
-# PolymorphicModel meta class
+# We wrap the base_manager property to return a PolymorphicManager
+# for polymorphic models when the base manager would otherwise
+# be the default auto-created manager. This ensures that
+# reverse relations to polymorphic models also use polymorphic
+# querysets by default.
+# https://github.com/jazzband/django-polymorphic/pull/858
+dj_base_manager = Options.base_manager.func
+
+
+def polymorphic_base_manager(self):
+    """
+    Return a polymorphic base manager for polymorphic models.
+    """
+    from polymorphic.models import PolymorphicModel
+
+    mgr = dj_base_manager(self)
+    if (
+        issubclass(self.model, PolymorphicModel)
+        and mgr.__class__ is models.Manager
+        and mgr.auto_created
+    ):
+        manager = PolymorphicManager()
+        manager.name = "_base_manager"
+        manager.model = self.model
+        manager.auto_created = True
+        return manager
+    return mgr
+
+
+Options.base_manager.func = polymorphic_base_manager
 
 
 class PolymorphicModelBase(ModelBase):
@@ -79,21 +108,6 @@ def __new__(cls, model_name, bases, attrs, **kwargs):
 
         new_class = super().__new__(cls, model_name, bases, attrs, **kwargs)
 
-        if not any(
-            parent._meta.base_manager_name
-            for parent in new_class.mro()
-            if issubclass(parent, PolymorphicModel)
-        ):
-            if new_class._meta.default_manager.__class__ is PolymorphicManager:
-                new_class._meta.__dict__["base_manager"] = new_class._meta.default_manager
-            else:
-                manager = PolymorphicManager()
-                manager.name = "_base_manager"
-                manager.model = new_class
-                manager.auto_created = True
-                # write new manager to property cache
-                new_class._meta.__dict__["base_manager"] = manager
-
         # wrap on_delete handlers of reverse relations back to this model with the
         # polymorphic deletion guard
         for fk in new_class._meta.fields:

src/polymorphic/tests/test_migration_managers.py

@@ -0,0 +1,91 @@
+from django.test import TestCase
+
+from django_test_migrations.contrib.unittest_case import MigratorTestCase
+from django_test_migrations.migrator import Migrator
+
+from polymorphic.managers import PolymorphicManager
+
+
+class TestRelatedManagersInMigrationState(MigratorTestCase):
+    """
+    Test that only non-polymorphic managers are used in migrations.
+    """
+
+    app = "tests"
+    migrate_from = (app, None)
+    migrate_to = (app, "0001_initial")
+
+    def test_migration_managers_are_nonpoly(self):
+        migrator = Migrator(database="default")
+
+        # Apply migrations up to the state you care about and get the historical apps registry.
+        state = migrator.apply_initial_migration(self.migrate_to)
+        apps = state.apps
+
+        ChildModelWithManager = apps.get_model("tests", "ChildModelWithManager")
+        ParentModelWithManager = apps.get_model("tests", "ParentModelWithManager")
+        pm = ParentModelWithManager.objects.create()
+        ChildModelWithManager.objects.create(field1="test", fk=pm)
+
+        assert not isinstance(ParentModelWithManager.objects, PolymorphicManager)
+        assert not isinstance(ChildModelWithManager.objects, PolymorphicManager)
+        assert not isinstance(ChildModelWithManager._meta.base_manager, PolymorphicManager)
+        assert not isinstance(ParentModelWithManager._meta.base_manager, PolymorphicManager)
+        assert not isinstance(pm.childmodel_set, PolymorphicManager)
+
+        One2OneRelatingModel = apps.get_model("tests", "One2OneRelatingModel")
+        One2OneRelatingModelDerived = apps.get_model("tests", "One2OneRelatingModelDerived")
+        Model2A = apps.get_model("tests", "Model2A")
+        Model2BFiltered = apps.get_model("tests", "Model2BFiltered")
+        Model2CFiltered = apps.get_model("tests", "Model2CFiltered")
+        Model2CNamedManagers = apps.get_model("tests", "Model2CNamedManagers")
+        Model2CNamedDefault = apps.get_model("tests", "Model2CNamedDefault")
+        ManagerTest = apps.get_model("tests", "ManagerTest")
+        ManagerTestChild = apps.get_model("tests", "ManagerTestChild")
+        RelatingModel = apps.get_model("tests", "RelatingModel")
+
+        assert not isinstance(Model2BFiltered._meta.base_manager, PolymorphicManager)
+        assert not isinstance(Model2CFiltered._meta.base_manager, PolymorphicManager)
+        assert not isinstance(Model2CNamedManagers._meta.base_manager, PolymorphicManager)
+        assert not isinstance(Model2CNamedDefault._meta.base_manager, PolymorphicManager)
+        assert not isinstance(Model2BFiltered._meta.default_manager, PolymorphicManager)
+        assert not isinstance(Model2CFiltered._meta.default_manager, PolymorphicManager)
+        assert not isinstance(Model2CNamedManagers._meta.default_manager, PolymorphicManager)
+        assert not isinstance(Model2CNamedDefault._meta.default_manager, PolymorphicManager)
+        assert not isinstance(Model2BFiltered.objects, PolymorphicManager)
+        assert not isinstance(Model2CFiltered.objects, PolymorphicManager)
+        assert not isinstance(Model2CNamedManagers.objects, PolymorphicManager)
+        assert not isinstance(Model2CNamedDefault.objects, PolymorphicManager)
+
+        assert not isinstance(ManagerTest._meta.base_manager, PolymorphicManager)
+        assert not isinstance(ManagerTest._meta.default_manager, PolymorphicManager)
+        assert not isinstance(ManagerTestChild._meta.base_manager, PolymorphicManager)
+        assert not isinstance(ManagerTestChild._meta.default_manager, PolymorphicManager)
+
+        b2 = Model2BFiltered.objects.create(field1="testB1", field2="testB2")
+        b2_2 = Model2BFiltered.objects.create(field1="testB12", field2="testB22")
+        o2o1 = One2OneRelatingModel.objects.create(field1="relating1", one2one=b2)
+        o2o2 = One2OneRelatingModelDerived.objects.create(
+            field1="relating2", field2="relating2", one2one=b2_2
+        )
+
+        o2o1.refresh_from_db()
+        o2o2.refresh_from_db()
+
+        assert o2o1.one2one.__class__ is Model2A
+        assert o2o2.one2one.__class__ is Model2A
+
+        a2 = Model2A.objects.create(field1="testA1")
+
+        rel = RelatingModel.objects.create()
+        assert not isinstance(rel.many2many, PolymorphicManager)
+        rel.many2many.add(b2)
+        rel.many2many.add(b2_2)
+        rel.many2many.add(a2)
+
+        rel.refresh_from_db()
+        assert set(rel.many2many.all()) == {
+            Model2A.objects.get(pk=b2.pk),
+            Model2A.objects.get(pk=b2_2.pk),
+            a2,
+        }

src/polymorphic/tests/test_orm.py

@@ -532,12 +532,6 @@ def base_manager(model):
             One2OneRelatingModelDerived,
         )
 
-        # unless the user provides a manager the default_manager and base_manager are
-        # the same
-        assert Model2A._default_manager is Model2A._base_manager
-        assert Model2B._default_manager is Model2B._base_manager
-        assert Model2C._default_manager is Model2C._base_manager
-
         assert type(Model2BFiltered._base_manager) is PolymorphicManager
         assert type(Model2CFiltered._base_manager) is PolymorphicManager
         assert type(Model2CNamedManagers._base_manager) is CustomBaseManager
@@ -2625,3 +2619,17 @@ def test_disparate_pk_values_in_hierarchy(self):
         )
 
         DisparateKeysGrandChild2.objects.all().delete()
+
+    def test_manager_cache_clear_persistence(self):
+        """
+        Test that clearing the model registry cache does not remove overriden
+        base managers.
+
+        https://github.com/jazzband/django-polymorphic/issues/857
+        """
+        from django.apps import apps
+
+        apps.clear_cache()
+
+        self.test_base_manager()
+        self.test_default_manager()