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

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):

plain/models/migrations/state.py

@@ -12,7 +12,6 @@ from plain.models.options import DEFAULT_NAMES
 from plain.models.registry import ModelsRegistry
 from plain.models.registry import models_registry as global_models
 from plain.packages import packages_registry
-from plain.utils.module_loading import import_string
 
 from .exceptions import InvalidBasesError
 from .utils import resolve_relation
@@ -176,11 +175,6 @@ class ProjectState:
                     model_state.options.pop(key, False)
         self.reload_model(package_label, model_name, delay=True)
 
-    def alter_model_managers(self, package_label, model_name, managers):
-        model_state = self.models[package_label, model_name]
-        model_state.managers = list(managers)
-        self.reload_model(package_label, model_name, delay=True)
-
     def _append_option(self, package_label, model_name, option_name, obj):
         model_state = self.models[package_label, model_name]
         model_state.options[option_name] = [*model_state.options[option_name], obj]
@@ -598,9 +592,7 @@ class ModelState:
     assign new ones, as these are not detached during a clone.
     """
 
-    def __init__(
-        self, package_label, name, fields, options=None, bases=None, managers=None
-    ):
+    def __init__(self, package_label, name, fields, options=None, bases=None):
         self.package_label = package_label
         self.name = name
         self.fields = dict(fields)
@@ -608,7 +600,6 @@ class ModelState:
         self.options.setdefault("indexes", [])
         self.options.setdefault("constraints", [])
         self.bases = bases or (models.Model,)
-        self.managers = managers or []
         for name, field in self.fields.items():
             # Sanity-check that fields are NOT already bound to a model.
             if hasattr(field, "model"):
@@ -711,33 +702,6 @@ class ModelState:
         ):
             bases = (models.Model,)
 
-        managers = []
-        manager_names = set()
-        default_manager_shim = None
-        for manager in model._meta.managers:
-            if manager.name in manager_names:
-                # Skip overridden managers.
-                continue
-            elif manager.use_in_migrations:
-                # Copy managers usable in migrations.
-                new_manager = copy.copy(manager)
-                new_manager._set_creation_counter()
-            elif manager is model._base_manager or manager is model._default_manager:
-                # Shim custom managers used as default and base managers.
-                new_manager = models.Manager()
-                new_manager.model = manager.model
-                new_manager.name = manager.name
-                if manager is model._default_manager:
-                    default_manager_shim = new_manager
-            else:
-                continue
-            manager_names.add(manager.name)
-            managers.append((manager.name, new_manager))
-
-        # Ignore a shimmed default manager called objects if it's the only one.
-        if managers == [("objects", default_manager_shim)]:
-            managers = []
-
         # Construct the new ModelState
         return cls(
             model._meta.package_label,
@@ -745,22 +709,8 @@ class ModelState:
             fields,
             options,
             bases,
-            managers,
         )
 
-    def construct_managers(self):
-        """Deep-clone the managers using deconstruction."""
-        # Sort all managers by their creation counter
-        sorted_managers = sorted(self.managers, key=lambda v: v[1].creation_counter)
-        for mgr_name, manager in sorted_managers:
-            as_manager, manager_path, qs_path, args, kwargs = manager.deconstruct()
-            if as_manager:
-                qs_class = import_string(qs_path)
-                yield mgr_name, qs_class.as_manager()
-            else:
-                manager_class = import_string(manager_path)
-                yield mgr_name, manager_class(*args, **kwargs)
-
     def clone(self):
         """Return an exact copy of this ModelState."""
         return self.__class__(
@@ -772,7 +722,6 @@ class ModelState:
             # than mutating it.
             options=dict(self.options),
             bases=self.bases,
-            managers=list(self.managers),
         )
 
     def render(self, models_registry):
@@ -799,8 +748,6 @@ class ModelState:
         body["Meta"] = meta
         body["__module__"] = "__fake__"
 
-        # Restore managers
-        body.update(self.construct_managers())
         # Then, make a Model object (models_registry.register_model is called in __new__)
         model_class = type(self.name, bases, body)
         from plain.models import register_model
@@ -840,5 +787,4 @@ class ModelState:
             )
             and (self.options == other.options)
             and (self.bases == other.bases)
-            and (self.managers == other.managers)
         )

plain/models/options.py

@@ -1,5 +1,4 @@
 import bisect
-import copy
 import inspect
 from collections import defaultdict
 from functools import cached_property
@@ -9,7 +8,7 @@ from plain.models import models_registry
 from plain.models.constraints import UniqueConstraint
 from plain.models.db import db_connection
 from plain.models.fields import PrimaryKeyField
-from plain.models.manager import Manager
+from plain.models.query import QuerySet
 from plain.utils.datastructures import ImmutableList
 
 PROXY_PARENTS = object()
@@ -24,14 +23,12 @@ IMMUTABLE_WARNING = (
 DEFAULT_NAMES = (
     "db_table",
     "db_table_comment",
+    "queryset_class",
     "ordering",
     "package_label",
     "models_registry",
-    "default_related_name",
     "required_db_features",
     "required_db_vendor",
-    "base_manager_name",
-    "default_manager_name",
     "indexes",
     "constraints",
 )
@@ -49,10 +46,8 @@ class Options:
         "local_concrete_fields",
         "_non_pk_concrete_field_names",
         "_forward_fields_map",
-        "managers",
-        "managers_map",
-        "base_manager",
-        "default_manager",
+        "base_queryset",
+        "queryset",
     }
     REVERSE_PROPERTIES = {"related_objects", "fields_map", "_relation_tree"}
 
@@ -62,9 +57,7 @@ class Options:
         self._get_fields_cache = {}
         self.local_fields = []
         self.local_many_to_many = []
-        self.local_managers = []
-        self.base_manager_name = None
-        self.default_manager_name = None
+        self.queryset_class = None
         self.model_name = None
         self.db_table = ""
         self.db_table_comment = ""
@@ -89,8 +82,6 @@ class Options:
         # A custom app registry to use, if you're making a separate model set.
         self.models_registry = self.default_models_registry
 
-        self.default_related_name = None
-
     @property
     def label(self):
         return f"{self.package_label}.{self.object_name}"
@@ -169,10 +160,6 @@ class Options:
         if not any(f.name == "id" for f in self.local_fields):
             model.add_to_class("id", PrimaryKeyField())
 
-    def add_manager(self, manager):
-        self.local_managers.append(manager)
-        self._expire_cache()
-
     def add_field(self, field, private=False):
         # Insert the given field in the order in which it was created, using
         # the "creation_counter" attribute of the field.
@@ -224,75 +211,25 @@ class Options:
             )
         return True
 
-    @cached_property
-    def managers(self):
-        managers = []
-        seen_managers = set()
-        bases = (b for b in self.model.mro() if hasattr(b, "_meta"))
-        for depth, base in enumerate(bases):
-            for manager in base._meta.local_managers:
-                if manager.name in seen_managers:
-                    continue
-
-                manager = copy.copy(manager)
-                manager.model = self.model
-                seen_managers.add(manager.name)
-                managers.append((depth, manager.creation_counter, manager))
-
-        return make_immutable_fields_list(
-            "managers",
-            (m[2] for m in sorted(managers)),
-        )
-
-    @cached_property
-    def managers_map(self):
-        return {manager.name: manager for manager in self.managers}
-
-    @cached_property
-    def base_manager(self):
-        base_manager_name = self.base_manager_name
-        if not base_manager_name:
-            # Get the first parent's base_manager_name if there's one.
-            for parent in self.model.mro()[1:]:
-                if hasattr(parent, "_meta"):
-                    if parent._base_manager.name != "_base_manager":
-                        base_manager_name = parent._base_manager.name
-                    break
-
-        if base_manager_name:
-            try:
-                return self.managers_map[base_manager_name]
-            except KeyError:
-                raise ValueError(
-                    f"{self.object_name} has no manager named {base_manager_name!r}"
-                )
-
-        manager = Manager()
-        manager.name = "_base_manager"
-        manager.model = self.model
-        manager.auto_created = True
-        return manager
-
-    @cached_property
-    def default_manager(self):
-        default_manager_name = self.default_manager_name
-        if not default_manager_name and not self.local_managers:
-            # Get the first parent's default_manager_name if there's one.
-            for parent in self.model.mro()[1:]:
-                if hasattr(parent, "_meta"):
-                    default_manager_name = parent._meta.default_manager_name
-                    break
-
-        if default_manager_name:
-            try:
-                return self.managers_map[default_manager_name]
-            except KeyError:
-                raise ValueError(
-                    f"{self.object_name} has no manager named {default_manager_name!r}"
-                )
+    @property
+    def base_queryset(self):
+        """
+        The base queryset is used by Plain's internal operations like cascading
+        deletes, migrations, and related object lookups. It provides access to
+        all objects in the database without any filtering, ensuring Plain can
+        always see the complete dataset when performing framework operations.
+
+        Unlike user-defined querysets which may filter results (e.g. only active
+        objects), the base queryset must never filter out rows to prevent
+        incomplete results in related queries.
+        """
+        return QuerySet(model=self.model)
 
-        if self.managers:
-            return self.managers[0]
+    @property
+    def queryset(self):
+        if self.queryset_class:
+            return self.queryset_class(model=self.model)
+        return QuerySet(model=self.model)
 
     @cached_property
     def fields(self):