Merge Manager into QuerySet, except for related managers

Author: davegaeddert

plain-admin/plain/admin/views/models.py

@@ -2,7 +2,7 @@
 
 from plain import models
 from plain.exceptions import FieldError
-from plain.models import Manager, Q
+from plain.models import Q, QuerySet
 
 from .objects import (
     AdminCreateView,
@@ -35,8 +35,8 @@ def get_model_field(instance, field):
 
     attr = getattr(instance, field)
 
-    if isinstance(attr, Manager):
-        # Automatically get .all() of related managers
+    if isinstance(attr, QuerySet):
+        # Automatically get .all() of related querysets
         return attr.all()
 
     return attr

plain-cache/plain/cache/models.py

@@ -22,7 +22,7 @@ class CachedItem(models.Model):
     updated_at = models.DateTimeField(auto_now=True)
 
     class Meta:
-        manager_class = CachedItemQuerySet
+        queryset_class = CachedItemQuerySet
         indexes = [
             models.Index(fields=["expires_at"]),
         ]

plain-models/plain/models/README.md

@@ -9,7 +9,7 @@
 - [Fields](#fields)
 - [Validation](#validation)
 - [Indexes and constraints](#indexes-and-constraints)
-- [Managers](#managers)
+- [Custom QuerySets](#custom-querysets)
 - [Forms](#forms)
 - [Sharing fields across models](#sharing-fields-across-models)
 - [Installation](#installation)
@@ -85,7 +85,7 @@ Multiple backends are supported, including Postgres, MySQL, and SQLite.
 
 ## Querying
 
-Models come with a powerful query API through their [`Manager`](./manager.py#Manager) interface:
+Models come with a powerful query API through their [`QuerySet`](./query.py#QuerySet) interface:
 
 ```python
 # Get all users
@@ -211,28 +211,71 @@ class User(models.Model):
         ]
 ```
 
-## Managers
+## Custom QuerySets
 
-[`Manager`](./manager.py#Manager) objects provide the interface for querying models:
+With the Manager functionality now merged into QuerySet, you can customize [`QuerySet`](./query.py#QuerySet) classes to provide specialized query methods. There are several ways to use custom QuerySets:
+
+### Setting a default QuerySet for a model
+
+Use `Meta.queryset_class` to set a custom QuerySet that will be used by `Model.objects`:
+
+```python
+class PublishedQuerySet(models.QuerySet):
+    def published_only(self):
+        return self.filter(status="published")
+
+    def draft_only(self):
+        return self.filter(status="draft")
+
+@models.register_model
+class Article(models.Model):
+    title = models.CharField(max_length=200)
+    status = models.CharField(max_length=20)
+
+    class Meta:
+        queryset_class = PublishedQuerySet
+
+# Usage - all methods available on Article.objects
+all_articles = Article.objects.all()
+published_articles = Article.objects.published_only()
+draft_articles = Article.objects.draft_only()
+```
+
+### Using custom QuerySets without formal attachment
+
+You can also use custom QuerySets manually without setting them as the default:
 
 ```python
-class PublishedManager(models.Manager):
-    def get_queryset(self):
-        return super().get_queryset().filter(status="published")
+class SpecialQuerySet(models.QuerySet):
+    def special_filter(self):
+        return self.filter(special=True)
+
+# Create and use the QuerySet manually
+special_qs = SpecialQuerySet(model=Article)
+special_articles = special_qs.special_filter()
+```
+
+### Using classmethods for convenience
+
+For even cleaner API, add classmethods to your model:
 
+```python
+@models.register_model
 class Article(models.Model):
     title = models.CharField(max_length=200)
     status = models.CharField(max_length=20)
 
-    # Default manager
-    objects = models.Manager()
+    @classmethod
+    def published(cls):
+        return PublishedQuerySet(model=cls).published_only()
 
-    # Custom manager
-    published = PublishedManager()
+    @classmethod
+    def drafts(cls):
+        return PublishedQuerySet(model=cls).draft_only()
 
 # Usage
-all_articles = Article.objects.all()
-published_articles = Article.published.all()
+published_articles = Article.published()
+draft_articles = Article.drafts()
 ```
 
 ## Forms

plain-models/plain/models/__init__.py

@@ -59,7 +59,6 @@
 from .indexes import *  # NOQA
 from .indexes import __all__ as indexes_all
 from .lookups import Lookup, Transform
-from .manager import Manager
 from .query import Prefetch, QuerySet, prefetch_related_objects
 from .query_utils import FilteredRelation, Q
 from .registry import models_registry, register_model
@@ -108,7 +107,6 @@
     "JSONField",
     "Lookup",
     "Transform",
-    "Manager",
     "Prefetch",
     "Q",
     "QuerySet",

plain-models/plain/models/base.py

@@ -169,7 +169,7 @@ def _prepare(cls):
 
     @property
     def objects(cls):
-        return cls._meta.manager
+        return cls._meta.queryset
 
 
 class ModelStateFieldsCacheDescriptor:
@@ -422,9 +422,7 @@ def refresh_from_db(self, fields=None):
                     "are not allowed in fields."
                 )
 
-        db_instance_qs = self.__class__._meta.base_manager.get_queryset().filter(
-            id=self.id
-        )
+        db_instance_qs = self.__class__._meta.base_queryset.filter(id=self.id)
 
         # Use provided fields, if not set then reload all non-deferred fields.
         deferred_fields = self.get_deferred_fields()
@@ -607,7 +605,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 = meta.base_manager
+            base_qs = meta.base_queryset
             values = [
                 (
                     f,
@@ -631,7 +629,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(meta.base_manager, fields, returning_fields, raw)
+            results = self._do_insert(meta.base_queryset, fields, returning_fields, raw)
             if results:
                 for value, field in zip(results[0], returning_fields):
                     setattr(self, field.attname, value)

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._meta.base_manager.filter(predicate)
+        return related_model._meta.base_queryset.filter(predicate)
 
     def sort(self):
         sorted_models = []

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._meta.base_manager.filter(
+        qs = self.remote_field.model._meta.base_queryset.filter(
             **{self.remote_field.field_name: value}
         )
         qs = qs.complex_filter(self.get_limit_choices_to())