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

plain/models/deletion.py

@@ -8,7 +8,7 @@ from plain.models import (
     sql,
     transaction,
 )
-from plain.models.db import IntegrityError, connections
+from plain.models.db import IntegrityError, db_connection
 from plain.models.query import QuerySet
 
 
@@ -31,7 +31,7 @@ def CASCADE(collector, field, sub_objs, using):
         nullable=field.allow_null,
         fail_on_restricted=False,
     )
-    if field.allow_null and not connections[using].features.can_defer_constraint_checks:
+    if field.allow_null and not db_connection.features.can_defer_constraint_checks:
         collector.add_field_update(field, None, sub_objs)
 
 
@@ -93,8 +93,7 @@ def get_candidate_relations_to_delete(opts):
 
 
 class Collector:
-    def __init__(self, using, origin=None):
-        self.using = using
+    def __init__(self, origin=None):
         # A Model or QuerySet object.
         self.origin = origin
         # Initially, {model: {instances}}, later values become lists.
@@ -210,11 +209,12 @@ class Collector:
 
     def get_del_batches(self, objs, fields):
         """
-        Return the objs in suitably sized batches for the used connection.
+        Return the objs in suitably sized batches for the used db_connection.
         """
         field_names = [field.name for field in fields]
         conn_batch_size = max(
-            connections[self.using].ops.bulk_batch_size(field_names, objs), 1
+            db_connection.ops.bulk_batch_size(field_names, objs),
+            1,
         )
         if len(objs) > conn_batch_size:
             return [
@@ -300,7 +300,7 @@ class Collector:
                     sub_objs = sub_objs.only(*tuple(referenced_fields))
                 if getattr(on_delete, "lazy_sub_objs", False) or sub_objs:
                     try:
-                        on_delete(self, field, sub_objs, self.using)
+                        on_delete(self, field, sub_objs)
                     except ProtectedError as error:
                         key = f"'{field.model.__name__}.{field.name}'"
                         protected_objects[key] += error.protected_objects
@@ -352,7 +352,7 @@ class Collector:
             [(f"{related_field.name}__in", objs) for related_field in related_fields],
             connector=query_utils.Q.OR,
         )
-        return related_model._base_manager.using(self.using).filter(predicate)
+        return related_model._base_manager.filter(predicate)
 
     def sort(self):
         sorted_models = []
@@ -388,17 +388,15 @@ class Collector:
         if len(self.data) == 1 and len(instances) == 1:
             instance = list(instances)[0]
             if self.can_fast_delete(instance):
-                with transaction.mark_for_rollback_on_error(self.using):
-                    count = sql.DeleteQuery(model).delete_batch(
-                        [instance.pk], self.using
-                    )
+                with transaction.mark_for_rollback_on_error():
+                    count = sql.DeleteQuery(model).delete_batch([instance.pk])
                 setattr(instance, model._meta.pk.attname, None)
                 return count, {model._meta.label: count}
 
-        with transaction.atomic(using=self.using, savepoint=False):
+        with transaction.atomic(savepoint=False):
             # fast deletes
             for qs in self.fast_deletes:
-                count = qs._raw_delete(using=self.using)
+                count = qs._raw_delete()
                 if count:
                     deleted_counter[qs.model._meta.label] += count
 
@@ -421,7 +419,7 @@ class Collector:
                     model = objs[0].__class__
                     query = sql.UpdateQuery(model)
                     query.update_batch(
-                        list({obj.pk for obj in objs}), {field.name: value}, self.using
+                        list({obj.pk for obj in objs}), {field.name: value}
                     )
 
             # reverse instance collections
@@ -432,7 +430,7 @@ class Collector:
             for model, instances in self.data.items():
                 query = sql.DeleteQuery(model)
                 pk_list = [obj.pk for obj in instances]
-                count = query.delete_batch(pk_list, self.using)
+                count = query.delete_batch(pk_list)
                 if count:
                     deleted_counter[model._meta.label] += count
 

plain/models/expressions.py

@@ -12,10 +12,9 @@ from plain.exceptions import EmptyResultSet, FieldError, FullResultSet
 from plain.models import fields
 from plain.models.constants import LOOKUP_SEP
 from plain.models.db import (
-    DEFAULT_DB_ALIAS,
     DatabaseError,
     NotSupportedError,
-    connections,
+    db_connection,
 )
 from plain.models.query_utils import Q
 from plain.utils.deconstruct import deconstructible
@@ -1782,20 +1781,18 @@ class WindowFrame(Expression):
 
     def __str__(self):
         if self.start.value is not None and self.start.value < 0:
-            start = (
-                f"{abs(self.start.value)} {connections[DEFAULT_DB_ALIAS].ops.PRECEDING}"
-            )
+            start = f"{abs(self.start.value)} {db_connection.ops.PRECEDING}"
         elif self.start.value is not None and self.start.value == 0:
-            start = connections[DEFAULT_DB_ALIAS].ops.CURRENT_ROW
+            start = db_connection.ops.CURRENT_ROW
         else:
-            start = connections[DEFAULT_DB_ALIAS].ops.UNBOUNDED_PRECEDING
+            start = db_connection.ops.UNBOUNDED_PRECEDING
 
         if self.end.value is not None and self.end.value > 0:
-            end = f"{self.end.value} {connections[DEFAULT_DB_ALIAS].ops.FOLLOWING}"
+            end = f"{self.end.value} {db_connection.ops.FOLLOWING}"
         elif self.end.value is not None and self.end.value == 0:
-            end = connections[DEFAULT_DB_ALIAS].ops.CURRENT_ROW
+            end = db_connection.ops.CURRENT_ROW
         else:
-            end = connections[DEFAULT_DB_ALIAS].ops.UNBOUNDED_FOLLOWING
+            end = db_connection.ops.UNBOUNDED_FOLLOWING
         return self.template % {
             "frame_type": self.frame_type,
             "start": start,

plain/models/fields/__init__.py

@@ -11,7 +11,7 @@ from functools import cached_property, partialmethod, total_ordering
 
 from plain import exceptions, preflight, validators
 from plain.models.constants import LOOKUP_SEP
-from plain.models.db import DEFAULT_DB_ALIAS, connections, router
+from plain.models.db import db_connection
 from plain.models.enums import ChoicesMeta
 from plain.models.query_utils import DeferredAttribute, RegisterLookupMixin
 from plain.utils import timezone
@@ -346,35 +346,29 @@ class Field(RegisterLookupMixin):
             )
         ]
 
-    def _check_db_comment(self, databases=None, **kwargs):
-        if not self.db_comment or not databases:
+    def _check_db_comment(self, database=False, **kwargs):
+        if not self.db_comment or not database:
             return []
         errors = []
-        for db in databases:
-            if not router.allow_migrate_model(db, self.model):
-                continue
-            connection = connections[db]
-            if not (
-                connection.features.supports_comments
-                or "supports_comments" in self.model._meta.required_db_features
-            ):
-                errors.append(
-                    preflight.Warning(
-                        f"{connection.display_name} does not support comments on "
-                        f"columns (db_comment).",
-                        obj=self,
-                        id="fields.W163",
-                    )
+        if not (
+            db_connection.features.supports_comments
+            or "supports_comments" in self.model._meta.required_db_features
+        ):
+            errors.append(
+                preflight.Warning(
+                    f"{db_connection.display_name} does not support comments on "
+                    f"columns (db_comment).",
+                    obj=self,
+                    id="fields.W163",
                 )
+            )
         return errors
 
     def _check_null_allowed_for_primary_keys(self):
         if (
             self.primary_key
             and self.allow_null
-            and not connections[
-                DEFAULT_DB_ALIAS
-            ].features.interprets_empty_strings_as_nulls
+            and not db_connection.features.interprets_empty_strings_as_nulls
         ):
             # We cannot reliably check this for backends like Oracle which
             # consider NULL and '' to be equal (and thus set up
@@ -393,13 +387,11 @@ class Field(RegisterLookupMixin):
         else:
             return []
 
-    def _check_backend_specific_checks(self, databases=None, **kwargs):
-        if databases is None:
+    def _check_backend_specific_checks(self, database=False, **kwargs):
+        if not database:
             return []
         errors = []
-        for alias in databases:
-            if router.allow_migrate_model(alias, self.model):
-                errors.extend(connections[alias].validation.check_field(self, **kwargs))
+        errors.extend(db_connection.validation.check_field(self, **kwargs))
         return errors
 
     def _check_validators(self):
@@ -896,9 +888,7 @@ class Field(RegisterLookupMixin):
         if (
             not self.empty_strings_allowed
             or self.allow_null
-            and not connections[
-                DEFAULT_DB_ALIAS
-            ].features.interprets_empty_strings_as_nulls
+            and not db_connection.features.interprets_empty_strings_as_nulls
         ):
             return return_None
         return str  # return empty string
@@ -1015,17 +1005,17 @@ class CharField(Field):
             return "String (unlimited)"
 
     def check(self, **kwargs):
-        databases = kwargs.get("databases") or []
+        database = kwargs.get("database", False)
         return [
             *super().check(**kwargs),
-            *self._check_db_collation(databases),
+            *self._check_db_collation(database),
             *self._check_max_length_attribute(**kwargs),
         ]
 
     def _check_max_length_attribute(self, **kwargs):
         if self.max_length is None:
             if (
-                connections[DEFAULT_DB_ALIAS].features.supports_unlimited_charfield
+                db_connection.features.supports_unlimited_charfield
                 or "supports_unlimited_charfield"
                 in self.model._meta.required_db_features
             ):
@@ -1052,26 +1042,22 @@ class CharField(Field):
         else:
             return []
 
-    def _check_db_collation(self, databases):
+    def _check_db_collation(self, database):
         errors = []
-        for db in databases:
-            if not router.allow_migrate_model(db, self.model):
-                continue
-            connection = connections[db]
-            if not (
-                self.db_collation is None
-                or "supports_collation_on_charfield"
-                in self.model._meta.required_db_features
-                or connection.features.supports_collation_on_charfield
-            ):
-                errors.append(
-                    preflight.Error(
-                        f"{connection.display_name} does not support a database collation on "
-                        "CharFields.",
-                        obj=self,
-                        id="fields.E190",
-                    ),
-                )
+        if database and not (
+            self.db_collation is None
+            or "supports_collation_on_charfield"
+            in self.model._meta.required_db_features
+            or db_connection.features.supports_collation_on_charfield
+        ):
+            errors.append(
+                preflight.Error(
+                    f"{db_connection.display_name} does not support a database collation on "
+                    "CharFields.",
+                    obj=self,
+                    id="fields.E190",
+                ),
+            )
         return errors
 
     def cast_db_type(self, connection):
@@ -1716,12 +1702,10 @@ class IntegerField(Field):
     @cached_property
     def validators(self):
         # These validators can't be added at field initialization time since
-        # they're based on values retrieved from `connections[DEFAULT_DB_ALIAS]`.
+        # they're based on values retrieved from the database connection.
         validators_ = super().validators
         internal_type = self.get_internal_type()
-        min_value, max_value = connections[DEFAULT_DB_ALIAS].ops.integer_field_range(
-            internal_type
-        )
+        min_value, max_value = db_connection.ops.integer_field_range(internal_type)
         if min_value is not None and not any(
             (
                 isinstance(validator, validators.MinValueValidator)
@@ -1993,32 +1977,28 @@ class TextField(Field):
         self.db_collation = db_collation
 
     def check(self, **kwargs):
-        databases = kwargs.get("databases") or []
+        database = kwargs.get("database", False)
         return [
             *super().check(**kwargs),
-            *self._check_db_collation(databases),
+            *self._check_db_collation(database),
         ]
 
-    def _check_db_collation(self, databases):
+    def _check_db_collation(self, database):
         errors = []
-        for db in databases:
-            if not router.allow_migrate_model(db, self.model):
-                continue
-            connection = connections[db]
-            if not (
-                self.db_collation is None
-                or "supports_collation_on_textfield"
-                in self.model._meta.required_db_features
-                or connection.features.supports_collation_on_textfield
-            ):
-                errors.append(
-                    preflight.Error(
-                        f"{connection.display_name} does not support a database collation on "
-                        "TextFields.",
-                        obj=self,
-                        id="fields.E190",
-                    ),
-                )
+        if database and not (
+            self.db_collation is None
+            or "supports_collation_on_textfield"
+            in self.model._meta.required_db_features
+            or db_connection.features.supports_collation_on_textfield
+        ):
+            errors.append(
+                preflight.Error(
+                    f"{db_connection.display_name} does not support a database collation on "
+                    "TextFields.",
+                    obj=self,
+                    id="fields.E190",
+                ),
+            )
         return errors
 
     def db_parameters(self, connection):

plain/models/fields/json.py

@@ -3,7 +3,7 @@ import json
 from plain import exceptions, preflight
 from plain.models import expressions, lookups
 from plain.models.constants import LOOKUP_SEP
-from plain.models.db import NotSupportedError, connections, router
+from plain.models.db import NotSupportedError, db_connection
 from plain.models.fields import TextField
 from plain.models.lookups import (
     FieldGetDbPrepValueMixin,
@@ -42,28 +42,25 @@ class JSONField(CheckFieldDefaultMixin, Field):
 
     def check(self, **kwargs):
         errors = super().check(**kwargs)
-        databases = kwargs.get("databases") or []
-        errors.extend(self._check_supported(databases))
+        database = kwargs.get("database", False)
+        errors.extend(self._check_supported(database))
         return errors
 
-    def _check_supported(self, databases):
+    def _check_supported(self, database):
         errors = []
-        for db in databases:
-            if not router.allow_migrate_model(db, self.model):
-                continue
-            connection = connections[db]
+        if database:
             if (
                 self.model._meta.required_db_vendor
-                and self.model._meta.required_db_vendor != connection.vendor
+                and self.model._meta.required_db_vendor != db_connection.vendor
             ):
-                continue
+                return errors
             if not (
                 "supports_json_field" in self.model._meta.required_db_features
-                or connection.features.supports_json_field
+                or db_connection.features.supports_json_field
             ):
                 errors.append(
                     preflight.Error(
-                        f"{connection.display_name} does not support JSONFields.",
+                        f"{db_connection.display_name} does not support JSONFields.",
                         obj=self.model,
                         id="fields.E180",
                     )

plain/models/fields/related.py

@@ -4,11 +4,10 @@ from functools import cached_property, partial
 
 from plain import exceptions, preflight
 from plain.models.constants import LOOKUP_SEP
-from plain.models.db import router
 from plain.models.deletion import SET_DEFAULT, SET_NULL
 from plain.models.query_utils import PathInfo, Q
 from plain.models.utils import make_model_tuple
-from plain.runtime import SettingsReference, settings
+from plain.runtime import SettingsReference
 
 from ..registry import models_registry
 from . import Field
@@ -929,8 +928,7 @@ class ForeignKey(ForeignObject):
         if value is None:
             return
 
-        using = router.db_for_read(self.remote_field.model, instance=model_instance)
-        qs = self.remote_field.model._base_manager.using(using).filter(
+        qs = self.remote_field.model._base_manager.filter(
             **{self.remote_field.field_name: value}
         )
         qs = qs.complex_filter(self.get_limit_choices_to())
@@ -1373,23 +1371,13 @@ class ManyToManyField(RelatedField):
             != self.remote_field.through._meta.concrete_model
         ):
             clashing_obj = model._meta.label
-            if settings.DATABASE_ROUTERS:
-                error_class, error_id = preflight.Warning, "fields.W344"
-                error_hint = (
-                    "You have configured settings.DATABASE_ROUTERS. Verify "
-                    f"that the table of {clashing_obj!r} is correctly routed to a separate "
-                    "database."
-                )
-            else:
-                error_class, error_id = preflight.Error, "fields.E340"
-                error_hint = None
             return [
-                error_class(
+                preflight.Error(
                     f"The field's intermediary table '{m2m_db_table}' clashes with the "
                     f"table name of '{clashing_obj}'.",
                     obj=self,
-                    hint=error_hint,
-                    id=error_id,
+                    hint=None,
+                    id="fields.E340",
                 )
             ]
         return []