Add support for inheritance in m2m

Author: legau

AUTHORS.rst

@@ -80,6 +80,7 @@ Authors
 - Klaas van Schelven
 - Kris Neuharth
 - Kyle Seever (`kseever <https://github.com/kseever>`_)
+- Léni Gauffier (`legau <https://github.com/legau>`_)
 - Leticia Portella
 - Lucas Wiman
 - Maciej "RooTer" Urbański

docs/historical_model.rst

@@ -461,11 +461,15 @@ If you want to track many to many relationships, you need to define them explici
     class Poll(models.Model):
         question = models.CharField(max_length=200)
         categories = models.ManyToManyField(Category)
-        history = HistoricalRecords(many_to_many=[categories])
+        history = HistoricalRecords(m2m_fields=[categories])
 
 This will create a historical intermediate model that tracks each relational change
 between `Poll` and `Category`.
 
+You may also define these fields in a model attribute (by default on `_history_m2m_fields`).
+This is mainly used for inherited models. You can override the attribute name by setting
+your own `m2m_fields_model_field_name` argument on the `HistoricalRecord` instance.
+
 You will see the many to many changes when diffing between two historical records:
 
 .. code-block:: python

simple_history/models.py

@@ -94,6 +94,7 @@ def __init__(
         no_db_index=list(),
         excluded_field_kwargs=None,
         m2m_fields=(),
+        m2m_fields_model_field_name="_history_m2m_fields",
     ):
         self.user_set_verbose_name = verbose_name
         self.user_set_verbose_name_plural = verbose_name_plural
@@ -114,6 +115,7 @@ def __init__(
         self.related_name = related_name
         self.use_base_model_db = use_base_model_db
         self.m2m_fields = m2m_fields
+        self.m2m_fields_model_field_name = m2m_fields_model_field_name
 
         if isinstance(no_db_index, str):
             no_db_index = [no_db_index]
@@ -189,7 +191,10 @@ def finalize(self, sender, **kwargs):
         # so the signal handlers can't use weak references.
         models.signals.post_save.connect(self.post_save, sender=sender, weak=False)
         models.signals.post_delete.connect(self.post_delete, sender=sender, weak=False)
-        for field in self.m2m_fields:
+
+        m2m_fields = self.get_m2m_fields_from_model(sender)
+
+        for field in m2m_fields:
             m2m_changed.connect(
                 partial(self.m2m_changed, attr=field.name),
                 sender=field.remote_field.through,
@@ -200,13 +205,12 @@ def finalize(self, sender, **kwargs):
         setattr(sender, self.manager_name, descriptor)
         sender._meta.simple_history_manager_attribute = self.manager_name
 
-        for field in self.m2m_fields:
+        for field in m2m_fields:
             m2m_model = self.create_history_m2m_model(
                 history_model, field.remote_field.through
             )
             self.m2m_models[field] = m2m_model
 
-            module = importlib.import_module(self.module)
             setattr(module, m2m_model.__name__, m2m_model)
 
             m2m_descriptor = HistoryDescriptor(m2m_model)
@@ -236,23 +240,12 @@ def get_history_model_name(self, model):
 
     def create_history_m2m_model(self, model, through_model):
         attrs = {
-            "__module__": self.module,
+            "__module__": model.__module__,
             "__str__": lambda self: "{} as of {}".format(
                 self._meta.verbose_name, self.history.history_date
             ),
         }
 
-        app_module = "%s.models" % model._meta.app_label
-
-        if model.__module__ != self.module:
-            # registered under different app
-            attrs["__module__"] = self.module
-        elif app_module != self.module:
-            # Abuse an internal API because the app registry is loading.
-            app = apps.app_configs[model._meta.app_label]
-            models_module = app.name
-            attrs["__module__"] = models_module
-
         # Get the primary key to the history model this model will look up to
         attrs["m2m_history_id"] = self._get_history_id_field()
         attrs["history"] = models.ForeignKey(
@@ -285,7 +278,7 @@ def create_history_model(self, model, inherited):
         attrs = {
             "__module__": self.module,
             "_history_excluded_fields": self.excluded_fields,
-            "_history_m2m_fields": self.m2m_fields,
+            "_history_m2m_fields": self.get_m2m_fields_from_model(model),
         }
 
         app_module = "%s.models" % model._meta.app_label
@@ -637,7 +630,7 @@ def m2m_changed(self, instance, action, attr, pk_set, reverse, **_):
             self.create_historical_record(instance, "~")
 
     def create_historical_record_m2ms(self, history_instance, instance):
-        for field in self.m2m_fields:
+        for field in history_instance._history_m2m_fields:
             m2m_history_model = self.m2m_models[field]
             original_instance = history_instance.instance
             through_model = getattr(original_instance, field.name).through
@@ -721,6 +714,14 @@ def get_history_user(self, instance):
 
         return self.get_user(instance=instance, request=request)
 
+    def get_m2m_fields_from_model(self, model):
+        m2m_fields = set(self.m2m_fields)
+        try:
+            m2m_fields.update(getattr(model, self.m2m_fields_model_field_name))
+        except AttributeError:
+            pass
+        return [getattr(model, field.name).field for field in m2m_fields]
+
 
 def transform_field(field):
     """Customize field appropriately for use in historical model"""

simple_history/tests/models.py

@@ -127,6 +127,32 @@ class PollWithSeveralManyToMany(models.Model):
     history = HistoricalRecords(m2m_fields=[places, restaurants, books])
 
 
+class PollParentWithManyToMany(models.Model):
+    question = models.CharField(max_length=200)
+    pub_date = models.DateTimeField("date published")
+    places = models.ManyToManyField("Place")
+
+    history = HistoricalRecords(
+        m2m_fields=[places],
+        inherit=True,
+    )
+
+    class Meta:
+        abstract = True
+
+
+class PollChildBookWithManyToMany(PollParentWithManyToMany):
+    books = models.ManyToManyField("Book", related_name="books_poll_child")
+    _history_m2m_fields = [books]
+
+
+class PollChildRestaurantWithManyToMany(PollParentWithManyToMany):
+    restaurants = models.ManyToManyField(
+        "Restaurant", related_name="restaurants_poll_child"
+    )
+    _history_m2m_fields = [restaurants]
+
+
 class CustomAttrNameForeignKey(models.ForeignKey):
     def __init__(self, *args, **kwargs):
         self.attr_name = kwargs.pop("attr_name", None)

simple_history/tests/tests/test_models.py

@@ -87,6 +87,8 @@
     Person,
     Place,
     Poll,
+    PollChildBookWithManyToMany,
+    PollChildRestaurantWithManyToMany,
     PollInfo,
     PollWithExcludedFieldsWithDefaults,
     PollWithExcludedFKField,
@@ -1736,6 +1738,58 @@ def test_separation(self):
         self.assertEqual(add.places.all().count(), 0)
 
 
+class InheritedManyToManyTest(TestCase):
+    def setUp(self):
+        self.model_book = PollChildBookWithManyToMany
+        self.model_rstr = PollChildRestaurantWithManyToMany
+        self.place = Place.objects.create(name="Home")
+        self.book = Book.objects.create(isbn="1234")
+        self.restaurant = Restaurant.objects.create(rating=1)
+        self.poll_book = self.model_book.objects.create(
+            question="what's up?", pub_date=today
+        )
+        self.poll_rstr = self.model_rstr.objects.create(
+            question="what's up?", pub_date=today
+        )
+
+    def test_separation(self):
+        self.assertEqual(self.poll_book.history.all().count(), 1)
+        self.poll_book.places.add(self.place)
+        self.poll_book.books.add(self.book)
+        self.assertEqual(self.poll_book.history.all().count(), 3)
+
+        self.assertEqual(self.poll_rstr.history.all().count(), 1)
+        self.poll_rstr.places.add(self.place)
+        self.poll_rstr.restaurants.add(self.restaurant)
+        self.assertEqual(self.poll_rstr.history.all().count(), 3)
+
+        book, place, add = self.poll_book.history.all()
+
+        self.assertEqual(book.books.all().count(), 1)
+        self.assertEqual(book.places.all().count(), 1)
+        self.assertEqual(book.books.first().book, self.book)
+
+        self.assertEqual(place.books.all().count(), 0)
+        self.assertEqual(place.places.all().count(), 1)
+        self.assertEqual(place.places.first().place, self.place)
+
+        self.assertEqual(add.books.all().count(), 0)
+        self.assertEqual(add.places.all().count(), 0)
+
+        restaurant, place, add = self.poll_rstr.history.all()
+
+        self.assertEqual(restaurant.restaurants.all().count(), 1)
+        self.assertEqual(restaurant.places.all().count(), 1)
+        self.assertEqual(restaurant.restaurants.first().restaurant, self.restaurant)
+
+        self.assertEqual(place.restaurants.all().count(), 0)
+        self.assertEqual(place.places.all().count(), 1)
+        self.assertEqual(place.places.first().place, self.place)
+
+        self.assertEqual(add.restaurants.all().count(), 0)
+        self.assertEqual(add.places.all().count(), 0)
+
+
 class ManyToManyTest(TestCase):
     def setUp(self):
         self.model = PollWithManyToMany