plain.models 0.33.1__py3-none-any.whl → 0.34.1__py3-none-any.whl

plain/models/fields/related_descriptors.py

@@ -51,10 +51,8 @@ from functools import cached_property
 from plain.exceptions import FieldError
 from plain.models import transaction
 from plain.models.db import (
-    DEFAULT_DB_ALIAS,
     NotSupportedError,
-    connections,
-    router,
+    db_connection,
 )
 from plain.models.expressions import Window
 from plain.models.functions import RowNumber
@@ -75,17 +73,14 @@ class ForeignKeyDeferredAttribute(DeferredAttribute):
 
 def _filter_prefetch_queryset(queryset, field_name, instances):
     predicate = Q(**{f"{field_name}__in": instances})
-    db = queryset._db or DEFAULT_DB_ALIAS
     if queryset.query.is_sliced:
-        if not connections[db].features.supports_over_clause:
+        if not db_connection.features.supports_over_clause:
             raise NotSupportedError(
                 "Prefetching from a limited queryset is only supported on backends "
                 "that support window functions."
             )
         low_mark, high_mark = queryset.query.low_mark, queryset.query.high_mark
-        order_by = [
-            expr for expr, _ in queryset.query.get_compiler(using=db).get_order_by()
-        ]
+        order_by = [expr for expr, _ in queryset.query.get_compiler().get_order_by()]
         window = Window(RowNumber(), partition_by=field_name, order_by=order_by)
         predicate &= GreaterThan(window, low_mark)
         if high_mark is not None:
@@ -127,7 +122,9 @@ class ForwardManyToOneDescriptor:
         return self.field.is_cached(instance)
 
     def get_queryset(self, **hints):
-        return self.field.remote_field.model._base_manager.db_manager(hints=hints).all()
+        qs = self.field.remote_field.model._base_manager.get_queryset()
+        qs._add_hints(**hints)
+        return qs.all()
 
     def get_prefetch_queryset(self, instances, queryset=None):
         if queryset is None:
@@ -232,21 +229,6 @@ class ForwardManyToOneDescriptor:
             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.'
             )
-        elif value is not None:
-            if instance._state.db is None:
-                instance._state.db = router.db_for_write(
-                    instance.__class__, instance=value
-                )
-            if value._state.db is None:
-                value._state.db = router.db_for_write(
-                    value.__class__, instance=instance
-                )
-            if not router.allow_relation(value, instance):
-                raise ValueError(
-                    f'Cannot assign "{value!r}": the current database router prevents this '
-                    "relation."
-                )
-
         remote_field = self.field.remote_field
         # If we're setting the value of a OneToOneField to None, we need to clear
         # out the cache on any old related object. Otherwise, deleting the
@@ -387,13 +369,10 @@ def create_reverse_many_to_one_manager(superclass, rel):
             """
             Filter the queryset for the instance this manager is bound to.
             """
-            db = self._db or router.db_for_read(self.model, instance=self.instance)
-            empty_strings_as_null = connections[
-                db
-            ].features.interprets_empty_strings_as_nulls
+            empty_strings_as_null = (
+                db_connection.features.interprets_empty_strings_as_nulls
+            )
             queryset._add_hints(instance=self.instance)
-            if self._db:
-                queryset = queryset.using(self._db)
             queryset._defer_next_filter = True
             queryset = queryset.filter(**self.core_filters)
             for field in self.field.foreign_related_fields:
@@ -453,7 +432,6 @@ def create_reverse_many_to_one_manager(superclass, rel):
                 queryset = super().get_queryset()
 
             queryset._add_hints(instance=instances[0])
-            queryset = queryset.using(queryset._db or self._db)
 
             rel_obj_attr = self.field.get_local_related_value
             instance_attr = self.field.get_foreign_related_value
@@ -472,7 +450,6 @@ def create_reverse_many_to_one_manager(superclass, rel):
         def add(self, *objs, bulk=True):
             self._check_fk_val()
             self._remove_prefetched_objects()
-            db = router.db_for_write(self.model, instance=self.instance)
 
             def check_and_update_obj(obj):
                 if not isinstance(obj, self.model):
@@ -485,19 +462,19 @@ def create_reverse_many_to_one_manager(superclass, rel):
                 pks = []
                 for obj in objs:
                     check_and_update_obj(obj)
-                    if obj._state.adding or obj._state.db != db:
+                    if obj._state.adding:
                         raise ValueError(
                             f"{obj!r} instance isn't saved. Use bulk=False or save "
                             "the object first."
                         )
                     pks.append(obj.pk)
-                self.model._base_manager.using(db).filter(pk__in=pks).update(
+                self.model._base_manager.filter(pk__in=pks).update(
                     **{
                         self.field.name: self.instance,
                     }
                 )
             else:
-                with transaction.atomic(using=db, savepoint=False):
+                with transaction.atomic(savepoint=False):
                     for obj in objs:
                         check_and_update_obj(obj)
                         obj.save()
@@ -505,20 +482,17 @@ def create_reverse_many_to_one_manager(superclass, rel):
         def create(self, **kwargs):
             self._check_fk_val()
             kwargs[self.field.name] = self.instance
-            db = router.db_for_write(self.model, instance=self.instance)
-            return super(RelatedManager, self.db_manager(db)).create(**kwargs)
+            return super().create(**kwargs)
 
         def get_or_create(self, **kwargs):
             self._check_fk_val()
             kwargs[self.field.name] = self.instance
-            db = router.db_for_write(self.model, instance=self.instance)
-            return super(RelatedManager, self.db_manager(db)).get_or_create(**kwargs)
+            return super().get_or_create(**kwargs)
 
         def update_or_create(self, **kwargs):
             self._check_fk_val()
             kwargs[self.field.name] = self.instance
-            db = router.db_for_write(self.model, instance=self.instance)
-            return super(RelatedManager, self.db_manager(db)).update_or_create(**kwargs)
+            return super().update_or_create(**kwargs)
 
         # remove() and clear() are only provided if the ForeignKey can have a
         # value of null.
@@ -550,13 +524,11 @@ def create_reverse_many_to_one_manager(superclass, rel):
 
             def _clear(self, queryset, bulk):
                 self._remove_prefetched_objects()
-                db = router.db_for_write(self.model, instance=self.instance)
-                queryset = queryset.using(db)
                 if bulk:
                     # `QuerySet.update()` is intrinsically atomic.
                     queryset.update(**{self.field.name: None})
                 else:
-                    with transaction.atomic(using=db, savepoint=False):
+                    with transaction.atomic(savepoint=False):
                         for obj in queryset:
                             setattr(obj, self.field.name, None)
                             obj.save(update_fields=[self.field.name])
@@ -568,13 +540,12 @@ def create_reverse_many_to_one_manager(superclass, rel):
             objs = tuple(objs)
 
             if self.field.allow_null:
-                db = router.db_for_write(self.model, instance=self.instance)
-                with transaction.atomic(using=db, savepoint=False):
+                with transaction.atomic(savepoint=False):
                     if clear:
                         self.clear(bulk=bulk)
                         self.add(*objs, bulk=bulk)
                     else:
-                        old_objs = set(self.using(db).all())
+                        old_objs = set(self.all())
                         new_objs = []
                         for obj in objs:
                             if obj in old_objs:
@@ -726,8 +697,6 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             Filter the queryset for the instance this manager is bound to.
             """
             queryset._add_hints(instance=self.instance)
-            if self._db:
-                queryset = queryset.using(self._db)
             queryset._defer_next_filter = True
             return queryset._next_is_sticky().filter(**self.core_filters)
 
@@ -749,7 +718,6 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                 queryset = super().get_queryset()
 
             queryset._add_hints(instance=instances[0])
-            queryset = queryset.using(queryset._db or self._db)
             queryset = _filter_prefetch_queryset(
                 queryset._next_is_sticky(), self.query_field_name, instances
             )
@@ -763,8 +731,7 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             # dealing with PK values.
             fk = self.through._meta.get_field(self.source_field_name)
             join_table = fk.model._meta.db_table
-            connection = connections[queryset.db]
-            qn = connection.ops.quote_name
+            qn = db_connection.ops.quote_name
             queryset = queryset.extra(
                 select={
                     f"_prefetch_related_val_{f.attname}": f"{qn(join_table)}.{qn(f.column)}"
@@ -778,7 +745,7 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                     for f in fk.local_related_fields
                 ),
                 lambda inst: tuple(
-                    f.get_db_prep_value(getattr(inst, f.attname), connection)
+                    f.get_db_prep_value(getattr(inst, f.attname), db_connection)
                     for f in fk.foreign_related_fields
                 ),
                 False,
@@ -788,8 +755,7 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
 
         def add(self, *objs, through_defaults=None):
             self._remove_prefetched_objects()
-            db = router.db_for_write(self.through, instance=self.instance)
-            with transaction.atomic(using=db, savepoint=False):
+            with transaction.atomic(savepoint=False):
                 self._add_items(
                     self.source_field_name,
                     self.target_field_name,
@@ -811,25 +777,23 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             self._remove_items(self.source_field_name, self.target_field_name, *objs)
 
         def clear(self):
-            db = router.db_for_write(self.through, instance=self.instance)
-            with transaction.atomic(using=db, savepoint=False):
+            with transaction.atomic(savepoint=False):
                 self._remove_prefetched_objects()
-                filters = self._build_remove_filters(super().get_queryset().using(db))
-                self.through._default_manager.using(db).filter(filters).delete()
+                filters = self._build_remove_filters(super().get_queryset())
+                self.through._default_manager.filter(filters).delete()
 
         def set(self, objs, *, clear=False, through_defaults=None):
             # Force evaluation of `objs` in case it's a queryset whose value
             # could be affected by `manager.clear()`. Refs #19816.
             objs = tuple(objs)
 
-            db = router.db_for_write(self.through, instance=self.instance)
-            with transaction.atomic(using=db, savepoint=False):
+            with transaction.atomic(savepoint=False):
                 if clear:
                     self.clear()
                     self.add(*objs, through_defaults=through_defaults)
                 else:
                     old_ids = set(
-                        self.using(db).values_list(
+                        self.values_list(
                             self.target_field.target_field.attname, flat=True
                         )
                     )
@@ -850,16 +814,12 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                     self.add(*new_objs, through_defaults=through_defaults)
 
         def create(self, *, through_defaults=None, **kwargs):
-            db = router.db_for_write(self.instance.__class__, instance=self.instance)
-            new_obj = super(ManyRelatedManager, self.db_manager(db)).create(**kwargs)
+            new_obj = super().create(**kwargs)
             self.add(new_obj, through_defaults=through_defaults)
             return new_obj
 
         def get_or_create(self, *, through_defaults=None, **kwargs):
-            db = router.db_for_write(self.instance.__class__, instance=self.instance)
-            obj, created = super(ManyRelatedManager, self.db_manager(db)).get_or_create(
-                **kwargs
-            )
+            obj, created = super().get_or_create(**kwargs)
             # We only need to add() if created because if we got an object back
             # from get() then the relationship already exists.
             if created:
@@ -867,10 +827,7 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             return obj, created
 
         def update_or_create(self, *, through_defaults=None, **kwargs):
-            db = router.db_for_write(self.instance.__class__, instance=self.instance)
-            obj, created = super(
-                ManyRelatedManager, self.db_manager(db)
-            ).update_or_create(**kwargs)
+            obj, created = super().update_or_create(**kwargs)
             # We only need to add() if created because if we got an object back
             # from get() then the relationship already exists.
             if created:
@@ -887,11 +844,6 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             target_field = self.through._meta.get_field(target_field_name)
             for obj in objs:
                 if isinstance(obj, self.model):
-                    if not router.allow_relation(obj, self.instance):
-                        raise ValueError(
-                            f'Cannot add "{obj!r}": instance is on database "{self.instance._state.db}", '
-                            f'value is on database "{obj._state.db}"'
-                        )
                     target_id = target_field.get_foreign_related_value(obj)[0]
                     if target_id is None:
                         raise ValueError(
@@ -907,21 +859,19 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             return target_ids
 
         def _get_missing_target_ids(
-            self, source_field_name, target_field_name, db, target_ids
+            self, source_field_name, target_field_name, target_ids
         ):
             """
             Return the subset of ids of `objs` that aren't already assigned to
             this relationship.
             """
-            vals = (
-                self.through._default_manager.using(db)
-                .values_list(target_field_name, flat=True)
-                .filter(
-                    **{
-                        source_field_name: self.related_val[0],
-                        f"{target_field_name}__in": target_ids,
-                    }
-                )
+            vals = self.through._default_manager.values_list(
+                target_field_name, flat=True
+            ).filter(
+                **{
+                    source_field_name: self.related_val[0],
+                    f"{target_field_name}__in": target_ids,
+                }
             )
             return target_ids.difference(vals)
 
@@ -937,14 +887,13 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
 
             through_defaults = dict(resolve_callables(through_defaults or {}))
             target_ids = self._get_target_ids(target_field_name, objs)
-            db = router.db_for_write(self.through, instance=self.instance)
 
             missing_target_ids = self._get_missing_target_ids(
-                source_field_name, target_field_name, db, target_ids
+                source_field_name, target_field_name, target_ids
             )
-            with transaction.atomic(using=db, savepoint=False):
+            with transaction.atomic(savepoint=False):
                 # Add the ones that aren't there already.
-                self.through._default_manager.using(db).bulk_create(
+                self.through._default_manager.bulk_create(
                     [
                         self.through(
                             **through_defaults,
@@ -974,16 +923,15 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
                 else:
                     old_ids.add(obj)
 
-            db = router.db_for_write(self.through, instance=self.instance)
-            with transaction.atomic(using=db, savepoint=False):
+            with transaction.atomic(savepoint=False):
                 target_model_qs = super().get_queryset()
                 if target_model_qs._has_filters():
-                    old_vals = target_model_qs.using(db).filter(
+                    old_vals = target_model_qs.filter(
                         **{f"{self.target_field.target_field.attname}__in": old_ids}
                     )
                 else:
                     old_vals = old_ids
                 filters = self._build_remove_filters(old_vals)
-                self.through._default_manager.using(db).filter(filters).delete()
+                self.through._default_manager.filter(filters).delete()
 
     return ManyRelatedManager

plain/models/forms.py

@@ -770,13 +770,11 @@ def modelfield_to_formfield(
         # will be validated twice. This is considered acceptable since we want
         # the value in the form field (to pass into widget for example).
         # TODO: Handle multiple backends with different feature flags.
-        from plain.models.db import DEFAULT_DB_ALIAS, connections
+        from plain.models.db import db_connection
 
         if (
             modelfield.allow_null
-            and not connections[
-                DEFAULT_DB_ALIAS
-            ].features.interprets_empty_strings_as_nulls
+            and not db_connection.features.interprets_empty_strings_as_nulls
         ):
             defaults["empty_value"] = None
         return fields.CharField(

plain/models/indexes.py

@@ -85,11 +85,11 @@ class Index:
             return None
         query = Query(model=model, alias_cols=False)
         where = query.build_where(self.condition)
-        compiler = query.get_compiler(connection=schema_editor.connection)
+        compiler = query.get_compiler()
         sql, params = where.as_sql(compiler, schema_editor.connection)
         return sql % tuple(schema_editor.quote_value(p) for p in params)
 
-    def create_sql(self, model, schema_editor, using="", **kwargs):
+    def create_sql(self, model, schema_editor, **kwargs):
         include = [
             model._meta.get_field(field_name).column for field_name in self.include
         ]
@@ -119,7 +119,6 @@ class Index:
             model,
             fields=fields,
             name=self.name,
-            using=using,
             col_suffixes=col_suffixes,
             opclasses=self.opclasses,
             condition=condition,

plain/models/lookups.py

@@ -448,13 +448,6 @@ class In(FieldGetDbPrepValueIterableMixin, BuiltinLookup):
         return super().get_prep_lookup()
 
     def process_rhs(self, compiler, connection):
-        db_rhs = getattr(self.rhs, "_db", None)
-        if db_rhs is not None and db_rhs != connection.alias:
-            raise ValueError(
-                "Subqueries aren't allowed across different databases. Force "
-                "the inner query to be evaluated using `list(inner_query)`."
-            )
-
         if self.rhs_is_direct_value():
             # Remove None from the list as NULL is never equal to anything.
             try:

plain/models/manager.py

@@ -1,9 +1,7 @@
-import copy
 import inspect
 from functools import wraps
 from importlib import import_module
 
-from plain.models.db import router
 from plain.models.query import QuerySet
 
 
@@ -29,7 +27,6 @@ class BaseManager:
         self._set_creation_counter()
         self.model = None
         self.name = None
-        self._db = None
         self._hints = {}
 
     def __str__(self):
@@ -132,16 +129,6 @@ class BaseManager:
         self.creation_counter = BaseManager.creation_counter
         BaseManager.creation_counter += 1
 
-    def db_manager(self, using=None, hints=None):
-        obj = copy.copy(self)
-        obj._db = using or self._db
-        obj._hints = hints or self._hints
-        return obj
-
-    @property
-    def db(self):
-        return self._db or router.db_for_read(self.model, **self._hints)
-
     #######################
     # PROXIES TO QUERYSET #
     #######################
@@ -151,7 +138,7 @@ class BaseManager:
         Return a new QuerySet object. Subclasses can override this method to
         customize the behavior of the Manager.
         """
-        return self._queryset_class(model=self.model, using=self._db, hints=self._hints)
+        return self._queryset_class(model=self.model, hints=self._hints)
 
     def all(self):
         # We can't proxy this method through the `QuerySet` like we do for the

plain/models/migrations/executor.py

@@ -1,5 +1,4 @@
 from plain.models import migrations
-from plain.models.db import router
 
 from .loader import MigrationLoader
 from .recorder import MigrationRecorder
@@ -179,16 +178,6 @@ class MigrationExecutor:
         on initial migrations (as it only looks for CreateModel and AddField).
         """
 
-        def should_skip_detecting_model(migration, model):
-            """
-            No need to detect tables for models that can't be migrated on the current database.
-            """
-            return not router.allow_migrate(
-                self.connection.alias,
-                migration.package_label,
-                model_name=model._meta.model_name,
-            )
-
         if migration.initial is None:
             # Bail if the migration isn't the first one in its app
             if any(
@@ -224,8 +213,6 @@ class MigrationExecutor:
                     migration.package_label, operation.name
                 )
 
-                if should_skip_detecting_model(migration, model):
-                    continue
                 db_table = model._meta.db_table
                 if fold_identifier_case:
                     db_table = db_table.casefold()
@@ -237,9 +224,6 @@ class MigrationExecutor:
                     migration.package_label, operation.model_name
                 )
 
-                if should_skip_detecting_model(migration, model):
-                    continue
-
                 table = model._meta.db_table
                 field = model._meta.get_field(operation.name)
 

plain/models/migrations/loader.py

@@ -317,7 +317,7 @@ class MigrationLoader:
                             continue
                     raise InconsistentMigrationHistory(
                         f"Migration {migration[0]}.{migration[1]} is applied before its dependency "
-                        f"{parent[0]}.{parent[1]} on database '{connection.alias}'."
+                        f"{parent[0]}.{parent[1]} on the database."
                     )
 
     def detect_conflicts(self):

plain/models/migrations/migration.py

@@ -114,7 +114,7 @@ class Migration:
             if not schema_editor.atomic_migration and atomic_operation:
                 # Force a transaction on a non-transactional-DDL backend or an
                 # atomic operation inside a non-atomic migration.
-                with atomic(schema_editor.connection.alias):
+                with atomic():
                     operation.database_forwards(
                         self.package_label, schema_editor, old_state, project_state
                     )

plain/models/migrations/operations/base.py

@@ -1,6 +1,3 @@
-from plain.models.db import router
-
-
 class Operation:
     """
     Base class for migration operations.
@@ -100,16 +97,12 @@ class Operation:
         """
         return self.references_model(model_name, package_label)
 
-    def allow_migrate_model(self, connection_alias, model):
-        """
-        Return whether or not a model may be migrated.
-
-        This is a thin wrapper around router.allow_migrate_model().
-        """
-        if not model._meta.can_migrate(connection_alias):
+    def allow_migrate_model(self, connection, model):
+        """Return whether or not a model may be migrated."""
+        if not model._meta.can_migrate(connection):
             return False
 
-        return router.allow_migrate_model(connection_alias, model)
+        return True
 
     def reduce(self, operation, package_label):
         """

plain/models/migrations/operations/fields.py

@@ -101,7 +101,7 @@ class AddField(FieldOperation):
 
     def database_forwards(self, package_label, schema_editor, from_state, to_state):
         to_model = to_state.models_registry.get_model(package_label, self.model_name)
-        if self.allow_migrate_model(schema_editor.connection.alias, to_model):
+        if self.allow_migrate_model(schema_editor.connection, to_model):
             from_model = from_state.models_registry.get_model(
                 package_label, self.model_name
             )
@@ -164,7 +164,7 @@ class RemoveField(FieldOperation):
         from_model = from_state.models_registry.get_model(
             package_label, self.model_name
         )
-        if self.allow_migrate_model(schema_editor.connection.alias, from_model):
+        if self.allow_migrate_model(schema_editor.connection, from_model):
             schema_editor.remove_field(
                 from_model, from_model._meta.get_field(self.name)
             )
@@ -218,7 +218,7 @@ class AlterField(FieldOperation):
 
     def database_forwards(self, package_label, schema_editor, from_state, to_state):
         to_model = to_state.models_registry.get_model(package_label, self.model_name)
-        if self.allow_migrate_model(schema_editor.connection.alias, to_model):
+        if self.allow_migrate_model(schema_editor.connection, to_model):
             from_model = from_state.models_registry.get_model(
                 package_label, self.model_name
             )
@@ -289,7 +289,7 @@ class RenameField(FieldOperation):
 
     def database_forwards(self, package_label, schema_editor, from_state, to_state):
         to_model = to_state.models_registry.get_model(package_label, self.model_name)
-        if self.allow_migrate_model(schema_editor.connection.alias, to_model):
+        if self.allow_migrate_model(schema_editor.connection, to_model):
             from_model = from_state.models_registry.get_model(
                 package_label, self.model_name
             )