plain.models 0.48.0__py3-none-any.whl → 0.49.0__py3-none-any.whl

plain/models/CHANGELOG.md

@@ -1,5 +1,21 @@
 # plain-models changelog
 
+## [0.49.0](https://github.com/dropseed/plain/releases/plain-models@0.49.0) (2025-09-29)
+
+### What's changed
+
+- Model exceptions (`FieldDoesNotExist`, `FieldError`, `ObjectDoesNotExist`, `MultipleObjectsReturned`, `EmptyResultSet`, `FullResultSet`) have been moved from `plain.exceptions` to `plain.models.exceptions` ([1c02564](https://github.com/dropseed/plain/commit/1c02564561))
+- The `get_FOO_display()` methods for fields with choices have been replaced with a single `get_field_display(field_name)` method ([e796e71](https://github.com/dropseed/plain/commit/e796e71e02))
+- The `get_next_by_*` and `get_previous_by_*` methods for date fields have been removed ([3a5b8a8](https://github.com/dropseed/plain/commit/3a5b8a89d1))
+- The `id` primary key field is now defined directly on the Model base class instead of being added dynamically via Options ([e164dc7](https://github.com/dropseed/plain/commit/e164dc7982))
+- Model `DoesNotExist` and `MultipleObjectsReturned` exceptions now use descriptors for better performance ([8f54ea3](https://github.com/dropseed/plain/commit/8f54ea3a62))
+
+### Upgrade instructions
+
+- Update imports for model exceptions from `plain.exceptions` to `plain.models.exceptions` (e.g., `from plain.exceptions import ObjectDoesNotExist` becomes `from plain.models.exceptions import ObjectDoesNotExist`)
+- Replace any usage of `instance.get_FOO_display()` with `instance.get_field_display("FOO")` where FOO is the field name
+- Remove any usage of `get_next_by_*` and `get_previous_by_*` methods - use QuerySet ordering instead (e.g., `Model.query.filter(date__gt=obj.date).order_by("date").first()`)
+
 ## [0.48.0](https://github.com/dropseed/plain/releases/plain-models@0.48.0) (2025-09-26)
 
 ### What's changed

plain/models/__init__.py

@@ -1,5 +1,3 @@
-from plain.exceptions import ObjectDoesNotExist
-
 from . import (
     preflight,  # noqa
 )
@@ -78,7 +76,6 @@ from .fields.reverse_related import (  # isort:skip
 
 __all__ = aggregates_all + constraints_all + enums_all + fields_all + indexes_all
 __all__ += [
-    "ObjectDoesNotExist",
     "CASCADE",
     "DO_NOTHING",
     "PROTECT",

plain/models/aggregates.py

@@ -2,7 +2,7 @@
 Classes to represent the definitions of aggregate functions.
 """
 
-from plain.exceptions import FieldError, FullResultSet
+from plain.models.exceptions import FieldError, FullResultSet
 from plain.models.expressions import Case, Func, Star, Value, When
 from plain.models.fields import IntegerField
 from plain.models.functions.comparison import Coalesce

plain/models/backends/mysql/compiler.py

@@ -1,4 +1,4 @@
-from plain.exceptions import FieldError, FullResultSet
+from plain.models.exceptions import FieldError, FullResultSet
 from plain.models.expressions import Col
 from plain.models.sql import compiler
 

plain/models/backends/sqlite3/operations.py

@@ -4,10 +4,10 @@ import uuid
 from functools import cached_property, lru_cache
 
 from plain import models
-from plain.exceptions import FieldError
 from plain.models.backends.base.operations import BaseDatabaseOperations
 from plain.models.constants import OnConflict
 from plain.models.db import DatabaseError, NotSupportedError
+from plain.models.exceptions import FieldError
 from plain.models.expressions import Col
 from plain.utils import timezone
 from plain.utils.dateparse import parse_date, parse_datetime, parse_time

plain/models/base.py

@@ -4,13 +4,7 @@ import warnings
 from itertools import chain
 
 import plain.runtime
-from plain.exceptions import (
-    NON_FIELD_ERRORS,
-    FieldDoesNotExist,
-    MultipleObjectsReturned,
-    ObjectDoesNotExist,
-    ValidationError,
-)
+from plain.exceptions import NON_FIELD_ERRORS, ValidationError
 from plain.models import models_registry, transaction
 from plain.models.constants import LOOKUP_SEP
 from plain.models.constraints import CheckConstraint, UniqueConstraint
@@ -20,8 +14,13 @@ from plain.models.db import (
     db_connection,
 )
 from plain.models.deletion import Collector
+from plain.models.exceptions import (
+    DoesNotExistDescriptor,
+    FieldDoesNotExist,
+    MultipleObjectsReturnedDescriptor,
+)
 from plain.models.expressions import RawSQL, Value
-from plain.models.fields import NOT_PROVIDED
+from plain.models.fields import NOT_PROVIDED, PrimaryKeyField
 from plain.models.fields.reverse_related import ForeignObjectRel
 from plain.models.options import Options
 from plain.models.query import F, Q, QuerySet
@@ -42,11 +41,6 @@ class Deferred:
 DEFERRED = Deferred()
 
 
-def _has_contribute_to_class(value):
-    # Only call contribute_to_class() if it's bound.
-    return not inspect.isclass(value) and hasattr(value, "contribute_to_class")
-
-
 class ModelBase(type):
     """Metaclass for all models."""
 
@@ -71,7 +65,6 @@ class ModelBase(type):
         new_class = super().__new__(cls, name, bases, attrs, **kwargs)
 
         new_class._setup_meta()
-        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 and meta options.
@@ -79,7 +72,9 @@ class ModelBase(type):
             if attr_name.startswith("_"):
                 continue
 
-            if _has_contribute_to_class(attr_value):
+            if not inspect.isclass(attr_value) and hasattr(
+                attr_value, "contribute_to_class"
+            ):
                 if attr_name not in attrs:
                     # If the field came from an inherited class/mixin,
                     # we need to make a copy of it to avoid altering the
@@ -87,25 +82,17 @@ class ModelBase(type):
                     field = copy.deepcopy(attr_value)
                 else:
                     field = attr_value
-                new_class.add_to_class(attr_name, field)
-
-        new_class._meta.concrete_model = new_class
-
-        # Copy indexes so that index names are unique when models extend another class.
-        new_class._meta.indexes = [
-            copy.deepcopy(idx) for idx in new_class._meta.indexes
-        ]
+                field.contribute_to_class(new_class, attr_name)
 
-        new_class._prepare()
+        # Set the name of _meta.indexes. This can't be done in
+        # Options.contribute_to_class() because fields haven't been added to
+        # the model at that point.
+        for index in new_class._meta.indexes:
+            if not index.name:
+                index.set_name_with_model(new_class)
 
         return new_class
 
-    def add_to_class(cls, name, value):
-        if _has_contribute_to_class(value):
-            value.contribute_to_class(cls, name)
-        else:
-            setattr(cls, name, value)
-
     def _setup_meta(cls):
         name = cls.__name__
         module = cls.__module__
@@ -127,45 +114,7 @@ class ModelBase(type):
             else:
                 package_label = package_config.package_label
 
-        cls.add_to_class("_meta", Options(meta, package_label))
-
-    def _add_exceptions(cls):
-        cls.DoesNotExist = type(
-            "DoesNotExist",
-            (ObjectDoesNotExist,),
-            {
-                "__module__": cls.__module__,
-                "__qualname__": f"{cls.__qualname__}.DoesNotExist",
-            },
-        )
-
-        cls.MultipleObjectsReturned = type(
-            "MultipleObjectsReturned",
-            (MultipleObjectsReturned,),
-            {
-                "__module__": cls.__module__,
-                "__qualname__": f"{cls.__qualname__}.MultipleObjectsReturned",
-            },
-        )
-
-    def _prepare(cls):
-        """Create some methods once self._meta has been populated."""
-        opts = cls._meta
-        opts._prepare(cls)
-
-        # Give the class a docstring -- its definition.
-        if cls.__doc__ is None:
-            cls.__doc__ = "{}({})".format(
-                cls.__name__,
-                ", ".join(f.name for f in opts.fields),
-            )
-
-        # Set the name of _meta.indexes. This can't be done in
-        # Options.contribute_to_class() because fields haven't been added to
-        # the model at that point.
-        for index in cls._meta.indexes:
-            if not index.name:
-                index.set_name_with_model(cls)
+        Options(meta, package_label).contribute_to_class(cls, "_meta")
 
     @property
     def query(cls) -> QuerySet:
@@ -194,8 +143,13 @@ class ModelState:
 
 class Model(metaclass=ModelBase):
     _meta: Options
-    DoesNotExist: type[ObjectDoesNotExist]
-    MultipleObjectsReturned: type[MultipleObjectsReturned]
+
+    # Use descriptors for exception classes instead of metaclass generation
+    DoesNotExist = DoesNotExistDescriptor()
+    MultipleObjectsReturned = MultipleObjectsReturnedDescriptor()
+
+    # Every model gets an automatic id field
+    id = PrimaryKeyField()
 
     def __init__(self, *args, **kwargs):
         # Alias some things as locals to avoid repeat global lookups
@@ -327,7 +281,7 @@ class Model(metaclass=ModelBase):
     def __eq__(self, other):
         if not isinstance(other, Model):
             return NotImplemented
-        if self._meta.concrete_model != other._meta.concrete_model:
+        if self.__class__ != other.__class__:
             return False
         my_id = self.id
         if my_id is None:
@@ -711,34 +665,20 @@ class Model(metaclass=ModelBase):
         collector.collect([self])
         return collector.delete()
 
-    def _get_FIELD_display(self, field):
+    def get_field_display(self, field):
+        """Get the display value for a field, especially useful for fields with choices."""
         value = getattr(self, field.attname)
+
+        # If field has no choices, just return the value as string
+        if not hasattr(field, "flatchoices") or not field.flatchoices:
+            return force_str(value, strings_only=True)
+
+        # For fields with choices, look up the display value
         choices_dict = dict(make_hashable(field.flatchoices))
-        # force_str() to coerce lazy strings.
         return force_str(
             choices_dict.get(make_hashable(value), value), strings_only=True
         )
 
-    def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
-        if not self.id:
-            raise ValueError("get_next/get_previous cannot be used on unsaved objects.")
-        op = "gt" if is_next else "lt"
-        order = "" if is_next else "-"
-        param = getattr(self, field.attname)
-        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__.query.filter(**kwargs)
-            .filter(q)
-            .order_by(f"{order}{field.name}", f"{order}id")
-        )
-        try:
-            return qs[0]
-        except IndexError:
-            raise self.DoesNotExist(
-                f"{self.__class__._meta.object_name} matching query does not exist."
-            )
-
     def _get_field_value_map(self, meta, exclude=None):
         if exclude is None:
             exclude = set()

plain/models/constraints.py

@@ -1,7 +1,8 @@
 from enum import Enum
 from types import NoneType
 
-from plain.exceptions import FieldError, ValidationError
+from plain.exceptions import ValidationError
+from plain.models.exceptions import FieldError
 from plain.models.expressions import Exists, ExpressionList, F, OrderBy
 from plain.models.indexes import IndexExpression
 from plain.models.lookups import Exact

plain/models/deletion.py

@@ -139,9 +139,7 @@ class Collector:
     def add_dependency(self, model, dependency, reverse_dependency=False):
         if reverse_dependency:
             model, dependency = dependency, model
-        self.dependencies[model._meta.concrete_model].add(
-            dependency._meta.concrete_model
-        )
+        self.dependencies[model].add(dependency)
         self.data.setdefault(dependency, self.data.default_factory())
 
     def add_field_update(self, field, value, objs):
@@ -363,10 +361,10 @@ class Collector:
             for model in models:
                 if model in sorted_models:
                     continue
-                dependencies = self.dependencies.get(model._meta.concrete_model)
+                dependencies = self.dependencies.get(model)
                 if not (dependencies and dependencies.difference(concrete_models)):
                     sorted_models.append(model)
-                    concrete_models.add(model._meta.concrete_model)
+                    concrete_models.add(model)
                     found = True
             if not found:
                 return

plain/models/exceptions.py

@@ -1,3 +1,111 @@
+from typing import Any
+
+# MARK: Database Query Exceptions
+
+
+class EmptyResultSet(Exception):
+    """A database query predicate is impossible."""
+
+    pass
+
+
+class FullResultSet(Exception):
+    """A database query predicate is matches everything."""
+
+    pass
+
+
+# MARK: Model and Field Errors
+
+
+class FieldDoesNotExist(Exception):
+    """The requested model field does not exist"""
+
+    pass
+
+
+class FieldError(Exception):
+    """Some kind of problem with a model field."""
+
+    pass
+
+
+class ObjectDoesNotExist(Exception):
+    """The requested object does not exist"""
+
+    pass
+
+
+class MultipleObjectsReturned(Exception):
+    """The query returned multiple objects when only one was expected."""
+
+    pass
+
+
+# MARK: Model Exception Descriptors
+
+
+class DoesNotExistDescriptor:
+    """Descriptor that creates a unique DoesNotExist exception class per model."""
+
+    def __init__(self) -> None:
+        self._exceptions_by_class: dict[type, type[ObjectDoesNotExist]] = {}
+
+    def __get__(self, instance: Any, owner: type | None) -> type[ObjectDoesNotExist]:
+        if owner is None:
+            return ObjectDoesNotExist  # Return base class as fallback
+
+        # Create a unique exception class for this model if we haven't already
+        if owner not in self._exceptions_by_class:
+            exc_class = type(
+                "DoesNotExist",
+                (ObjectDoesNotExist,),
+                {
+                    "__module__": owner.__module__,
+                    "__qualname__": f"{owner.__qualname__}.DoesNotExist",
+                },
+            )
+            self._exceptions_by_class[owner] = exc_class
+
+        return self._exceptions_by_class[owner]
+
+    def __set__(self, instance: Any, value: Any) -> None:
+        raise AttributeError("Cannot set DoesNotExist")
+
+
+class MultipleObjectsReturnedDescriptor:
+    """Descriptor that creates a unique MultipleObjectsReturned exception class per model."""
+
+    def __init__(self) -> None:
+        self._exceptions_by_class: dict[type, type[MultipleObjectsReturned]] = {}
+
+    def __get__(
+        self, instance: Any, owner: type | None
+    ) -> type[MultipleObjectsReturned]:
+        if owner is None:
+            return MultipleObjectsReturned  # Return base class as fallback
+
+        # Create a unique exception class for this model if we haven't already
+        if owner not in self._exceptions_by_class:
+            exc_class = type(
+                "MultipleObjectsReturned",
+                (MultipleObjectsReturned,),
+                {
+                    "__module__": owner.__module__,
+                    "__qualname__": f"{owner.__qualname__}.MultipleObjectsReturned",
+                },
+            )
+            self._exceptions_by_class[owner] = exc_class
+
+        return self._exceptions_by_class[owner]
+
+    def __set__(self, instance: Any, value: Any) -> None:
+        raise AttributeError("Cannot set MultipleObjectsReturned")
+
+
+# MARK: Database Exceptions (PEP-249)
+
+
 class Error(Exception):
     pass
 

plain/models/expressions.py

@@ -8,7 +8,6 @@ from functools import cached_property
 from types import NoneType
 from uuid import UUID
 
-from plain.exceptions import EmptyResultSet, FieldError, FullResultSet
 from plain.models import fields
 from plain.models.constants import LOOKUP_SEP
 from plain.models.db import (
@@ -16,6 +15,7 @@ from plain.models.db import (
     NotSupportedError,
     db_connection,
 )
+from plain.models.exceptions import EmptyResultSet, FieldError, FullResultSet
 from plain.models.query_utils import Q
 from plain.utils.deconstruct import deconstructible
 from plain.utils.hashable import make_hashable

plain/models/fields/__init__.py

@@ -7,7 +7,7 @@ import operator
 import uuid
 import warnings
 from base64 import b64decode, b64encode
-from functools import cached_property, partialmethod, total_ordering
+from functools import cached_property, total_ordering
 
 from plain import exceptions, validators
 from plain.models.constants import LOOKUP_SEP
@@ -759,29 +759,15 @@ class Field(RegisterLookupMixin):
         self.attname, self.column = self.get_attname_column()
         self.concrete = self.column is not None
 
-    def contribute_to_class(self, cls, name, private_only=False):
+    def contribute_to_class(self, cls, name):
         """
         Register the field with the model class it belongs to.
-
-        If private_only is True, create a separate instance of this field
-        for every subclass of cls, even if cls is not an abstract model.
         """
         self.set_attributes_from_name(name)
         self.model = cls
-        cls._meta.add_field(self, private=private_only)
+        cls._meta.add_field(self)
         if self.column:
             setattr(cls, self.attname, self.descriptor_class(self))
-        if self.choices is not None:
-            # Don't override a get_FOO_display() method defined explicitly on
-            # this class, but don't check methods derived from inheritance, to
-            # allow overriding inherited choices. For more complex inheritance
-            # structures users should override contribute_to_class().
-            if f"get_{self.name}_display" not in cls.__dict__:
-                setattr(
-                    cls,
-                    f"get_{self.name}_display",
-                    partialmethod(cls._get_FIELD_display, field=self),
-                )
 
     def get_attname(self):
         return self.name
@@ -1200,24 +1186,6 @@ class DateField(DateTimeCheckMixin, Field):
         else:
             return super().pre_save(model_instance, add)
 
-    def contribute_to_class(self, cls, name, **kwargs):
-        super().contribute_to_class(cls, name, **kwargs)
-        if not self.allow_null:
-            setattr(
-                cls,
-                f"get_next_by_{self.name}",
-                partialmethod(
-                    cls._get_next_or_previous_by_FIELD, field=self, is_next=True
-                ),
-            )
-            setattr(
-                cls,
-                f"get_previous_by_{self.name}",
-                partialmethod(
-                    cls._get_next_or_previous_by_FIELD, field=self, is_next=False
-                ),
-            )
-
     def get_prep_value(self, value):
         value = super().get_prep_value(value)
         return self.to_python(value)
@@ -1319,9 +1287,6 @@ class DateTimeField(DateField):
         else:
             return super().pre_save(model_instance, add)
 
-    # contribute_to_class is inherited from DateField, it registers
-    # get_next_by_FOO and get_prev_by_FOO
-
     def get_prep_value(self, value):
         value = super().get_prep_value(value)
         value = self.to_python(value)
@@ -2145,9 +2110,6 @@ class PrimaryKeyField(BigIntegerField):
             value = connection.ops.validate_autopk_value(value)
         return value
 
-    def contribute_to_class(self, cls, name, **kwargs):
-        super().contribute_to_class(cls, name, **kwargs)
-
     def get_internal_type(self):
         return "PrimaryKeyField"
 

plain/models/fields/related.py

@@ -3,6 +3,7 @@ from functools import cached_property, partial
 from plain import exceptions
 from plain.models.constants import LOOKUP_SEP
 from plain.models.deletion import SET_DEFAULT, SET_NULL
+from plain.models.exceptions import FieldDoesNotExist, FieldError
 from plain.models.query_utils import PathInfo, Q
 from plain.models.utils import make_model_tuple
 from plain.preflight import PreflightResult
@@ -303,8 +304,8 @@ class RelatedField(FieldCacheMixin, Field):
         # columns from another table.
         return None
 
-    def contribute_to_class(self, cls, name, private_only=False, **kwargs):
-        super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
+    def contribute_to_class(self, cls, name):
+        super().contribute_to_class(cls, name)
 
         self.opts = cls._meta
 
@@ -407,7 +408,7 @@ class RelatedField(FieldCacheMixin, Field):
         """
         target_fields = self.path_infos[-1].target_fields
         if len(target_fields) > 1:
-            raise exceptions.FieldError(
+            raise FieldError(
                 "The relation has multiple target fields, but only single target field "
                 "was asked for"
             )
@@ -582,15 +583,15 @@ class ForeignKey(RelatedField):
     def reverse_path_infos(self):
         return self.get_reverse_path_info()
 
-    def contribute_to_class(self, cls, name, private_only=False, **kwargs):
-        super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
+    def contribute_to_class(self, cls, name):
+        super().contribute_to_class(cls, name)
         setattr(cls, self.name, self.forward_related_accessor_class(self))
 
     def contribute_to_related_class(self, cls, related):
         # Internal FK's - i.e., those with a related name ending with '+'
         if not self.remote_field.is_hidden():
             setattr(
-                cls._meta.concrete_model,
+                cls,
                 related.get_accessor_name(),
                 self.related_accessor_class(related),
             )
@@ -696,13 +697,10 @@ class ForeignKey(RelatedField):
         related_fields = [(from_field, to_field)]
 
         for from_field, to_field in related_fields:
-            if (
-                to_field
-                and to_field.model != self.remote_field.model._meta.concrete_model
-            ):
-                raise exceptions.FieldError(
+            if to_field and to_field.model != self.remote_field.model:
+                raise FieldError(
                     f"'{self.model._meta.label}.{self.name}' refers to field '{to_field.name}' which is not local to model "
-                    f"'{self.remote_field.model._meta.concrete_model._meta.label}'."
+                    f"'{self.remote_field.model._meta.label}'."
                 )
         return related_fields
 
@@ -1075,7 +1073,7 @@ class ManyToManyField(RelatedField):
 
                     try:
                         field = through._meta.get_field(field_name)
-                    except exceptions.FieldDoesNotExist:
+                    except FieldDoesNotExist:
                         errors.append(
                             PreflightResult(
                                 fix=f"The intermediary model '{qualified_model_name}' has no field '{field_name}'. {fix}",
@@ -1109,13 +1107,8 @@ class ManyToManyField(RelatedField):
         }
         m2m_db_table = self.m2m_db_table()
         model = registered_tables.get(m2m_db_table)
-        # The second condition allows multiple m2m relations on a model if
-        # some point to a through model that proxies another through model.
-        if (
-            model
-            and model._meta.concrete_model
-            != self.remote_field.through._meta.concrete_model
-        ):
+        # Check if there's already a m2m field using the same through model.
+        if model and model != self.remote_field.through:
             clashing_obj = model._meta.label
             return [
                 PreflightResult(
@@ -1245,8 +1238,8 @@ class ManyToManyField(RelatedField):
                     break
         return getattr(self, cache_attr)
 
-    def contribute_to_class(self, cls, name, **kwargs):
-        super().contribute_to_class(cls, name, **kwargs)
+    def contribute_to_class(self, cls, name):
+        super().contribute_to_class(cls, name)
 
         def resolve_through_model(_, model, field):
             field.remote_field.through = model

plain/models/fields/related_descriptors.py

@@ -208,9 +208,7 @@ class ForwardManyToOneDescriptor:
             value = value if value else None
 
         # An object must be an instance of the related class.
-        if value is not None and not isinstance(
-            value, self.field.remote_field.model._meta.concrete_model
-        ):
+        if value is not None and not isinstance(value, self.field.remote_field.model):
             raise ValueError(
                 f'Cannot assign "{value!r}": "{instance._meta.object_name}.{self.field.name}" must be a "{self.field.remote_field.model._meta.object_name}" instance.'
             )

plain/models/fields/related_managers.py

@@ -80,7 +80,7 @@ class ReverseManyToOneManager(BaseRelatedManager):
         """
         Filter the queryset for the instance this manager is bound to.
         """
-        from plain.exceptions import FieldError
+        from plain.models.exceptions import FieldError
 
         queryset._defer_next_filter = True
         queryset = queryset.filter(**self.core_filters)

plain/models/fields/reverse_related.py

@@ -11,7 +11,7 @@ they're the closest concept currently available.
 
 from functools import cached_property
 
-from plain import exceptions
+from plain.models.exceptions import FieldDoesNotExist, FieldError
 from plain.utils.hashable import make_hashable
 
 from . import BLANK_CHOICE_DASH
@@ -79,9 +79,7 @@ class ForeignObjectRel(FieldCacheMixin):
         """
         target_fields = self.path_infos[-1].target_fields
         if len(target_fields) > 1:
-            raise exceptions.FieldError(
-                "Can't use target_field for multicolumn relations."
-            )
+            raise FieldError("Can't use target_field for multicolumn relations.")
         return target_fields[0]
 
     @cached_property
@@ -274,7 +272,7 @@ class ManyToOneRel(ForeignObjectRel):
         """
         field = self.model._meta.get_field("id")
         if not field.concrete:
-            raise exceptions.FieldDoesNotExist("No related field named 'id'")
+            raise FieldDoesNotExist("No related field named 'id'")
         return field
 
     def set_field_name(self):

plain/models/forms.py

@@ -7,13 +7,13 @@ from itertools import chain
 
 from plain.exceptions import (
     NON_FIELD_ERRORS,
-    FieldError,
     ImproperlyConfigured,
     ValidationError,
 )
 from plain.forms import fields
 from plain.forms.fields import ChoiceField, Field
 from plain.forms.forms import BaseForm, DeclarativeFieldsMetaclass
+from plain.models.exceptions import FieldError
 
 __all__ = (
     "ModelForm",

plain/models/lookups.py

@@ -2,7 +2,7 @@ import itertools
 import math
 from functools import cached_property
 
-from plain.exceptions import EmptyResultSet, FullResultSet
+from plain.models.exceptions import EmptyResultSet, FullResultSet
 from plain.models.expressions import Expression, Func, Value
 from plain.models.fields import (
     BooleanField,

plain/models/migrations/state.py

@@ -4,7 +4,7 @@ from contextlib import contextmanager
 from functools import cached_property, partial
 
 from plain import models
-from plain.exceptions import FieldDoesNotExist
+from plain.models.exceptions import FieldDoesNotExist
 from plain.models.fields import NOT_PROVIDED
 from plain.models.fields.related import RECURSIVE_RELATIONSHIP_CONSTANT
 from plain.models.migrations.utils import field_is_referenced, get_references

plain/models/options.py

@@ -3,11 +3,10 @@ import inspect
 from collections import defaultdict
 from functools import cached_property
 
-from plain.exceptions import FieldDoesNotExist
 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.exceptions import FieldDoesNotExist
 from plain.models.query import QuerySet
 from plain.utils.datastructures import ImmutableList
 
@@ -70,11 +69,6 @@ class Options:
         self.required_db_vendor = None
         self.meta = meta
 
-        # For any non-abstract class, the concrete class is the model
-        # in the end of the proxy_for_model chain. In particular, for
-        # concrete models, the concrete_model is always the class itself.
-        self.concrete_model = None
-
         # List of all lookups defined in ForeignKey 'limit_choices_to' options
         # from *other* models. Needed for some admin checks. Internal use only.
         self.related_fkey_lookups = []
@@ -156,11 +150,7 @@ class Options:
             new_objs.append(obj)
         return new_objs
 
-    def _prepare(self, model):
-        if not any(f.name == "id" for f in self.local_fields):
-            model.add_to_class("id", PrimaryKeyField())
-
-    def add_field(self, field, private=False):
+    def add_field(self, field):
         # Insert the given field in the order in which it was created, using
         # the "creation_counter" attribute of the field.
         # Move many-to-many related fields from self.fields into
@@ -417,7 +407,7 @@ class Options:
             )
             for f in fields_with_relations:
                 if not isinstance(f.remote_field.model, str):
-                    remote_label = f.remote_field.model._meta.concrete_model._meta.label
+                    remote_label = f.remote_field.model._meta.label
                     related_objects_graph[remote_label].append(f)
 
         for model in all_models:
@@ -426,9 +416,7 @@ class Options:
             # __dict__ takes precedence over a data descriptor (such as
             # @cached_property). This means that the _meta._relation_tree is
             # only called if related_objects is not in __dict__.
-            related_objects = related_objects_graph[
-                model._meta.concrete_model._meta.label
-            ]
+            related_objects = related_objects_graph[model._meta.label]
             model._meta.__dict__["_relation_tree"] = related_objects
         # It seems it is possible that self is not in all_models, so guard
         # against that with default for get().

plain/models/query.py

@@ -9,7 +9,6 @@ from functools import cached_property
 from itertools import chain, islice
 
 import plain.runtime
-from plain import exceptions
 from plain.exceptions import ValidationError
 from plain.models import (
     sql,
@@ -22,6 +21,11 @@ from plain.models.db import (
     NotSupportedError,
     db_connection,
 )
+from plain.models.exceptions import (
+    FieldDoesNotExist,
+    FieldError,
+    ObjectDoesNotExist,
+)
 from plain.models.expressions import Case, F, Value, When
 from plain.models.fields import (
     DateField,
@@ -129,9 +133,7 @@ class RawModelIterable(BaseIterable):
             ) = self.queryset.resolve_model_init_order()
             model_cls = self.queryset.model
             if "id" not in model_init_names:
-                raise exceptions.FieldDoesNotExist(
-                    "Raw query must include the primary key"
-                )
+                raise FieldDoesNotExist("Raw query must include the primary key")
             fields = [self.queryset.model_fields.get(c) for c in self.queryset.columns]
             converters = compiler.get_converters(
                 [f.get_col(f.model._meta.db_table) if f else None for f in fields]
@@ -850,12 +852,12 @@ class QuerySet:
         for param in params:
             try:
                 self.model._meta.get_field(param)
-            except exceptions.FieldDoesNotExist:
+            except FieldDoesNotExist:
                 # It's okay to use a model's property if it has a setter.
                 if not (param in property_names and getattr(self.model, param).fset):
                     invalid_params.append(param)
         if invalid_params:
-            raise exceptions.FieldError(
+            raise FieldError(
                 "Invalid field name(s) for model {}: '{}'.".format(
                     self.model._meta.object_name,
                     "', '".join(sorted(invalid_params)),
@@ -982,7 +984,7 @@ class QuerySet:
                 descending = True
             if annotation := query.annotations.get(alias):
                 if getattr(annotation, "contains_aggregate", False):
-                    raise exceptions.FieldError(
+                    raise FieldError(
                         f"Cannot update when ordering by an aggregate: {annotation}"
                     )
                 if descending:
@@ -1034,7 +1036,7 @@ class QuerySet:
                 "Cannot call QuerySet.contains() after .values() or .values_list()."
             )
         try:
-            if obj._meta.concrete_model != self.model._meta.concrete_model:
+            if obj.__class__ != self.model:
                 return False
         except AttributeError:
             raise TypeError("'obj' must be a model instance.")
@@ -2039,7 +2041,7 @@ def prefetch_related_objects(model_instances, *related_lookups):
                     else:
                         try:
                             new_obj = getattr(obj, through_attr)
-                        except exceptions.ObjectDoesNotExist:
+                        except ObjectDoesNotExist:
                             continue
                     if new_obj is None:
                         continue
@@ -2174,7 +2176,7 @@ def prefetch_one_level(instances, prefetcher, lookup, level):
         model = instances[0].__class__
         try:
             model._meta.get_field(to_attr)
-        except exceptions.FieldDoesNotExist:
+        except FieldDoesNotExist:
             pass
         else:
             msg = "to_attr={} conflicts with a field on the {} model."

plain/models/query_utils.py

@@ -11,9 +11,9 @@ import inspect
 import logging
 from collections import namedtuple
 
-from plain.exceptions import FieldError
 from plain.models.constants import LOOKUP_SEP
 from plain.models.db import DatabaseError, db_connection
+from plain.models.exceptions import FieldError
 from plain.utils import tree
 
 logger = logging.getLogger("plain.models")
@@ -355,7 +355,7 @@ def check_rel_lookup_compatibility(model, target_opts, field):
     """
 
     def check(opts):
-        return model._meta.concrete_model == opts.concrete_model
+        return model == opts.model
 
     # If the field is a primary key, then doing a query against the field's
     # model is ok, too. Consider the case:

plain/models/sql/compiler.py

@@ -4,9 +4,9 @@ import re
 from functools import cached_property, partial
 from itertools import chain
 
-from plain.exceptions import EmptyResultSet, FieldError, FullResultSet
 from plain.models.constants import LOOKUP_SEP
 from plain.models.db import DatabaseError, NotSupportedError
+from plain.models.exceptions import EmptyResultSet, FieldError, FullResultSet
 from plain.models.expressions import F, OrderBy, RawSQL, Ref, Value
 from plain.models.functions import Cast, Random
 from plain.models.lookups import Lookup
@@ -940,9 +940,9 @@ class SQLCompiler:
         start_alias = start_alias or self.query.get_initial_alias()
 
         for field in opts.concrete_fields:
-            model = field.model._meta.concrete_model
-            # A proxy model will have a different model and concrete_model. We
-            # will assign None if the field belongs to this model.
+            model = field.model
+            # Since we no longer have proxy models or inheritance,
+            # the field's model should always be the same as opts.model.
             if model == opts.model:
                 model = None
             if select_mask and field not in select_mask:
@@ -1331,9 +1331,9 @@ class SQLCompiler:
             select_fields is filled recursively, so it also contains fields
             from the parent models.
             """
-            concrete_model = klass_info["model"]._meta.concrete_model
+            model = klass_info["model"]
             for select_index in klass_info["select_fields"]:
-                if self.select[select_index][0].target.model == concrete_model:
+                if self.select[select_index][0].target.model == model:
                     return self.select[select_index][0]
 
         def _get_field_choices():

plain/models/sql/datastructures.py

@@ -3,7 +3,7 @@ Useful auxiliary data structures for query construction. Not useful outside
 the SQL domain.
 """
 
-from plain.exceptions import FullResultSet
+from plain.models.exceptions import FullResultSet
 from plain.models.sql.constants import INNER, LOUTER
 
 

plain/models/sql/query.py

@@ -17,10 +17,10 @@ from functools import cached_property
 from itertools import chain, count, product
 from string import ascii_uppercase
 
-from plain.exceptions import FieldDoesNotExist, FieldError
 from plain.models.aggregates import Count
 from plain.models.constants import LOOKUP_SEP
 from plain.models.db import NotSupportedError, db_connection
+from plain.models.exceptions import FieldDoesNotExist, FieldError
 from plain.models.expressions import (
     BaseExpression,
     Col,
@@ -706,7 +706,7 @@ class Query(BaseExpression):
                 if not field.is_relation:
                     raise FieldError(next(iter(field_mask)))
                 field_select_mask = select_mask.setdefault(field, {})
-                related_model = field.remote_field.model._meta.concrete_model
+                related_model = field.remote_field.model
                 self._get_defer_select_mask(
                     related_model._meta, field_mask, field_select_mask
                 )
@@ -721,7 +721,7 @@ class Query(BaseExpression):
             else:
                 field = opts.get_field(field_name).field
                 field_select_mask = select_mask.setdefault(field, {})
-            related_model = field.model._meta.concrete_model
+            related_model = field.model
             self._get_defer_select_mask(
                 related_model._meta, field_mask, field_select_mask
             )
@@ -738,7 +738,7 @@ class Query(BaseExpression):
             if field_mask:
                 if not field.is_relation:
                     raise FieldError(next(iter(field_mask)))
-                related_model = field.remote_field.model._meta.concrete_model
+                related_model = field.remote_field.model
                 self._get_only_select_mask(
                     related_model._meta, field_mask, field_select_mask
                 )

plain/models/sql/subqueries.py

@@ -2,7 +2,7 @@
 Query subclasses which provide extra functionality beyond simple data retrieval.
 """
 
-from plain.exceptions import FieldError
+from plain.models.exceptions import FieldError
 from plain.models.sql.constants import CURSOR, GET_ITERATOR_CHUNK_SIZE, NO_RESULTS
 from plain.models.sql.query import Query
 
@@ -87,13 +87,13 @@ class UpdateQuery(Query):
             direct = (
                 not (field.auto_created and not field.concrete) or not field.concrete
             )
-            model = field.model._meta.concrete_model
+            model = field.model
             if not direct or (field.is_relation and field.many_to_many):
                 raise FieldError(
                     f"Cannot update model field {field!r} (only non-relations and "
                     "foreign keys permitted)."
                 )
-            if model is not self.get_meta().concrete_model:
+            if model is not self.get_meta().model:
                 self.add_related_update(model, field, val)
                 continue
             values_seq.append((field, model, val))

plain/models/sql/where.py

@@ -5,7 +5,7 @@ Code to manage the creation and SQL rendering of 'where' constraints.
 import operator
 from functools import cached_property, reduce
 
-from plain.exceptions import EmptyResultSet, FullResultSet
+from plain.models.exceptions import EmptyResultSet, FullResultSet
 from plain.models.expressions import Case, When
 from plain.models.lookups import Exact
 from plain.utils import tree

{plain_models-0.48.0.dist-info → plain_models-0.49.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.models
-Version: 0.48.0
+Version: 0.49.0
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE

{plain_models-0.48.0.dist-info → plain_models-0.49.0.dist-info}/RECORD

@@ -1,30 +1,30 @@
 plain/models/AGENTS.md,sha256=xQQW-z-DehnCUyjiGSBfLqUjoSUdo_W1b0JmwYmWieA,209
-plain/models/CHANGELOG.md,sha256=_EJXRX89opgWTq_FnrLrs2Q7BOKxbrINWsYU4qwZIqQ,18245
+plain/models/CHANGELOG.md,sha256=f-zsBeKsovIyXp5YozHM7Fz8ujJS1II-oF2POrLSrAQ,19875
 plain/models/README.md,sha256=lqzWJrEIxBCHC1P8X1YoRjbsMFlu0-kG4ujP76B_ZO4,8572
-plain/models/__init__.py,sha256=aB9HhIKBh0iK3LZztInAE-rDF-yKsdfcjfMtwtN5vnI,2920
-plain/models/aggregates.py,sha256=P0mhsMl1VZt2CVHMuCHnNI8SxZ9citjDLEgioN6NOpo,7240
-plain/models/base.py,sha256=4NkK-gkcxbIWZm7c9Q51eDwLClIieWZvlRg6l7vJOxE,65692
+plain/models/__init__.py,sha256=t6scDQ-bGQD3k-U_DE9K5JJ3pnmkC7ZHchFnWA-BcW8,2845
+plain/models/aggregates.py,sha256=P1nAyp1XORdlx1D-__Nx9AehUeuKmcjeS6heqjB7A7k,7247
+plain/models/base.py,sha256=7fN3nPpO1vlE8eJ7C26g_kaoo2kImujmturCkpnAc2w,63835
 plain/models/cli.py,sha256=rqrgG__OyqtaDaKLB6XZnS6Zv7esU9K9EAyKCO35McA,39548
 plain/models/config.py,sha256=-m15VY1ZJKWdPGt-5i9fnMvz9LBzPfSRgWmWeEV8Dao,382
 plain/models/connections.py,sha256=RBNa2FZ0x3C9un6PaYL-IYzH_OesRSpdHNGKvYHGiOM,2276
 plain/models/constants.py,sha256=ndnj9TOTKW0p4YcIPLOLEbsH6mOgFi6B1-rIzr_iwwU,210
-plain/models/constraints.py,sha256=Mm9gm5D7EKmo486dL481-hrTcxi2gxgqyUUtbGrkLjs,16749
+plain/models/constraints.py,sha256=DC6BW6tB4WcChakyRsi6qiiWolC3v5oG1IAFvQe3ESk,16784
 plain/models/database_url.py,sha256=iidKVhOylf5N6t1EMPRySRQiv6LiuRjYRECB_UJ3MI8,6419
 plain/models/db.py,sha256=FpdfLYrRX2THUzDy4QdJ_OpSo9IFKLerZIEQ-T2x8zA,1348
 plain/models/default_settings.py,sha256=cDym1o_DtHySWgDRIdjgEM0YxjgYU51ZqzWVA3vpzTk,569
-plain/models/deletion.py,sha256=GnjhPHLRAsrec7Aa0sczqtOEDV41AGKj6QBQdhl508A,17611
+plain/models/deletion.py,sha256=7EdE_ZtKI3-Plb4QIlWYqQJa1l8gC9-KHH6GazoWjT4,17505
 plain/models/entrypoints.py,sha256=EC14mW19tK9dCumaNHnv4_9jQV8jomQ8jXy8Ib89VBw,191
 plain/models/enums.py,sha256=Zr-JKt2aeYsSADtAm69fDRfajS7jYwop2vWQVLJ9YYI,2726
-plain/models/exceptions.py,sha256=IqzK60-hY3TYsgOMxlWwgpVa21E7ydC-gqUG4tNvVJc,2042
-plain/models/expressions.py,sha256=hN6sfOxqxpP0qmYOUotsFAAn2-bnl35iHwyINyXA7CI,62763
-plain/models/forms.py,sha256=VreclYMITYh3D-sfZV3iSQH9QjNmwNwIYQL_90owOVM,25805
+plain/models/exceptions.py,sha256=xxwsr2rhV4J4RNJoGu5yaKWQUTiREFx6ARnKGRcxl7k,4995
+plain/models/expressions.py,sha256=1bWyeSzlTbBawZa-aaDEMSiTSnroMA2DRswsAu-5mtw,62770
+plain/models/forms.py,sha256=nqA5_bByjNxKoc51O48Gycp6z2oMmozqyyzfwnc5V2o,25836
 plain/models/indexes.py,sha256=fazIZPJgCX5_Bhwk7MQy3YbWOxpHvaCe1dDLGGldTuY,11540
-plain/models/lookups.py,sha256=eCsxQXUcOoAa_U_fAAd3edcgXI1wfyFW8hPgUh8TwTo,24776
-plain/models/options.py,sha256=BOnu9NDVcgL0tJhan5gBbaK1SWNeg4NVTPNAzkKT3NE,21528
+plain/models/lookups.py,sha256=77F4AE0ukDRqAj-uLQ5oWgmK1dZcuVujspefyEO7gOE,24783
+plain/models/options.py,sha256=_UWTLyQo4D2sx4AmIRgXQBo3HqBHWujY3XutLu_O8LQ,20999
 plain/models/otel.py,sha256=36QSJS6UXv1YPJTqeSmEvdMVHRkXa_zgqqItJaXc59g,7619
 plain/models/preflight.py,sha256=_cBX7AnfQDNtZfoW0ydxH8WQM3ftCqcH0-tPhqS5q8c,8973
-plain/models/query.py,sha256=YxIpgRndQyXsSpNLl3uPGvu-UNQzK1CXFsf2U75XVao,90714
-plain/models/query_utils.py,sha256=zxAdfwDbOmaN_SJODl4Wl9gs-q2EzOjXbsBFTWWhh8g,14174
+plain/models/query.py,sha256=p-qpwN-eR7Dvk68QA6W7QgVD5ejoYwYYsv4rbXxB7WA,90652
+plain/models/query_utils.py,sha256=x_n2lKsSjx-5ULbZsGx0AhGpMNVYizdbl_BxDlUK8lQ,14151
 plain/models/registry.py,sha256=5yxVgT_W8GlyL2bsGT2HvMQB5sKolXucP2qrhr7Wlnk,8126
 plain/models/transaction.py,sha256=KqkRDT6aqMgbPA_ch7qO8a9NyDvwY_2FaxM7FkBkcgY,9357
 plain/models/utils.py,sha256=rD47CAMH4SsznTe-kUnRUdnaZeZHVv1fwLUiU3KOFW0,1630
@@ -43,7 +43,7 @@ plain/models/backends/base/validation.py,sha256=ATkhZ36RgKHrXhdiOzIK5kRHW56eSggL
 plain/models/backends/mysql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plain/models/backends/mysql/base.py,sha256=FCANhKAs2013oLPdC9y4PQCRb9NYsp1Zca_wha6TDT4,14286
 plain/models/backends/mysql/client.py,sha256=YGjk4f5VOuIKcj5SOOJeBqiSDF0Ft9m1aUPOmLzdD6c,2973
-plain/models/backends/mysql/compiler.py,sha256=NaYgcGyFUZ2lTOXXJj87hLMMMnXRAS1jUYkJq1NoCv4,3289
+plain/models/backends/mysql/compiler.py,sha256=DorAoufST7QYQUwkXRZFl4xyp2rykrGBhkHZlW1vCr4,3296
 plain/models/backends/mysql/creation.py,sha256=ozuc3mz65bjFz6sn5BFLRRGQsUYaxwIGjQyKod31c1Y,952
 plain/models/backends/mysql/features.py,sha256=OPHaiqPmAFAUZqnZdLOqbCmxmuGMnIqa62fJqAkYQ0o,5875
 plain/models/backends/mysql/introspection.py,sha256=R3U912qnWwJDmTiX7QzGAXTc2LAShIhp4C6xHTABM68,13960
@@ -65,20 +65,20 @@ plain/models/backends/sqlite3/client.py,sha256=dvxY10LFJHKY6ykOuCE6e45Wo4fAH4IPD
 plain/models/backends/sqlite3/creation.py,sha256=dH4rqZj79TCMHmaBash4I_io15QCxnam92fuWrRK_R8,2788
 plain/models/backends/sqlite3/features.py,sha256=V7ueGfbUSzBNGgMRtCptXSH_0b51lyVfzi-98BX4afo,2366
 plain/models/backends/sqlite3/introspection.py,sha256=6nD5sbjxlJ1ocmwBxmyZqg7KT7fHKbjmmGZqAzmVpZc,17063
-plain/models/backends/sqlite3/operations.py,sha256=K2PFCsvzGhBrPEzz1AXFenge2B4Ap8lsQAABsC4e_UI,15302
+plain/models/backends/sqlite3/operations.py,sha256=jgVfxFKP3fnIo9PzfxZtm5BYTo3XgHUncvtTtI6WRKY,15309
 plain/models/backends/sqlite3/schema.py,sha256=sbtI0PBGe0fK0IOFWh0bkpVntCMMVsfzPb9dpL7o4r8,22566
 plain/models/backups/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plain/models/backups/cli.py,sha256=AKVh_Go0LxnxFi2jQjmpPEbbJvYCurjJsGCWESm1X8A,2960
 plain/models/backups/clients.py,sha256=gHYQkukqamR_uksMr9wy3tBpMxK6DyUyj7nndNIlbo8,4744
 plain/models/backups/core.py,sha256=09IZUhBEe1Yej3PC8AidtkaI0c8tt7VnqGBCWK-WrFg,3318
-plain/models/fields/__init__.py,sha256=-daSts1wN63oU_XXQUlNPmk81-JPQzXwY1FdCMRnTng,74732
+plain/models/fields/__init__.py,sha256=Pxso0fIHOhf9Czrw-W5x0B7u_mBbhf9KgNzW9QBoJrk,73096
 plain/models/fields/json.py,sha256=4WHZX5MI-GZapcaaHltPgc6f9pHAezjfaTYNh_PX8rQ,18041
 plain/models/fields/mixins.py,sha256=wmu3JJEOimijgepjMEFPN8u74mHpefgnsB4u5ZzVCUY,1890
-plain/models/fields/related.py,sha256=7Ku8E5hxQxVgJy3afWZfuDlHDzrky_4mkKwPlqLpM6o,51065
-plain/models/fields/related_descriptors.py,sha256=nsVgLjpOlrha90eTfg7ad_il6_uI_YG0d4bH51LP3Os,15180
+plain/models/fields/related.py,sha256=C69F4umO_oNTbpE5XhI5PBV_tLttBA-jV4lPcsqq6kA,50669
+plain/models/fields/related_descriptors.py,sha256=Ox7sX6mpsDfvNRZBm323GwseOqlaK4270WREydCRjrQ,15137
 plain/models/fields/related_lookups.py,sha256=9y6AfEcg8xRRZne2LXFP6jym9mecFlB_toYih7lD8Uw,7781
-plain/models/fields/related_managers.py,sha256=LefSf8ss8XZ_97NoKfRKHTijheb44exJ_UBLGcNgQdc,25053
-plain/models/fields/reverse_related.py,sha256=SNFytCI3BeAlB5kY6UQrv6QGqtRMo_aHWPx_-fCkfu4,10404
+plain/models/fields/related_managers.py,sha256=MxxOY5iMmHgpZR7qt9ZPbdvw8pN_B39siBJgdDXgS2A,25060
+plain/models/fields/reverse_related.py,sha256=uAePNDx6h-7duDeJyMPBPm0DpUM39YZKxrO6G8Lgm_A,10389
 plain/models/functions/__init__.py,sha256=aglCm_JtzDYk2KmxubDN_78CGG3JCfRWnfJ74Oj5YJ4,2658
 plain/models/functions/comparison.py,sha256=9uAiEuNXZiGFzJKBvktsHwx58Qpa2cPQkr6pUWsGcKo,6554
 plain/models/functions/datetime.py,sha256=ov1H0Oq9qHSeu8L5CZsln0_SMU2C5M_P5HvKxppA24o,13089
@@ -97,7 +97,7 @@ plain/models/migrations/optimizer.py,sha256=HH-uz-jnWw_Ni6F2_rRW1nax1Dxmf1s_F_8s
 plain/models/migrations/questioner.py,sha256=qAsePI5JHiSJrlY_kmpgMuK9Dom22q17edov7RtBeGw,11967
 plain/models/migrations/recorder.py,sha256=_ncIVLJ4ns6AaO0vVmCoXfABlOFXDKu8NTPsutqKjK4,3653
 plain/models/migrations/serializer.py,sha256=yBP9TyUZlSh_8qdw1I4VotbsZqoomz3mBs7ASQLsDH8,12459
-plain/models/migrations/state.py,sha256=EB3BCST2SxpijGjdEhh2Jqp-wr4Fb29bhvOZP3ZWdqg,32120
+plain/models/migrations/state.py,sha256=yX04Y5M87RylEqIpy6pbzWdTw_9Fv2bhtT0ODbPAiZg,32127
 plain/models/migrations/utils.py,sha256=Ih_mu6UbdUSt-ZtHaB0xIXHDrBANuFZyftTQ56BFJYs,4174
 plain/models/migrations/writer.py,sha256=N8Rnjv5ccsA_CTcS7zZyppzyHFOUQVJy0l6RZYjwF-0,10981
 plain/models/migrations/operations/__init__.py,sha256=YKZsQsJ4G5iw9F4o6dOSgSCuLiiKuApvneoV4jqjZaA,752
@@ -106,17 +106,17 @@ plain/models/migrations/operations/fields.py,sha256=ARL945rbztAnMsbd0lvQRsQJEmxY
 plain/models/migrations/operations/models.py,sha256=jwhck8ygfi8cW8baVeGUB6coVVv4HnGVSFVb2IW_aTU,24947
 plain/models/migrations/operations/special.py,sha256=cKieE9AQcFrpvEw5_TJCum56uu6cfN1p-azY7sKdB7E,4944
 plain/models/sql/__init__.py,sha256=FoRCcab-kh_XY8C4eldgLy9-zuk-M63Nyi9cFsYjclU,225
-plain/models/sql/compiler.py,sha256=FVa_v4Q8izuFc9VQTrW4jAqM1uqRnTVdOeP7IKt3yM8,84691
+plain/models/sql/compiler.py,sha256=MumFROrMBIRhWpxlq85sj25YeZ1UZMTA7UQfRzzJLwQ,84632
 plain/models/sql/constants.py,sha256=usb1LSh9WNGPsurWAGppDkV0wYJJg5GEegKibQdS718,533
-plain/models/sql/datastructures.py,sha256=FC88CVCukLyU621JrmKLBhmgvotEHgAhIOYfVvJpuR0,7084
-plain/models/sql/query.py,sha256=ASR6jeRTjGlnO5E_hb5cnUYQH2_JrpHa_M545xOG7dg,108745
-plain/models/sql/subqueries.py,sha256=1YYlgoDrx_mW19MWWawLdgDTJnLgvvkGBQ30YQ702W4,5860
-plain/models/sql/where.py,sha256=ezE9Clt2BmKo-I7ARsgqZ_aVA-1UdayCwr6ULSWZL6c,12635
+plain/models/sql/datastructures.py,sha256=OvMfckKGQOb0pb1UAXhlV-P0FAvvV9oSR0R82i0u0JU,7091
+plain/models/sql/query.py,sha256=DkLdkDzQuJWzdtyzCTQldQIHyoJu8JGoTuiLolCA16w,108689
+plain/models/sql/subqueries.py,sha256=DGWpBO4wYVT0lSSDoNYcy_VyCLuSueZvoDfrgQu7V1g,5837
+plain/models/sql/where.py,sha256=P_2EFg-BMIu9jTZFiiPwz1E74jlSitiP-taShCp5OhU,12642
 plain/models/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plain/models/test/pytest.py,sha256=KD5-mxonBxOYIhUh9Ql5uJOIiC9R4t-LYfb6sjA0UdE,3486
 plain/models/test/utils.py,sha256=S3d6zf3OFWDxB_kBJr0tDvwn51bjwDVWKPumv37N-p8,467
-plain_models-0.48.0.dist-info/METADATA,sha256=rE7jXG5-QLDFTyIJQnTb9QGt6Z23o_LZ16soPfLKvlI,8884
-plain_models-0.48.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-plain_models-0.48.0.dist-info/entry_points.txt,sha256=IYJAW9MpL3PXyXFWmKmALagAGXC_5rzBn2eEGJlcV04,112
-plain_models-0.48.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
-plain_models-0.48.0.dist-info/RECORD,,
+plain_models-0.49.0.dist-info/METADATA,sha256=QulZ-TJtNAyutLdHzWvvhGNaZ5uayc3hgl3VFycIgzw,8884
+plain_models-0.49.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plain_models-0.49.0.dist-info/entry_points.txt,sha256=IYJAW9MpL3PXyXFWmKmALagAGXC_5rzBn2eEGJlcV04,112
+plain_models-0.49.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
+plain_models-0.49.0.dist-info/RECORD,,