Change objects manager via Meta.manager_class, init Manager with a model class

Author: davegaeddert

plain-auth/plain/auth/sessions.py

@@ -115,7 +115,7 @@ def get_user(request):
 
     UserModel = get_user_model()
     try:
-        user = UserModel._default_manager.get(id=request.session[USER_ID_SESSION_KEY])
+        user = UserModel.objects.get(id=request.session[USER_ID_SESSION_KEY])
     except UserModel.DoesNotExist:
         return None
 

plain-cache/plain/cache/models.py

@@ -21,9 +21,8 @@ class CachedItem(models.Model):
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
 
-    objects = CachedItemQuerySet.as_manager()
-
     class Meta:
+        manager_class = CachedItemQuerySet
         indexes = [
             models.Index(fields=["expires_at"]),
         ]

plain-models/plain/models/base.py

@@ -24,7 +24,6 @@
 from plain.models.expressions import RawSQL, Value
 from plain.models.fields import NOT_PROVIDED
 from plain.models.fields.reverse_related import ForeignObjectRel
-from plain.models.manager import BaseManager, Manager
 from plain.models.options import Options
 from plain.models.query import F, Q
 from plain.packages import packages_registry
@@ -75,7 +74,7 @@ def __new__(cls, name, bases, attrs, **kwargs):
         new_class._add_exceptions()
 
         # Now go back over all the attrs on this class see if they have a contribute_to_class() method.
-        # Attributes with contribute_to_class are fields, meta options, and managers.
+        # Attributes with contribute_to_class are fields and meta options.
         for attr_name, attr_value in inspect.getmembers(new_class):
             if attr_name.startswith("_"):
                 continue
@@ -154,13 +153,6 @@ def _prepare(cls):
         opts = cls._meta
         opts._prepare(cls)
 
-        # Validate that 'objects' is either None or a Manager
-        if cls.objects is not None and not isinstance(cls.objects, BaseManager):
-            raise TypeError(
-                f"Model {cls.__name__} attribute 'objects' must be either None "
-                f"or a Manager instance, got {type(cls.objects).__name__}"
-            )
-
         # Give the class a docstring -- its definition.
         if cls.__doc__ is None:
             cls.__doc__ = "{}({})".format(
@@ -176,12 +168,8 @@ def _prepare(cls):
                 index.set_name_with_model(cls)
 
     @property
-    def _base_manager(cls):
-        return cls._meta.base_manager
-
-    @property
-    def _default_manager(cls):
-        return cls._meta.default_manager
+    def objects(cls):
+        return cls._meta.manager
 
 
 class ModelStateFieldsCacheDescriptor:
@@ -204,7 +192,6 @@ class ModelState:
 
 
 class Model(metaclass=ModelBase):
-    objects = Manager()
     DoesNotExist: type[ObjectDoesNotExist]
     MultipleObjectsReturned: type[MultipleObjectsReturned]
 
@@ -435,7 +422,9 @@ def refresh_from_db(self, fields=None):
                     "are not allowed in fields."
                 )
 
-        db_instance_qs = self.__class__._base_manager.get_queryset().filter(id=self.id)
+        db_instance_qs = self.__class__._meta.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()
@@ -618,7 +607,7 @@ def _save_table(
             force_insert = True
         # If possible, try an UPDATE. If that doesn't update anything, do an INSERT.
         if id_set and not force_insert:
-            base_qs = cls._base_manager
+            base_qs = meta.base_manager
             values = [
                 (
                     f,
@@ -642,7 +631,7 @@ def _save_table(
                 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)
+            results = self._do_insert(meta.base_manager, fields, returning_fields, raw)
             if results:
                 for value, field in zip(results[0], returning_fields):
                     setattr(self, field.attname, value)
@@ -739,7 +728,7 @@ def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
         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)
+            self.__class__.objects.filter(**kwargs)
             .filter(q)
             .order_by(f"{order}{field.name}", f"{order}id")
         )
@@ -837,7 +826,7 @@ def _perform_unique_checks(self, unique_checks):
             if len(unique_check) != len(lookup_kwargs):
                 continue
 
-            qs = model_class._default_manager.filter(**lookup_kwargs)
+            qs = model_class.objects.filter(**lookup_kwargs)
 
             # Exclude the current object from the query if we are editing an
             # instance (as opposed to creating a new one)
@@ -1044,7 +1033,6 @@ def _check_db_table_comment(cls, database):
             )
         return errors
 
-
     @classmethod
     def _check_fields(cls, **kwargs):
         """Perform all field checks."""

plain-models/plain/models/constraints.py

@@ -347,7 +347,7 @@ def deconstruct(self):
         return path, self.expressions, kwargs
 
     def validate(self, model, instance, exclude=None):
-        queryset = model._default_manager
+        queryset = model.objects
         if self.fields:
             lookup_kwargs = {}
             for field_name in self.fields:

plain-models/plain/models/deletion.py

@@ -352,7 +352,7 @@ def related_objects(self, related_model, related_fields, objs):
             [(f"{related_field.name}__in", objs) for related_field in related_fields],
             connector=query_utils.Q.OR,
         )
-        return related_model._base_manager.filter(predicate)
+        return related_model._meta.base_manager.filter(predicate)
 
     def sort(self):
         sorted_models = []

plain-models/plain/models/fields/__init__.py

@@ -901,7 +901,7 @@ def get_choices(
             if hasattr(self.remote_field, "get_related_field")
             else "id"
         )
-        qs = rel_model._default_manager.complex_filter(limit_choices_to)
+        qs = rel_model.objects.complex_filter(limit_choices_to)
         if ordering:
             qs = qs.order_by(*ordering)
         return (blank_choice if include_blank else []) + [

plain-models/plain/models/fields/related.py

@@ -669,7 +669,7 @@ def validate(self, value, model_instance):
         if value is None:
             return
 
-        qs = self.remote_field.model._base_manager.filter(
+        qs = self.remote_field.model._meta.base_manager.filter(
             **{self.remote_field.field_name: value}
         )
         qs = qs.complex_filter(self.get_limit_choices_to())

plain-models/plain/models/fields/related_descriptors.py

@@ -123,7 +123,7 @@ def is_cached(self, instance):
         return self.field.is_cached(instance)
 
     def get_queryset(self):
-        qs = self.field.remote_field.model._base_manager.get_queryset()
+        qs = self.field.remote_field.model._meta.base_manager.get_queryset()
         return qs.all()
 
     def get_prefetch_queryset(self, instances, queryset=None):
@@ -308,7 +308,7 @@ def related_manager_cls(self):
         related_model = self.rel.related_model
 
         return create_reverse_many_to_one_manager(
-            related_model._default_manager.__class__,
+            related_model.objects.__class__,
             self.rel,
         )
 
@@ -351,10 +351,9 @@ def create_reverse_many_to_one_manager(superclass, rel):
 
     class RelatedManager(superclass):
         def __init__(self, instance):
-            super().__init__()
-
+            super().__init__(model=rel.related_model)
             self.instance = instance
-            self.model = rel.related_model
+
             self.field = rel.field
 
             self.core_filters = {self.field.name: instance}
@@ -469,7 +468,7 @@ def check_and_update_obj(obj):
                             "the object first."
                         )
                     ids.append(obj.id)
-                self.model._base_manager.filter(id__in=ids).update(
+                self.model._meta.base_manager.filter(id__in=ids).update(
                     **{
                         self.field.name: self.instance,
                     }
@@ -596,7 +595,7 @@ 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__,
+            related_model.objects.__class__,
             self.rel,
             reverse=self.reverse,
         )
@@ -619,25 +618,25 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
 
     class ManyRelatedManager(superclass):
         def __init__(self, instance=None):
-            super().__init__()
-
             self.instance = instance
 
             if not reverse:
-                self.model = rel.model
+                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
+                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
 
+            super().__init__(model=model)
+
             self.through = rel.through
             self.reverse = reverse
 
@@ -779,7 +778,7 @@ 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()
+                self.through.objects.filter(filters).delete()
 
         def set(self, objs, *, clear=False, through_defaults=None):
             # Force evaluation of `objs` in case it's a queryset whose value
@@ -864,7 +863,7 @@ def _get_missing_target_ids(
             Return the subset of ids of `objs` that aren't already assigned to
             this relationship.
             """
-            vals = self.through._default_manager.values_list(
+            vals = self.through.objects.values_list(
                 target_field_name, flat=True
             ).filter(
                 **{
@@ -892,7 +891,7 @@ def _add_items(
             )
             with transaction.atomic(savepoint=False):
                 # Add the ones that aren't there already.
-                self.through._default_manager.bulk_create(
+                self.through.objects.bulk_create(
                     [
                         self.through(
                             **through_defaults,
@@ -931,6 +930,6 @@ def _remove_items(self, source_field_name, target_field_name, *objs):
                 else:
                     old_vals = old_ids
                 filters = self._build_remove_filters(old_vals)
-                self.through._default_manager.filter(filters).delete()
+                self.through.objects.filter(filters).delete()
 
     return ManyRelatedManager

plain-models/plain/models/fields/reverse_related.py

@@ -166,7 +166,7 @@ def get_choices(
         initially for utilization by RelatedFieldListFilter.
         """
         limit_choices_to = limit_choices_to or self.limit_choices_to
-        qs = self.related_model._default_manager.complex_filter(limit_choices_to)
+        qs = self.related_model.objects.complex_filter(limit_choices_to)
         if ordering:
             qs = qs.order_by(*ordering)
         return (blank_choice if include_blank else []) + [(x.id, str(x)) for x in qs]

plain-models/plain/models/forms.py

@@ -721,7 +721,7 @@ def modelfield_to_formfield(
 
     if isinstance(modelfield, models.ForeignKey):
         return ModelChoiceField(
-            queryset=modelfield.remote_field.model._default_manager,
+            queryset=modelfield.remote_field.model.objects,
             **defaults,
         )