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

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/executor.py

@@ -1,3 +1,6 @@
+from contextlib import nullcontext
+
+from ..transaction import atomic
 from .loader import MigrationLoader
 from .recorder import MigrationRecorder
 from .state import ProjectState
@@ -52,12 +55,14 @@ class MigrationExecutor:
                     migration.mutate_state(state, preserve=False)
         return state
 
-    def migrate(self, targets, plan=None, state=None, fake=False):
+    def migrate(self, targets, plan=None, state=None, fake=False, atomic_batch=False):
         """
         Migrate the database up to the given targets.
 
         Plain first needs to create all project states before a migration is
         (un)applied and in a second step run all the database operations.
+
+        atomic_batch: Whether to run all migrations in a single transaction.
         """
         # The plain_migrations table must be present to record applied
         # migrations, but don't create it if there are no migrations to apply.
@@ -82,34 +87,31 @@ class MigrationExecutor:
             if state is None:
                 # The resulting state should still include applied migrations.
                 state = self._create_project_state(with_applied_migrations=True)
-            state = self._migrate_all_forwards(state, plan, full_plan, fake=fake)
-
-        self.check_replacements()
 
-        return state
+            migrations_to_run = set(plan)
+
+            # Choose context manager based on atomic_batch
+            batch_context = atomic if (atomic_batch and len(plan) > 1) else nullcontext
+
+            with batch_context():
+                for migration in full_plan:
+                    if not migrations_to_run:
+                        # We remove every migration that we applied from these sets so
+                        # that we can bail out once the last migration has been applied
+                        # and don't always run until the very end of the migration
+                        # process.
+                        break
+                    if migration in migrations_to_run:
+                        if "models_registry" not in state.__dict__:
+                            if self.progress_callback:
+                                self.progress_callback("render_start")
+                            state.models_registry  # Render all -- performance critical
+                            if self.progress_callback:
+                                self.progress_callback("render_success")
+                        state = self.apply_migration(state, migration, fake=fake)
+                        migrations_to_run.remove(migration)
 
-    def _migrate_all_forwards(self, state, plan, full_plan, fake):
-        """
-        Take a list of 2-tuples of the form (migration instance, False) and
-        apply them in the order they occur in the full_plan.
-        """
-        migrations_to_run = set(plan)
-        for migration in full_plan:
-            if not migrations_to_run:
-                # We remove every migration that we applied from these sets so
-                # that we can bail out once the last migration has been applied
-                # and don't always run until the very end of the migration
-                # process.
-                break
-            if migration in migrations_to_run:
-                if "models_registry" not in state.__dict__:
-                    if self.progress_callback:
-                        self.progress_callback("render_start")
-                    state.models_registry  # Render all -- performance critical
-                    if self.progress_callback:
-                        self.progress_callback("render_success")
-                state = self.apply_migration(state, migration, fake=fake)
-                migrations_to_run.remove(migration)
+        self.check_replacements()
 
         return state
 

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.47.0.dist-info → plain_models-0.49.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.models
-Version: 0.47.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