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

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

plain/models/otel.py

@@ -218,7 +218,19 @@ def _get_code_attributes():
 
         # Add full stack trace only in DEBUG mode (expensive)
         if settings.DEBUG:
-            attrs[CODE_STACKTRACE] = "".join(traceback.format_stack())
+            # Filter out internal frames from the stack trace
+            filtered_stack = []
+            for frame in stack:
+                filepath = frame.filename
+                if not filepath:
+                    continue
+                if "/plain/models/" in filepath:
+                    continue
+                if filepath.endswith("contextlib.py"):
+                    continue
+                filtered_stack.append(frame)
+
+            attrs[CODE_STACKTRACE] = "".join(traceback.format_list(filtered_stack))
 
         return attrs
 

plain/models/query.py

@@ -255,9 +255,8 @@ class FlatValuesListIterable(BaseIterable):
 class QuerySet:
     """Represent a lazy database lookup for a set of objects."""
 
-    def __init__(self, model=None, query=None, hints=None):
+    def __init__(self, *, model=None, query=None):
         self.model = model
-        self._hints = hints or {}
         self._query = query or sql.Query(self.model)
         self._result_cache = None
         self._sticky_filter = False
@@ -284,17 +283,6 @@ class QuerySet:
             self._iterable_class = ValuesIterable
         self._query = value
 
-    def as_manager(cls):
-        # Address the circular dependency between `Queryset` and `Manager`.
-        from plain.models.manager import Manager
-
-        manager = Manager.from_queryset(cls)()
-        manager._built_with_as_manager = True
-        return manager
-
-    as_manager.queryset_only = True
-    as_manager = classmethod(as_manager)
-
     ########################
     # PYTHON MAGIC METHODS #
     ########################
@@ -425,12 +413,12 @@ class QuerySet:
         query = (
             self
             if self.query.can_filter()
-            else self.model._base_manager.filter(id__in=self.values("id"))
+            else self.model._meta.base_queryset.filter(id__in=self.values("id"))
         )
         combined = query._chain()
         combined._merge_known_related_objects(other)
         if not other.query.can_filter():
-            other = other.model._base_manager.filter(id__in=other.values("id"))
+            other = other.model._meta.base_queryset.filter(id__in=other.values("id"))
         combined.query.combine(other.query, sql.OR)
         return combined
 
@@ -444,12 +432,12 @@ class QuerySet:
         query = (
             self
             if self.query.can_filter()
-            else self.model._base_manager.filter(id__in=self.values("id"))
+            else self.model._meta.base_queryset.filter(id__in=self.values("id"))
         )
         combined = query._chain()
         combined._merge_known_related_objects(other)
         if not other.query.can_filter():
-            other = other.model._base_manager.filter(id__in=other.values("id"))
+            other = other.model._meta.base_queryset.filter(id__in=other.values("id"))
         combined.query.combine(other.query, sql.XOR)
         return combined
 
@@ -957,8 +945,6 @@ class QuerySet:
         self._result_cache = None
         return deleted, _rows_count
 
-    delete.queryset_only = True
-
     def _raw_delete(self):
         """
         Delete objects found from the given queryset in single direct SQL
@@ -1027,8 +1013,6 @@ class QuerySet:
         self._result_cache = None
         return query.get_compiler().execute_sql(CURSOR)
 
-    _update.queryset_only = False
-
     def exists(self):
         """
         Return True if the QuerySet would have any results, False otherwise.
@@ -1201,7 +1185,7 @@ class QuerySet:
     def all(self):
         """
         Return a new QuerySet that is a copy of the current one. This allows a
-        QuerySet to proxy for a model manager in some cases.
+        QuerySet to proxy for a model queryset in some cases.
         """
         return self._chain()
 
@@ -1565,8 +1549,6 @@ class QuerySet:
         query.insert_values(fields, objs, raw=raw)
         return query.get_compiler().execute_sql(returning_fields)
 
-    _insert.queryset_only = False
-
     def _batched_insert(
         self,
         objs,
@@ -1622,7 +1604,6 @@ class QuerySet:
         c = self.__class__(
             model=self.model,
             query=self.query.chain(),
-            hints=self._hints,
         )
         c._sticky_filter = self._sticky_filter
         c._for_write = self._for_write
@@ -1678,15 +1659,6 @@ class QuerySet:
         query = self.query.resolve_expression(*args, **kwargs)
         return query
 
-    resolve_expression.queryset_only = True
-
-    def _add_hints(self, **hints):
-        """
-        Update hinting information for use by routers. Add new key/values or
-        overwrite existing key/values.
-        """
-        self._hints.update(hints)
-
     def _has_filters(self):
         """
         Check if this QuerySet has any filtering going on. This isn't
@@ -1747,11 +1719,9 @@ class RawQuerySet:
         query=None,
         params=(),
         translations=None,
-        hints=None,
     ):
         self.raw_query = raw_query
         self.model = model
-        self._hints = hints or {}
         self.query = query or sql.RawQuery(sql=raw_query, params=params)
         self.params = params
         self.translations = translations or {}
@@ -1797,7 +1767,6 @@ class RawQuerySet:
             query=self.query,
             params=self.params,
             translations=self.translations,
-            hints=self._hints,
         )
         c._prefetch_related_lookups = self._prefetch_related_lookups[:]
         return c
@@ -2180,7 +2149,7 @@ def prefetch_one_level(instances, prefetcher, lookup, level):
         for additional_lookup in getattr(rel_qs, "_prefetch_related_lookups", ())
     ]
     if additional_lookups:
-        # Don't need to clone because the manager should have given us a fresh
+        # Don't need to clone because the queryset should have given us a fresh
         # instance, so we access an internal instead of using public interface
         # for performance reasons.
         rel_qs._prefetch_related_lookups = ()
@@ -2231,11 +2200,11 @@ def prefetch_one_level(instances, prefetcher, lookup, level):
             if as_attr:
                 setattr(obj, to_attr, vals)
             else:
-                manager = getattr(obj, to_attr)
+                queryset = getattr(obj, to_attr)
                 if leaf and lookup.queryset is not None:
-                    qs = manager._apply_rel_filters(lookup.queryset)
+                    qs = queryset._apply_rel_filters(lookup.queryset)
                 else:
-                    qs = manager.get_queryset()
+                    qs = queryset.__class__(model=queryset.model)
                 qs._result_cache = vals
                 # We don't want the individual qs doing prefetch_related now,
                 # since we have merged this into the current work.

plain/models/query_utils.py

@@ -361,7 +361,7 @@ def check_rel_lookup_compatibility(model, target_opts, field):
     # model is ok, too. Consider the case:
     # class Restaurant(models.Model):
     #     place = OneToOneField(Place, primary_key=True):
-    # Restaurant.objects.filter(id__in=Restaurant.objects.all()).
+    # Restaurant.query.filter(id__in=Restaurant.query.all()).
     # If we didn't have the primary key check, then id__in (== place__in) would
     # give Place's opts as the target opts, but Restaurant isn't compatible
     # with that. This logic applies only to primary keys, as when doing __in=qs,

plain/models/sql/compiler.py

@@ -98,20 +98,20 @@ class SQLCompiler:
         then it is correct".
         """
         # Some examples:
-        #     SomeModel.objects.annotate(Count('somecol'))
+        #     SomeModel.query.annotate(Count('somecol'))
         #     GROUP BY: all fields of the model
         #
-        #    SomeModel.objects.values('name').annotate(Count('somecol'))
+        #    SomeModel.query.values('name').annotate(Count('somecol'))
         #    GROUP BY: name
         #
-        #    SomeModel.objects.annotate(Count('somecol')).values('name')
+        #    SomeModel.query.annotate(Count('somecol')).values('name')
         #    GROUP BY: all cols of the model
         #
-        #    SomeModel.objects.values('name', 'id')
+        #    SomeModel.query.values('name', 'id')
         #    .annotate(Count('somecol')).values('id')
         #    GROUP BY: name, id
         #
-        #    SomeModel.objects.values('name').annotate(Count('somecol')).values('id')
+        #    SomeModel.query.values('name').annotate(Count('somecol')).values('id')
         #    GROUP BY: name, id
         #
         # In fact, the self.query.group_by is the minimal set to GROUP BY. It

plain/models/sql/query.py

@@ -1174,9 +1174,9 @@ class Query(BaseExpression):
         """Check the type of object passed to query relations."""
         if field.is_relation:
             # Check that the field and the queryset use the same model in a
-            # query like .filter(author=Author.objects.all()). For example, the
+            # query like .filter(author=Author.query.all()). For example, the
             # opts would be Author's (from the author field) and value.model
-            # would be Author.objects.all() queryset's .model (Author also).
+            # would be Author.query.all() queryset's .model (Author also).
             # The field is the related field on the lhs side.
             if (
                 isinstance(value, Query)

{plain_models-0.41.0.dist-info → plain_models-0.42.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.models
-Version: 0.41.0
+Version: 0.42.0
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE
@@ -20,7 +20,7 @@ Description-Content-Type: text/markdown
 - [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)
@@ -54,7 +54,7 @@ from .models import User
 
 
 # Create a new user
-user = User.objects.create(
+user = User.query.create(
     email="test@example.com",
     password="password",
 )
@@ -67,7 +67,7 @@ user.save()
 user.delete()
 
 # Query for users
-admin_users = User.objects.filter(is_admin=True)
+admin_users = User.query.filter(is_admin=True)
 ```
 
 ## Database connection
@@ -96,30 +96,30 @@ 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
-all_users = User.objects.all()
+all_users = User.query.all()
 
 # Filter users
-admin_users = User.objects.filter(is_admin=True)
-recent_users = User.objects.filter(created_at__gte=datetime.now() - timedelta(days=7))
+admin_users = User.query.filter(is_admin=True)
+recent_users = User.query.filter(created_at__gte=datetime.now() - timedelta(days=7))
 
 # Get a single user
-user = User.objects.get(email="test@example.com")
+user = User.query.get(email="test@example.com")
 
 # Complex queries with Q objects
 from plain.models import Q
-users = User.objects.filter(
+users = User.query.filter(
     Q(is_admin=True) | Q(email__endswith="@example.com")
 )
 
 # Ordering
-users = User.objects.order_by("-created_at")
+users = User.query.order_by("-created_at")
 
 # Limiting results
-first_10_users = User.objects.all()[:10]
+first_10_users = User.query.all()[:10]
 ```
 
 For more advanced querying options, see the [`QuerySet`](./query.py#QuerySet) class.
@@ -222,28 +222,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.query`:
+
+```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.query.all()
+published_articles = Article.query.published_only()
+draft_articles = Article.query.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