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

plain/models/fields/related_descriptors.py

@@ -122,15 +122,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):
+        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 +168,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))
 
@@ -310,7 +308,7 @@ class ReverseManyToOneDescriptor:
         related_model = self.rel.related_model
 
         return create_reverse_many_to_one_manager(
-            related_model._default_manager.__class__,
+            related_model.query.__class__,
             self.rel,
         )
 
@@ -347,24 +345,27 @@ def create_reverse_many_to_one_manager(superclass, rel):
     """
     Create a manager for the reverse side of a many-to-one relation.
 
-    This manager subclasses another manager, generally the default manager of
-    the related model, and adds behaviors specific to many-to-one relations.
+    This manager adds behaviors specific to many-to-one relations.
     """
 
-    class RelatedManager(superclass):
+    class RelatedManager:
         def __init__(self, instance):
-            super().__init__()
-
-            self.instance = instance
             self.model = rel.related_model
+            self.instance = instance
             self.field = rel.field
-
             self.core_filters = {self.field.name: instance}
+            # Store the base queryset class for this model
+            self.base_queryset_class = rel.related_model._meta.queryset.__class__
 
-        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)
+        @property
+        def query(self):
+            """
+            Access the QuerySet for this relationship.
+
+            Example:
+                parent.children.query.filter(active=True)
+            """
+            return self.get_queryset()
 
         def _check_fk_val(self):
             for field in self.field.foreign_related_fields:
@@ -378,7 +379,6 @@ def create_reverse_many_to_one_manager(superclass, rel):
             """
             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:
@@ -430,14 +430,13 @@ def create_reverse_many_to_one_manager(superclass, rel):
                     self.field.remote_field.get_cache_name()
                 ]
             except (AttributeError, KeyError):
-                queryset = super().get_queryset()
+                # Use the base queryset class for this model
+                queryset = self.base_queryset_class(model=self.model)
                 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 = self.base_queryset_class(model=self.model)
 
             rel_obj_attr = self.field.get_local_related_value
             instance_attr = self.field.get_foreign_related_value
@@ -474,7 +473,7 @@ def create_reverse_many_to_one_manager(superclass, rel):
                             "the object first."
                         )
                     ids.append(obj.id)
-                self.model._base_manager.filter(id__in=ids).update(
+                self.model._meta.base_queryset.filter(id__in=ids).update(
                     **{
                         self.field.name: self.instance,
                     }
@@ -488,17 +487,17 @@ def create_reverse_many_to_one_manager(superclass, rel):
         def create(self, **kwargs):
             self._check_fk_val()
             kwargs[self.field.name] = self.instance
-            return super().create(**kwargs)
+            return self.base_queryset_class(model=self.model).create(**kwargs)
 
         def get_or_create(self, **kwargs):
             self._check_fk_val()
             kwargs[self.field.name] = self.instance
-            return super().get_or_create(**kwargs)
+            return self.base_queryset_class(model=self.model).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)
+            return self.base_queryset_class(model=self.model).update_or_create(**kwargs)
 
         # remove() and clear() are only provided if the ForeignKey can have a
         # value of null.
@@ -601,7 +600,7 @@ class ManyToManyDescriptor(ReverseManyToOneDescriptor):
         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.query.__class__,
             self.rel,
             reverse=self.reverse,
         )
@@ -618,14 +617,11 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
     """
     Create a manager for the either 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.
+    This manager adds behaviors specific to many-to-many relations.
     """
 
-    class ManyRelatedManager(superclass):
+    class ManyRelatedManager:
         def __init__(self, instance=None):
-            super().__init__()
-
             self.instance = instance
 
             if not reverse:
@@ -643,6 +639,9 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                 self.target_field_name = rel.field.m2m_field_name()
                 self.symmetrical = False
 
+            # Store the base queryset class for this model
+            self.base_queryset_class = self.model._meta.queryset.__class__
+
             self.through = rel.through
             self.reverse = reverse
 
@@ -671,12 +670,15 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                     "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)
+        @property
+        def query(self):
+            """
+            Access the QuerySet for this relationship.
+
+            Example:
+                book.authors.query.filter(active=True)
+            """
+            return self.get_queryset()
 
         def _build_remove_filters(self, removed_vals):
             filters = Q.create([(self.source_field_name, self.related_val)])
@@ -702,7 +704,6 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             """
             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)
 
@@ -716,14 +717,13 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             try:
                 return self.instance._prefetched_objects_cache[self.prefetch_cache_name]
             except (AttributeError, KeyError):
-                queryset = super().get_queryset()
+                queryset = self.base_queryset_class(model=self.model)
                 return self._apply_rel_filters(queryset)
 
         def get_prefetch_queryset(self, instances, queryset=None):
             if queryset is None:
-                queryset = super().get_queryset()
+                queryset = self.base_queryset_class(model=self.model)
 
-            queryset._add_hints(instance=instances[0])
             queryset = _filter_prefetch_queryset(
                 queryset._next_is_sticky(), self.query_field_name, instances
             )
@@ -785,8 +785,10 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
         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()
+                filters = self._build_remove_filters(
+                    self.base_queryset_class(model=self.model)
+                )
+                self.through.query.filter(filters).delete()
 
         def set(self, objs, *, clear=False, through_defaults=None):
             # Force evaluation of `objs` in case it's a queryset whose value
@@ -820,12 +822,14 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                     self.add(*new_objs, through_defaults=through_defaults)
 
         def create(self, *, through_defaults=None, **kwargs):
-            new_obj = super().create(**kwargs)
+            new_obj = self.base_queryset_class(model=self.model).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)
+            obj, created = self.base_queryset_class(model=self.model).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:
@@ -833,7 +837,9 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             return obj, created
 
         def update_or_create(self, *, through_defaults=None, **kwargs):
-            obj, created = super().update_or_create(**kwargs)
+            obj, created = self.base_queryset_class(model=self.model).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:
@@ -871,9 +877,7 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             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(
+            vals = self.through.query.values_list(target_field_name, flat=True).filter(
                 **{
                     source_field_name: self.related_val[0],
                     f"{target_field_name}__in": target_ids,
@@ -899,7 +903,7 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             )
             with transaction.atomic(savepoint=False):
                 # Add the ones that aren't there already.
-                self.through._default_manager.bulk_create(
+                self.through.query.bulk_create(
                     [
                         self.through(
                             **through_defaults,
@@ -930,7 +934,7 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                     old_ids.add(obj)
 
             with transaction.atomic(savepoint=False):
-                target_model_qs = super().get_queryset()
+                target_model_qs = self.base_queryset_class(model=self.model)
                 if target_model_qs._has_filters():
                     old_vals = target_model_qs.filter(
                         **{f"{self.target_field.target_field.attname}__in": old_ids}
@@ -938,6 +942,6 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                 else:
                     old_vals = old_ids
                 filters = self._build_remove_filters(old_vals)
-                self.through._default_manager.filter(filters).delete()
+                self.through.query.filter(filters).delete()
 
     return ManyRelatedManager

plain/models/fields/related_lookups.py

@@ -53,7 +53,7 @@ def get_normalized_value(value, lhs):
             try:
                 value_list.append(getattr(value, source.attname))
             except AttributeError:
-                # A case like Restaurant.objects.filter(place=restaurant_instance),
+                # A case like Restaurant.query.filter(place=restaurant_instance),
                 # where place is a OneToOneField and the primary key of Restaurant.
                 return (value.id,)
         return tuple(value_list)
@@ -88,7 +88,7 @@ class RelatedIn(In):
                     and self.lhs.output_field.model == self.rhs.model
                 ):
                     # A case like
-                    # Restaurant.objects.filter(place__in=restaurant_qs), where
+                    # Restaurant.query.filter(place__in=restaurant_qs), where
                     # place is a OneToOneField and the primary key of
                     # Restaurant.
                     target_field = self.lhs.field.name

plain/models/fields/reverse_related.py

@@ -166,7 +166,7 @@ class ForeignObjectRel(FieldCacheMixin):
         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.query.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/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.query,
             **defaults,
         )
 

plain/models/migrations/autodetector.py

@@ -152,7 +152,6 @@ class MigrationAutodetector:
         self.generate_deleted_models()
         self.generate_created_models()
         self.generate_altered_options()
-        self.generate_altered_managers()
         self.generate_altered_db_table_comment()
 
         # Create the renamed fields and store them in self.renamed_fields.
@@ -600,7 +599,6 @@ class MigrationAutodetector:
                     ],
                     options=model_state.options,
                     bases=model_state.bases,
-                    managers=model_state.managers,
                 ),
                 dependencies=dependencies,
                 beginning=True,
@@ -1258,22 +1256,6 @@ class MigrationAutodetector:
                     ),
                 )
 
-    def generate_altered_managers(self):
-        for package_label, model_name in sorted(self.kept_model_keys):
-            old_model_name = self.renamed_models.get(
-                (package_label, model_name), model_name
-            )
-            old_model_state = self.from_state.models[package_label, old_model_name]
-            new_model_state = self.to_state.models[package_label, model_name]
-            if old_model_state.managers != new_model_state.managers:
-                self.add_operation(
-                    package_label,
-                    operations.AlterModelManagers(
-                        name=model_name,
-                        managers=new_model_state.managers,
-                    ),
-                )
-
     def arrange_for_graph(self, changes, graph, migration_name=None):
         """
         Take a result from changes() and a MigrationGraph, and fix the names

plain/models/migrations/operations/__init__.py

@@ -2,7 +2,6 @@ from .fields import AddField, AlterField, RemoveField, RenameField
 from .models import (
     AddConstraint,
     AddIndex,
-    AlterModelManagers,
     AlterModelOptions,
     AlterModelTable,
     AlterModelTableComment,
@@ -34,5 +33,4 @@ __all__ = [
     "SeparateDatabaseAndState",
     "RunSQL",
     "RunPython",
-    "AlterModelManagers",
 ]

plain/models/migrations/operations/models.py

@@ -41,16 +41,14 @@ class ModelOperation(Operation):
 class CreateModel(ModelOperation):
     """Create a model's table."""
 
-    serialization_expand_args = ["fields", "options", "managers"]
+    serialization_expand_args = ["fields", "options"]
 
-    def __init__(self, name, fields, options=None, bases=None, managers=None):
+    def __init__(self, name, fields, options=None, bases=None):
         self.fields = fields
         self.options = options or {}
         self.bases = bases or (models.Model,)
-        self.managers = managers or []
         super().__init__(name)
-        # Sanity-check that there are no duplicated field names, bases, or
-        # manager names
+        # Sanity-check that there are no duplicated field names or bases
         _check_for_duplicates("fields", (name for name, _ in self.fields))
         _check_for_duplicates(
             "bases",
@@ -63,7 +61,6 @@ class CreateModel(ModelOperation):
                 for base in self.bases
             ),
         )
-        _check_for_duplicates("managers", (name for name, _ in self.managers))
 
     def deconstruct(self):
         kwargs = {
@@ -74,8 +71,6 @@ class CreateModel(ModelOperation):
             kwargs["options"] = self.options
         if self.bases and self.bases != (models.Model,):
             kwargs["bases"] = self.bases
-        if self.managers and self.managers != [("objects", models.Manager())]:
-            kwargs["managers"] = self.managers
         return (self.__class__.__qualname__, [], kwargs)
 
     def state_forwards(self, package_label, state):
@@ -86,7 +81,6 @@ class CreateModel(ModelOperation):
                 list(self.fields),
                 dict(self.options),
                 tuple(self.bases),
-                list(self.managers),
             )
         )
 
@@ -141,7 +135,6 @@ class CreateModel(ModelOperation):
                     fields=self.fields,
                     options=self.options,
                     bases=self.bases,
-                    managers=self.managers,
                 ),
             ]
         elif (
@@ -158,20 +151,6 @@ class CreateModel(ModelOperation):
                     fields=self.fields,
                     options=options,
                     bases=self.bases,
-                    managers=self.managers,
-                ),
-            ]
-        elif (
-            isinstance(operation, AlterModelManagers)
-            and self.name_lower == operation.name_lower
-        ):
-            return [
-                CreateModel(
-                    self.name,
-                    fields=self.fields,
-                    options=self.options,
-                    bases=self.bases,
-                    managers=operation.managers,
                 ),
             ]
         elif (
@@ -185,7 +164,6 @@ class CreateModel(ModelOperation):
                         fields=self.fields + [(operation.name, operation.field)],
                         options=self.options,
                         bases=self.bases,
-                        managers=self.managers,
                     ),
                 ]
             elif isinstance(operation, AlterField):
@@ -198,7 +176,6 @@ class CreateModel(ModelOperation):
                         ],
                         options=self.options,
                         bases=self.bases,
-                        managers=self.managers,
                     ),
                 ]
             elif isinstance(operation, RemoveField):
@@ -214,7 +191,6 @@ class CreateModel(ModelOperation):
                         ],
                         options=options,
                         bases=self.bases,
-                        managers=self.managers,
                     ),
                 ]
             elif isinstance(operation, RenameField):
@@ -229,7 +205,6 @@ class CreateModel(ModelOperation):
                         ],
                         options=options,
                         bases=self.bases,
-                        managers=self.managers,
                     ),
                 ]
         return super().reduce(operation, package_label)
@@ -447,9 +422,6 @@ class AlterModelOptions(ModelOptionOperation):
 
     # Model options we want to compare and preserve in an AlterModelOptions op
     ALTER_OPTION_KEYS = [
-        "base_manager_name",
-        "default_manager_name",
-        "default_related_name",
         "ordering",
     ]
 
@@ -483,32 +455,6 @@ class AlterModelOptions(ModelOptionOperation):
         return f"alter_{self.name_lower}_options"
 
 
-class AlterModelManagers(ModelOptionOperation):
-    """Alter the model's managers."""
-
-    serialization_expand_args = ["managers"]
-
-    def __init__(self, name, managers):
-        self.managers = managers
-        super().__init__(name)
-
-    def deconstruct(self):
-        return (self.__class__.__qualname__, [self.name, self.managers], {})
-
-    def state_forwards(self, package_label, state):
-        state.alter_model_managers(package_label, self.name_lower, self.managers)
-
-    def database_forwards(self, package_label, schema_editor, from_state, to_state):
-        pass
-
-    def describe(self):
-        return f"Change managers on {self.name}"
-
-    @property
-    def migration_name_fragment(self):
-        return f"alter_{self.name_lower}_managers"
-
-
 class IndexOperation(Operation):
     option_name = "indexes"
 

plain/models/migrations/operations/special.py

@@ -49,10 +49,9 @@ class RunSQL(Operation):
     by this SQL change, in case it's custom column/table creation/deletion.
     """
 
-    def __init__(self, sql, *, state_operations=None, hints=None, elidable=False):
+    def __init__(self, sql, *, state_operations=None, elidable=False):
         self.sql = sql
         self.state_operations = state_operations or []
-        self.hints = hints or {}
         self.elidable = elidable
 
     def deconstruct(self):
@@ -61,8 +60,6 @@ class RunSQL(Operation):
         }
         if self.state_operations:
             kwargs["state_operations"] = self.state_operations
-        if self.hints:
-            kwargs["hints"] = self.hints
         return (self.__class__.__qualname__, [], kwargs)
 
     def state_forwards(self, package_label, state):
@@ -99,13 +96,12 @@ class RunPython(Operation):
 
     reduces_to_sql = False
 
-    def __init__(self, code, *, atomic=None, hints=None, elidable=False):
+    def __init__(self, code, *, atomic=None, elidable=False):
         self.atomic = atomic
         # Forwards code
         if not callable(code):
             raise ValueError("RunPython must be supplied with a callable")
         self.code = code
-        self.hints = hints or {}
         self.elidable = elidable
 
     def deconstruct(self):
@@ -114,8 +110,6 @@ class RunPython(Operation):
         }
         if self.atomic is not None:
             kwargs["atomic"] = self.atomic
-        if self.hints:
-            kwargs["hints"] = self.hints
         return (self.__class__.__qualname__, [], kwargs)
 
     def state_forwards(self, package_label, state):

plain/models/migrations/recorder.py

@@ -53,7 +53,7 @@ class MigrationRecorder:
 
     @property
     def migration_qs(self):
-        return self.Migration.objects.all()
+        return self.Migration.query.all()
 
     def has_table(self):
         """Return True if the plainmigrations table exists."""

plain/models/migrations/serializer.py

@@ -215,16 +215,6 @@ class ModelFieldSerializer(DeconstructableSerializer):
         return self.serialize_deconstructed(path, args, kwargs)
 
 
-class ModelManagerSerializer(DeconstructableSerializer):
-    def serialize(self):
-        as_manager, manager_path, qs_path, args, kwargs = self.value.deconstruct()
-        if as_manager:
-            name, imports = self._serialize_path(qs_path)
-            return f"{name}.as_manager()", imports
-        else:
-            return self.serialize_deconstructed(manager_path, args, kwargs)
-
-
 class OperationSerializer(BaseSerializer):
     def serialize(self):
         from plain.models.migrations.writer import OperationWriter
@@ -359,8 +349,6 @@ def serializer_factory(value):
 
     if isinstance(value, models.Field):
         return ModelFieldSerializer(value)
-    if isinstance(value, models.manager.BaseManager):
-        return ModelManagerSerializer(value)
     if isinstance(value, Operation):
         return OperationSerializer(value)
     if isinstance(value, type):