plain.models 0.41.1__py3-none-any.whl → 0.43.0__py3-none-any.whl

plain/models/fields/related_descriptors.py

@@ -48,20 +48,16 @@ reverse many-to-one relation.
 
 from functools import cached_property
 
-from plain.exceptions import FieldError
-from plain.models import transaction
-from plain.models.db import (
-    NotSupportedError,
-    db_connection,
-)
-from plain.models.expressions import Window
-from plain.models.functions import RowNumber
-from plain.models.lookups import GreaterThan, LessThanOrEqual
 from plain.models.query import QuerySet
-from plain.models.query_utils import DeferredAttribute, Q
-from plain.models.utils import resolve_callables
+from plain.models.query_utils import DeferredAttribute
 from plain.utils.functional import LazyObject
 
+from .related_managers import (
+    ForwardManyToManyManager,
+    ReverseManyToManyManager,
+    ReverseManyToOneManager,
+)
+
 
 class ForeignKeyDeferredAttribute(DeferredAttribute):
     def __set__(self, instance, value):
@@ -72,24 +68,6 @@ class ForeignKeyDeferredAttribute(DeferredAttribute):
         instance.__dict__[self.field.attname] = value
 
 
-def _filter_prefetch_queryset(queryset, field_name, instances):
-    predicate = Q(**{f"{field_name}__in": instances})
-    if queryset.query.is_sliced:
-        if not db_connection.features.supports_over_clause:
-            raise NotSupportedError(
-                "Prefetching from a limited queryset is only supported on backends "
-                "that support window functions."
-            )
-        low_mark, high_mark = queryset.query.low_mark, queryset.query.high_mark
-        order_by = [expr for expr, _ in queryset.query.get_compiler().get_order_by()]
-        window = Window(RowNumber(), partition_by=field_name, order_by=order_by)
-        predicate &= GreaterThan(window, low_mark)
-        if high_mark is not None:
-            predicate &= LessThanOrEqual(window, high_mark)
-        queryset.query.clear_limits()
-    return queryset.filter(predicate)
-
-
 class ForwardManyToOneDescriptor:
     """
     Accessor to the related object on the forward side of a many-to-one relation.
@@ -122,15 +100,13 @@ class ForwardManyToOneDescriptor:
     def is_cached(self, instance):
         return self.field.is_cached(instance)
 
-    def get_queryset(self, **hints):
-        qs = self.field.remote_field.model._base_manager.get_queryset()
-        qs._add_hints(**hints)
+    def get_queryset(self) -> QuerySet:
+        qs = self.field.remote_field.model._meta.base_queryset
         return qs.all()
 
     def get_prefetch_queryset(self, instances, queryset=None):
         if queryset is None:
             queryset = self.get_queryset()
-        queryset._add_hints(instance=instances[0])
 
         rel_obj_attr = self.field.get_foreign_related_value
         instance_attr = self.field.get_local_related_value
@@ -170,7 +146,7 @@ class ForwardManyToOneDescriptor:
         )
 
     def get_object(self, instance):
-        qs = self.get_queryset(instance=instance)
+        qs = self.get_queryset()
         # Assuming the database enforces foreign keys, this won't fail.
         return qs.get(self.field.get_reverse_related_filter(instance))
 
@@ -285,57 +261,43 @@ class ForwardManyToOneDescriptor:
         return getattr, (self.field.model, self.field.name)
 
 
-class ReverseManyToOneDescriptor:
+class RelationDescriptorBase:
     """
-    Accessor to the related objects manager on the reverse side of a
-    many-to-one relation.
-
-    In the example::
+    Base class for relation descriptors that don't allow direct assignment.
 
-        class Child(Model):
-            parent = ForeignKey(Parent, related_name='children')
-
-    ``Parent.children`` is a ``ReverseManyToOneDescriptor`` instance.
-
-    Most of the implementation is delegated to a dynamically defined manager
-    class built by ``create_forward_many_to_many_manager()`` defined below.
+    This is used for descriptors that manage collections of related objects
+    (reverse FK and M2M relations). Forward FK relations don't inherit from
+    this because they allow direct assignment.
     """
 
     def __init__(self, rel):
         self.rel = rel
         self.field = rel.field
 
-    @cached_property
-    def related_manager_cls(self):
-        related_model = self.rel.related_model
-
-        return create_reverse_many_to_one_manager(
-            related_model._default_manager.__class__,
-            self.rel,
-        )
-
     def __get__(self, instance, cls=None):
         """
-        Get the related objects through the reverse relation.
-
-        With the example above, when getting ``parent.children``:
+        Get the related manager when the descriptor is accessed.
 
-        - ``self`` is the descriptor managing the ``children`` attribute
-        - ``instance`` is the ``parent`` instance
-        - ``cls`` is the ``Parent`` class (unused)
+        Subclasses must implement get_related_manager().
         """
         if instance is None:
             return self
+        return self.get_related_manager(instance)
 
-        return self.related_manager_cls(instance)
+    def get_related_manager(self, instance):
+        """Return the appropriate manager for this relation."""
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must implement get_related_manager()"
+        )
 
     def _get_set_deprecation_msg_params(self):
-        return (
-            "reverse side of a related set",
-            self.rel.get_accessor_name(),
+        """Return parameters for the error message when direct assignment is attempted."""
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must implement _get_set_deprecation_msg_params()"
         )
 
     def __set__(self, instance, value):
+        """Prevent direct assignment to the relation."""
         raise TypeError(
             "Direct assignment to the {} is prohibited. Use {}.set() instead.".format(
                 *self._get_set_deprecation_msg_params()
@@ -343,252 +305,45 @@ class ReverseManyToOneDescriptor:
         )
 
 
-def create_reverse_many_to_one_manager(superclass, rel):
+class ReverseManyToOneDescriptor(RelationDescriptorBase):
     """
-    Create a manager for the reverse side of a many-to-one relation.
+    Accessor to the related objects manager on the reverse side of a
+    many-to-one relation.
+
+    In the example::
 
-    This manager subclasses another manager, generally the default manager of
-    the related model, and adds behaviors specific to many-to-one relations.
+        class Child(Model):
+            parent = ForeignKey(Parent, related_name='children')
+
+    ``Parent.children`` is a ``ReverseManyToOneDescriptor`` instance.
+
+    Most of the implementation is delegated to the ReverseManyToOneManager class.
     """
 
-    class RelatedManager(superclass):
-        def __init__(self, instance):
-            super().__init__()
-
-            self.instance = instance
-            self.model = rel.related_model
-            self.field = rel.field
-
-            self.core_filters = {self.field.name: instance}
-
-        def __call__(self, *, manager):
-            manager = getattr(self.model, manager)
-            manager_class = create_reverse_many_to_one_manager(manager.__class__, rel)
-            return manager_class(self.instance)
-
-        def _check_fk_val(self):
-            for field in self.field.foreign_related_fields:
-                if getattr(self.instance, field.attname) is None:
-                    raise ValueError(
-                        f'"{self.instance!r}" needs to have a value for field '
-                        f'"{field.attname}" before this relationship can be used.'
-                    )
-
-        def _apply_rel_filters(self, queryset):
-            """
-            Filter the queryset for the instance this manager is bound to.
-            """
-            queryset._add_hints(instance=self.instance)
-            queryset._defer_next_filter = True
-            queryset = queryset.filter(**self.core_filters)
-            for field in self.field.foreign_related_fields:
-                val = getattr(self.instance, field.attname)
-                if val is None:
-                    return queryset.none()
-            if self.field.many_to_one:
-                # Guard against field-like objects such as GenericRelation
-                # that abuse create_reverse_many_to_one_manager() with reverse
-                # one-to-many relationships instead and break known related
-                # objects assignment.
-                try:
-                    target_field = self.field.target_field
-                except FieldError:
-                    # The relationship has multiple target fields. Use a tuple
-                    # for related object id.
-                    rel_obj_id = tuple(
-                        [
-                            getattr(self.instance, target_field.attname)
-                            for target_field in self.field.path_infos[-1].target_fields
-                        ]
-                    )
-                else:
-                    rel_obj_id = getattr(self.instance, target_field.attname)
-                queryset._known_related_objects = {
-                    self.field: {rel_obj_id: self.instance}
-                }
-            return queryset
-
-        def _remove_prefetched_objects(self):
-            try:
-                self.instance._prefetched_objects_cache.pop(
-                    self.field.remote_field.get_cache_name()
-                )
-            except (AttributeError, KeyError):
-                pass  # nothing to clear from cache
-
-        def get_queryset(self):
-            # Even if this relation is not to primary key, we require still primary key value.
-            # The wish is that the instance has been already saved to DB,
-            # although having a primary key value isn't a guarantee of that.
-            if self.instance.id is None:
-                raise ValueError(
-                    f"{self.instance.__class__.__name__!r} instance needs to have a "
-                    f"primary key value before this relationship can be used."
-                )
-            try:
-                return self.instance._prefetched_objects_cache[
-                    self.field.remote_field.get_cache_name()
-                ]
-            except (AttributeError, KeyError):
-                queryset = super().get_queryset()
-                return self._apply_rel_filters(queryset)
-
-        def get_prefetch_queryset(self, instances, queryset=None):
-            if queryset is None:
-                queryset = super().get_queryset()
-
-            queryset._add_hints(instance=instances[0])
-
-            rel_obj_attr = self.field.get_local_related_value
-            instance_attr = self.field.get_foreign_related_value
-            instances_dict = {instance_attr(inst): inst for inst in instances}
-            queryset = _filter_prefetch_queryset(queryset, self.field.name, instances)
-
-            # Since we just bypassed this class' get_queryset(), we must manage
-            # the reverse relation manually.
-            for rel_obj in queryset:
-                if not self.field.is_cached(rel_obj):
-                    instance = instances_dict[rel_obj_attr(rel_obj)]
-                    setattr(rel_obj, self.field.name, instance)
-            cache_name = self.field.remote_field.get_cache_name()
-            return queryset, rel_obj_attr, instance_attr, False, cache_name, False
-
-        def add(self, *objs, bulk=True):
-            self._check_fk_val()
-            self._remove_prefetched_objects()
-
-            def check_and_update_obj(obj):
-                if not isinstance(obj, self.model):
-                    raise TypeError(
-                        f"'{self.model._meta.object_name}' instance expected, got {obj!r}"
-                    )
-                setattr(obj, self.field.name, self.instance)
-
-            if bulk:
-                ids = []
-                for obj in objs:
-                    check_and_update_obj(obj)
-                    if obj._state.adding:
-                        raise ValueError(
-                            f"{obj!r} instance isn't saved. Use bulk=False or save "
-                            "the object first."
-                        )
-                    ids.append(obj.id)
-                self.model._base_manager.filter(id__in=ids).update(
-                    **{
-                        self.field.name: self.instance,
-                    }
-                )
-            else:
-                with transaction.atomic(savepoint=False):
-                    for obj in objs:
-                        check_and_update_obj(obj)
-                        obj.save()
-
-        def create(self, **kwargs):
-            self._check_fk_val()
-            kwargs[self.field.name] = self.instance
-            return super().create(**kwargs)
-
-        def get_or_create(self, **kwargs):
-            self._check_fk_val()
-            kwargs[self.field.name] = self.instance
-            return super().get_or_create(**kwargs)
-
-        def update_or_create(self, **kwargs):
-            self._check_fk_val()
-            kwargs[self.field.name] = self.instance
-            return super().update_or_create(**kwargs)
-
-        # remove() and clear() are only provided if the ForeignKey can have a
-        # value of null.
-        if rel.field.allow_null:
-
-            def remove(self, *objs, bulk=True):
-                if not objs:
-                    return
-                self._check_fk_val()
-                val = self.field.get_foreign_related_value(self.instance)
-                old_ids = set()
-                for obj in objs:
-                    if not isinstance(obj, self.model):
-                        raise TypeError(
-                            f"'{self.model._meta.object_name}' instance expected, got {obj!r}"
-                        )
-                    # Is obj actually part of this descriptor set?
-                    if self.field.get_local_related_value(obj) == val:
-                        old_ids.add(obj.id)
-                    else:
-                        raise self.field.remote_field.model.DoesNotExist(
-                            f"{obj!r} is not related to {self.instance!r}."
-                        )
-                self._clear(self.filter(id__in=old_ids), bulk)
-
-            def clear(self, *, bulk=True):
-                self._check_fk_val()
-                self._clear(self, bulk)
-
-            def _clear(self, queryset, bulk):
-                self._remove_prefetched_objects()
-                if bulk:
-                    # `QuerySet.update()` is intrinsically atomic.
-                    queryset.update(**{self.field.name: None})
-                else:
-                    with transaction.atomic(savepoint=False):
-                        for obj in queryset:
-                            setattr(obj, self.field.name, None)
-                            obj.save(update_fields=[self.field.name])
-
-        def set(self, objs, *, bulk=True, clear=False):
-            self._check_fk_val()
-            # Force evaluation of `objs` in case it's a queryset whose value
-            # could be affected by `manager.clear()`. Refs #19816.
-            objs = tuple(objs)
-
-            if self.field.allow_null:
-                with transaction.atomic(savepoint=False):
-                    if clear:
-                        self.clear(bulk=bulk)
-                        self.add(*objs, bulk=bulk)
-                    else:
-                        old_objs = set(self.all())
-                        new_objs = []
-                        for obj in objs:
-                            if obj in old_objs:
-                                old_objs.remove(obj)
-                            else:
-                                new_objs.append(obj)
-
-                        self.remove(*old_objs, bulk=bulk)
-                        self.add(*new_objs, bulk=bulk)
-            else:
-                self.add(*objs, bulk=bulk)
-
-    return RelatedManager
-
-
-class ManyToManyDescriptor(ReverseManyToOneDescriptor):
+    def get_related_manager(self, instance):
+        """Return the ReverseManyToOneManager for this relation."""
+        return ReverseManyToOneManager(instance, self.rel)
+
+    def _get_set_deprecation_msg_params(self):
+        return (
+            "reverse side of a related set",
+            self.rel.get_accessor_name(),
+        )
+
+
+class ForwardManyToManyDescriptor(RelationDescriptorBase):
     """
-    Accessor to the related objects manager on the forward and reverse sides of
-    a many-to-many relation.
+    Accessor to the related objects manager on the forward side of a
+    many-to-many relation.
 
     In the example::
 
         class Pizza(Model):
             toppings = ManyToManyField(Topping, related_name='pizzas')
 
-    ``Pizza.toppings`` and ``Topping.pizzas`` are ``ManyToManyDescriptor``
-    instances.
-
-    Most of the implementation is delegated to a dynamically defined manager
-    class built by ``create_forward_many_to_many_manager()`` defined below.
+    ``Pizza.toppings`` is a ``ForwardManyToManyDescriptor`` instance.
     """
 
-    def __init__(self, rel, reverse=False):
-        super().__init__(rel)
-
-        self.reverse = reverse
-
     @property
     def through(self):
         # through is provided so that you have easy access to the through
@@ -596,348 +351,43 @@ class ManyToManyDescriptor(ReverseManyToOneDescriptor):
         # a property to ensure that the fully resolved value is returned.
         return self.rel.through
 
-    @cached_property
-    def related_manager_cls(self):
-        related_model = self.rel.related_model if self.reverse else self.rel.model
-
-        return create_forward_many_to_many_manager(
-            related_model._default_manager.__class__,
-            self.rel,
-            reverse=self.reverse,
-        )
+    def get_related_manager(self, instance):
+        """Return the ForwardManyToManyManager for this relation."""
+        return ForwardManyToManyManager(instance, self.rel)
 
     def _get_set_deprecation_msg_params(self):
         return (
-            "%s side of a many-to-many set"
-            % ("reverse" if self.reverse else "forward"),
-            self.rel.get_accessor_name() if self.reverse else self.field.name,
+            "forward side of a many-to-many set",
+            self.field.name,
         )
 
 
-def create_forward_many_to_many_manager(superclass, rel, reverse):
+class ReverseManyToManyDescriptor(RelationDescriptorBase):
     """
-    Create a manager for the either side of a many-to-many relation.
+    Accessor to the related objects manager on the reverse side of a
+    many-to-many relation.
 
-    This manager subclasses another manager, generally the default manager of
-    the related model, and adds behaviors specific to many-to-many relations.
-    """
+    In the example::
 
-    class ManyRelatedManager(superclass):
-        def __init__(self, instance=None):
-            super().__init__()
-
-            self.instance = instance
-
-            if not reverse:
-                self.model = rel.model
-                self.query_field_name = rel.field.related_query_name()
-                self.prefetch_cache_name = rel.field.name
-                self.source_field_name = rel.field.m2m_field_name()
-                self.target_field_name = rel.field.m2m_reverse_field_name()
-                self.symmetrical = rel.symmetrical
-            else:
-                self.model = rel.related_model
-                self.query_field_name = rel.field.name
-                self.prefetch_cache_name = rel.field.related_query_name()
-                self.source_field_name = rel.field.m2m_reverse_field_name()
-                self.target_field_name = rel.field.m2m_field_name()
-                self.symmetrical = False
-
-            self.through = rel.through
-            self.reverse = reverse
-
-            self.source_field = self.through._meta.get_field(self.source_field_name)
-            self.target_field = self.through._meta.get_field(self.target_field_name)
-
-            self.core_filters = {}
-            self.id_field_names = {}
-            for lh_field, rh_field in self.source_field.related_fields:
-                core_filter_key = f"{self.query_field_name}__{rh_field.name}"
-                self.core_filters[core_filter_key] = getattr(instance, rh_field.attname)
-                self.id_field_names[lh_field.name] = rh_field.name
-
-            self.related_val = self.source_field.get_foreign_related_value(instance)
-            if None in self.related_val:
-                raise ValueError(
-                    f'"{instance!r}" needs to have a value for field "{self.id_field_names[self.source_field_name]}" before '
-                    "this many-to-many relationship can be used."
-                )
-            # Even if this relation is not to primary key, we require still primary key value.
-            # The wish is that the instance has been already saved to DB,
-            # although having a primary key value isn't a guarantee of that.
-            if instance.id is None:
-                raise ValueError(
-                    f"{instance.__class__.__name__!r} instance needs to have a primary key value before "
-                    "a many-to-many relationship can be used."
-                )
-
-        def __call__(self, *, manager):
-            manager = getattr(self.model, manager)
-            manager_class = create_forward_many_to_many_manager(
-                manager.__class__, rel, reverse
-            )
-            return manager_class(instance=self.instance)
-
-        def _build_remove_filters(self, removed_vals):
-            filters = Q.create([(self.source_field_name, self.related_val)])
-            # No need to add a subquery condition if removed_vals is a QuerySet without
-            # filters.
-            removed_vals_filters = (
-                not isinstance(removed_vals, QuerySet) or removed_vals._has_filters()
-            )
-            if removed_vals_filters:
-                filters &= Q.create([(f"{self.target_field_name}__in", removed_vals)])
-            if self.symmetrical:
-                symmetrical_filters = Q.create(
-                    [(self.target_field_name, self.related_val)]
-                )
-                if removed_vals_filters:
-                    symmetrical_filters &= Q.create(
-                        [(f"{self.source_field_name}__in", removed_vals)]
-                    )
-                filters |= symmetrical_filters
-            return filters
-
-        def _apply_rel_filters(self, queryset):
-            """
-            Filter the queryset for the instance this manager is bound to.
-            """
-            queryset._add_hints(instance=self.instance)
-            queryset._defer_next_filter = True
-            return queryset._next_is_sticky().filter(**self.core_filters)
-
-        def _remove_prefetched_objects(self):
-            try:
-                self.instance._prefetched_objects_cache.pop(self.prefetch_cache_name)
-            except (AttributeError, KeyError):
-                pass  # nothing to clear from cache
-
-        def get_queryset(self):
-            try:
-                return self.instance._prefetched_objects_cache[self.prefetch_cache_name]
-            except (AttributeError, KeyError):
-                queryset = super().get_queryset()
-                return self._apply_rel_filters(queryset)
-
-        def get_prefetch_queryset(self, instances, queryset=None):
-            if queryset is None:
-                queryset = super().get_queryset()
-
-            queryset._add_hints(instance=instances[0])
-            queryset = _filter_prefetch_queryset(
-                queryset._next_is_sticky(), self.query_field_name, instances
-            )
+        class Pizza(Model):
+            toppings = ManyToManyField(Topping, related_name='pizzas')
 
-            # M2M: need to annotate the query in order to get the primary model
-            # that the secondary model was actually related to. We know that
-            # there will already be a join on the join table, so we can just add
-            # the select.
-
-            # For non-autocreated 'through' models, can't assume we are
-            # dealing with PK values.
-            fk = self.through._meta.get_field(self.source_field_name)
-            join_table = fk.model._meta.db_table
-            qn = db_connection.ops.quote_name
-            queryset = queryset.extra(
-                select={
-                    f"_prefetch_related_val_{f.attname}": f"{qn(join_table)}.{qn(f.column)}"
-                    for f in fk.local_related_fields
-                }
-            )
-            return (
-                queryset,
-                lambda result: tuple(
-                    getattr(result, f"_prefetch_related_val_{f.attname}")
-                    for f in fk.local_related_fields
-                ),
-                lambda inst: tuple(
-                    f.get_db_prep_value(getattr(inst, f.attname), db_connection)
-                    for f in fk.foreign_related_fields
-                ),
-                False,
-                self.prefetch_cache_name,
-                False,
-            )
+    ``Topping.pizzas`` is a ``ReverseManyToManyDescriptor`` instance.
+    """
 
-        def add(self, *objs, through_defaults=None):
-            self._remove_prefetched_objects()
-            with transaction.atomic(savepoint=False):
-                self._add_items(
-                    self.source_field_name,
-                    self.target_field_name,
-                    *objs,
-                    through_defaults=through_defaults,
-                )
-                # If this is a symmetrical m2m relation to self, add the mirror
-                # entry in the m2m table.
-                if self.symmetrical:
-                    self._add_items(
-                        self.target_field_name,
-                        self.source_field_name,
-                        *objs,
-                        through_defaults=through_defaults,
-                    )
-
-        def remove(self, *objs):
-            self._remove_prefetched_objects()
-            self._remove_items(self.source_field_name, self.target_field_name, *objs)
-
-        def clear(self):
-            with transaction.atomic(savepoint=False):
-                self._remove_prefetched_objects()
-                filters = self._build_remove_filters(super().get_queryset())
-                self.through._default_manager.filter(filters).delete()
-
-        def set(self, objs, *, clear=False, through_defaults=None):
-            # Force evaluation of `objs` in case it's a queryset whose value
-            # could be affected by `manager.clear()`. Refs #19816.
-            objs = tuple(objs)
-
-            with transaction.atomic(savepoint=False):
-                if clear:
-                    self.clear()
-                    self.add(*objs, through_defaults=through_defaults)
-                else:
-                    old_ids = set(
-                        self.values_list(
-                            self.target_field.target_field.attname, flat=True
-                        )
-                    )
-
-                    new_objs = []
-                    for obj in objs:
-                        fk_val = (
-                            self.target_field.get_foreign_related_value(obj)[0]
-                            if isinstance(obj, self.model)
-                            else self.target_field.get_prep_value(obj)
-                        )
-                        if fk_val in old_ids:
-                            old_ids.remove(fk_val)
-                        else:
-                            new_objs.append(obj)
-
-                    self.remove(*old_ids)
-                    self.add(*new_objs, through_defaults=through_defaults)
-
-        def create(self, *, through_defaults=None, **kwargs):
-            new_obj = super().create(**kwargs)
-            self.add(new_obj, through_defaults=through_defaults)
-            return new_obj
-
-        def get_or_create(self, *, through_defaults=None, **kwargs):
-            obj, created = super().get_or_create(**kwargs)
-            # We only need to add() if created because if we got an object back
-            # from get() then the relationship already exists.
-            if created:
-                self.add(obj, through_defaults=through_defaults)
-            return obj, created
-
-        def update_or_create(self, *, through_defaults=None, **kwargs):
-            obj, created = super().update_or_create(**kwargs)
-            # We only need to add() if created because if we got an object back
-            # from get() then the relationship already exists.
-            if created:
-                self.add(obj, through_defaults=through_defaults)
-            return obj, created
-
-        def _get_target_ids(self, target_field_name, objs):
-            """
-            Return the set of ids of `objs` that the target field references.
-            """
-            from plain.models import Model
-
-            target_ids = set()
-            target_field = self.through._meta.get_field(target_field_name)
-            for obj in objs:
-                if isinstance(obj, self.model):
-                    target_id = target_field.get_foreign_related_value(obj)[0]
-                    if target_id is None:
-                        raise ValueError(
-                            f'Cannot add "{obj!r}": the value for field "{target_field_name}" is None'
-                        )
-                    target_ids.add(target_id)
-                elif isinstance(obj, Model):
-                    raise TypeError(
-                        f"'{self.model._meta.object_name}' instance expected, got {obj!r}"
-                    )
-                else:
-                    target_ids.add(target_field.get_prep_value(obj))
-            return target_ids
-
-        def _get_missing_target_ids(
-            self, source_field_name, target_field_name, target_ids
-        ):
-            """
-            Return the subset of ids of `objs` that aren't already assigned to
-            this relationship.
-            """
-            vals = self.through._default_manager.values_list(
-                target_field_name, flat=True
-            ).filter(
-                **{
-                    source_field_name: self.related_val[0],
-                    f"{target_field_name}__in": target_ids,
-                }
-            )
-            return target_ids.difference(vals)
+    @property
+    def through(self):
+        # through is provided so that you have easy access to the through
+        # model (Book.authors.through) for inlines, etc. This is done as
+        # a property to ensure that the fully resolved value is returned.
+        return self.rel.through
 
-        def _add_items(
-            self, source_field_name, target_field_name, *objs, through_defaults=None
-        ):
-            # source_field_name: the PK fieldname in join table for the source object
-            # target_field_name: the PK fieldname in join table for the target object
-            # *objs - objects to add. Either object instances, or primary keys
-            # of object instances.
-            if not objs:
-                return
-
-            through_defaults = dict(resolve_callables(through_defaults or {}))
-            target_ids = self._get_target_ids(target_field_name, objs)
-
-            missing_target_ids = self._get_missing_target_ids(
-                source_field_name, target_field_name, target_ids
-            )
-            with transaction.atomic(savepoint=False):
-                # Add the ones that aren't there already.
-                self.through._default_manager.bulk_create(
-                    [
-                        self.through(
-                            **through_defaults,
-                            **{
-                                f"{source_field_name}_id": self.related_val[0],
-                                f"{target_field_name}_id": target_id,
-                            },
-                        )
-                        for target_id in missing_target_ids
-                    ],
-                )
-
-        def _remove_items(self, source_field_name, target_field_name, *objs):
-            # source_field_name: the PK colname in join table for the source object
-            # target_field_name: the PK colname in join table for the target object
-            # *objs - objects to remove. Either object instances, or primary
-            # keys of object instances.
-            if not objs:
-                return
-
-            # Check that all the objects are of the right type
-            old_ids = set()
-            for obj in objs:
-                if isinstance(obj, self.model):
-                    fk_val = self.target_field.get_foreign_related_value(obj)[0]
-                    old_ids.add(fk_val)
-                else:
-                    old_ids.add(obj)
-
-            with transaction.atomic(savepoint=False):
-                target_model_qs = super().get_queryset()
-                if target_model_qs._has_filters():
-                    old_vals = target_model_qs.filter(
-                        **{f"{self.target_field.target_field.attname}__in": old_ids}
-                    )
-                else:
-                    old_vals = old_ids
-                filters = self._build_remove_filters(old_vals)
-                self.through._default_manager.filter(filters).delete()
-
-    return ManyRelatedManager
+    def get_related_manager(self, instance):
+        """Return the ReverseManyToManyManager for this relation."""
+        return ReverseManyToManyManager(instance, self.rel)
+
+    def _get_set_deprecation_msg_params(self):
+        return (
+            "reverse side of a many-to-many set",
+            self.rel.get_accessor_name(),
+        )