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

plain/models/cli.py

@@ -14,7 +14,7 @@ from plain.utils.text import Truncator
 from . import migrations
 from .backups.cli import cli as backups_cli
 from .backups.cli import create_backup
-from .db import DEFAULT_DB_ALIAS, OperationalError, connections, router
+from .db import OperationalError, db_connection
 from .migrations.autodetector import MigrationAutodetector
 from .migrations.executor import MigrationExecutor
 from .migrations.loader import AmbiguityError, MigrationLoader
@@ -42,27 +42,18 @@ cli.add_command(backups_cli)
 
 
 @cli.command()
-@click.option(
-    "--database",
-    default=DEFAULT_DB_ALIAS,
-    help=(
-        "Nominates a database onto which to open a shell. Defaults to the "
-        '"default" database.'
-    ),
-)
 @click.argument("parameters", nargs=-1)
-def db_shell(database, parameters):
+def db_shell(parameters):
     """Runs the command-line client for specified database, or the default database if none is provided."""
-    connection = connections[database]
     try:
-        connection.client.runshell(parameters)
+        db_connection.client.runshell(parameters)
     except FileNotFoundError:
         # Note that we're assuming the FileNotFoundError relates to the
         # command missing. It could be raised for some other reason, in
         # which case this error message would be inaccurate. Still, this
         # message catches the common case.
         click.secho(
-            f"You appear not to have the {connection.client.executable_name!r} program installed or on your path.",
+            f"You appear not to have the {db_connection.client.executable_name!r} program installed or on your path.",
             fg="red",
             err=True,
         )
@@ -85,24 +76,23 @@ def db_wait():
     attempts = 0
     while True:
         attempts += 1
-        waiting_for = []
+        waiting_for = False
 
-        for conn in connections.all():
-            try:
-                conn.ensure_connection()
-            except OperationalError:
-                waiting_for.append(conn.alias)
+        try:
+            db_connection.ensure_connection()
+        except OperationalError:
+            waiting_for = True
 
         if waiting_for:
             if attempts > 1:
                 # After the first attempt, start printing them
                 click.secho(
-                    f"Waiting for database (attempt {attempts}): {', '.join(waiting_for)}",
+                    f"Waiting for database (attempt {attempts})",
                     fg="yellow",
                 )
             time.sleep(1.5)
         else:
-            click.secho(f"Database ready: {', '.join(connections)}", fg="green")
+            click.secho("Database ready", fg="green")
             break
 
 
@@ -318,21 +308,8 @@ def makemigrations(
     loader = MigrationLoader(None, ignore_no_migrations=True)
 
     # Raise an error if any migrations are applied before their dependencies.
-    consistency_check_labels = {
-        config.package_label for config in packages_registry.get_package_configs()
-    }
-    # Non-default databases are only checked if database routers used.
-    aliases_to_check = connections if settings.DATABASE_ROUTERS else [DEFAULT_DB_ALIAS]
-    for alias in sorted(aliases_to_check):
-        connection = connections[alias]
-        if any(
-            router.allow_migrate(
-                connection.alias, package_label, model_name=model._meta.object_name
-            )
-            for package_label in consistency_check_labels
-            for model in models_registry.get_models(package_label=package_label)
-        ):
-            loader.check_consistent_history(connection)
+    # Only the default db_connection is supported.
+    loader.check_consistent_history(db_connection)
 
     # Check for conflicts
     conflicts = loader.detect_conflicts()
@@ -422,11 +399,6 @@ def makemigrations(
 @cli.command()
 @click.argument("package_label", required=False)
 @click.argument("migration_name", required=False)
-@click.option(
-    "--database",
-    default=DEFAULT_DB_ALIAS,
-    help="Nominates a database to synchronize. Defaults to the 'default' database.",
-)
 @click.option(
     "--fake", is_flag=True, help="Mark migrations as run without actually running them."
 )
@@ -468,7 +440,6 @@ def makemigrations(
 def migrate(
     package_label,
     migration_name,
-    database,
     fake,
     fake_initial,
     plan,
@@ -512,16 +483,14 @@ def migrate(
         return prefix + operation.describe() + truncated.chars(40), is_error
 
     # Get the database we're operating from
-    connection = connections[database]
-
     # Hook for backends needing any database preparation
-    connection.prepare_database()
+    db_connection.prepare_database()
 
     # Work out which packages have migrations and which do not
-    executor = MigrationExecutor(connection, migration_progress_callback)
+    executor = MigrationExecutor(db_connection, migration_progress_callback)
 
     # Raise an error if any migrations are applied before their dependencies.
-    executor.loader.check_consistent_history(connection)
+    executor.loader.check_consistent_history(db_connection)
 
     # Before anything else, see if there's conflicting packages and drop out
     # hard if there are any
@@ -864,11 +833,6 @@ def optimize_migration(package_label, migration_name, check, verbosity):
 
 @cli.command()
 @click.argument("package_labels", nargs=-1)
-@click.option(
-    "--database",
-    default=DEFAULT_DB_ALIAS,
-    help="Nominates a database to show migrations for. Defaults to the 'default' database.",
-)
 @click.option(
     "--format",
     type=click.Choice(["list", "plan"]),
@@ -882,7 +846,7 @@ def optimize_migration(package_label, migration_name, check, verbosity):
     default=1,
     help="Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output",
 )
-def show_migrations(package_labels, database, format, verbosity):
+def show_migrations(package_labels, format, verbosity):
     """Shows all available migrations for the current project"""
 
     def _validate_package_names(package_names):
@@ -896,14 +860,14 @@ def show_migrations(package_labels, database, format, verbosity):
         if has_bad_names:
             sys.exit(2)
 
-    def show_list(connection, package_names):
+    def show_list(db_connection, package_names):
         """
         Show a list of all migrations on the system, or only those of
         some named packages.
         """
         # Load migrations from disk/DB
-        loader = MigrationLoader(connection, ignore_no_migrations=True)
-        recorder = MigrationRecorder(connection)
+        loader = MigrationLoader(db_connection, ignore_no_migrations=True)
+        recorder = MigrationRecorder(db_connection)
         recorded_migrations = recorder.applied_migrations()
 
         graph = loader.graph
@@ -972,13 +936,13 @@ def show_migrations(package_labels, database, format, verbosity):
                 for name in sorted(prunable_by_package[package]):
                     click.echo(f"    - {name}")
 
-    def show_plan(connection, package_names):
+    def show_plan(db_connection, package_names):
         """
         Show all known migrations (or only those of the specified package_names)
         in the order they will be applied.
         """
         # Load migrations from disk/DB
-        loader = MigrationLoader(connection)
+        loader = MigrationLoader(db_connection)
         graph = loader.graph
         if package_names:
             _validate_package_names(package_names)
@@ -1017,12 +981,11 @@ def show_migrations(package_labels, database, format, verbosity):
             click.secho("(no migrations)", fg="red")
 
     # Get the database we're operating from
-    connection = connections[database]
 
     if format == "plan":
-        show_plan(connection, package_labels)
+        show_plan(db_connection, package_labels)
     else:
-        show_list(connection, package_labels)
+        show_list(db_connection, package_labels)
 
 
 @cli.command()
@@ -1082,7 +1045,7 @@ def squash_migrations(
         raise click.ClickException(str(err))
 
     # Load the current graph state, check the app and migration they asked for exists
-    loader = MigrationLoader(connections[DEFAULT_DB_ALIAS])
+    loader = MigrationLoader(db_connection)
     if package_label not in loader.migrated_packages:
         raise click.ClickException(
             f"Package '{package_label}' does not have migrations (so squashmigrations on it makes no sense)"

plain/models/connections.py

@@ -1,15 +1,8 @@
-from functools import cached_property
 from importlib import import_module
 from threading import local
 from typing import Any, TypedDict
 
-from plain.exceptions import ImproperlyConfigured
 from plain.runtime import settings as plain_settings
-from plain.utils.module_loading import import_string
-
-from .exceptions import ConnectionDoesNotExist
-
-DEFAULT_DB_ALIAS = "default"
 
 
 class DatabaseConfig(TypedDict, total=False):
@@ -28,167 +21,57 @@ class DatabaseConfig(TypedDict, total=False):
     USER: str
 
 
-class ConnectionHandler:
-    """
-    Handler for database connections. Provides lazy connection creation
-    and convenience methods for managing multiple database connections.
-    """
+class DatabaseConnection:
+    """Lazy access to the single configured database connection."""
 
-    def __init__(self):
-        self._settings: dict[str, DatabaseConfig] = {}
-        self._connections = local()
+    __slots__ = ("_settings", "_local")
 
-    @cached_property
-    def settings(self) -> DatabaseConfig:
-        self._settings = self.configure_settings()
-        return self._settings
+    def __init__(self):
+        self._settings: DatabaseConfig = {}
+        self._local = local()
 
     def configure_settings(self) -> DatabaseConfig:
-        databases = plain_settings.DATABASES
-
-        if DEFAULT_DB_ALIAS not in databases:
-            raise ImproperlyConfigured(
-                f"You must define a '{DEFAULT_DB_ALIAS}' database."
-            )
-
-        # Configure default settings.
-        for conn in databases.values():
-            conn.setdefault("AUTOCOMMIT", True)
-            conn.setdefault("CONN_MAX_AGE", 0)
-            conn.setdefault("CONN_HEALTH_CHECKS", False)
-            conn.setdefault("OPTIONS", {})
-            conn.setdefault("TIME_ZONE", None)
-            for setting in ["NAME", "USER", "PASSWORD", "HOST", "PORT"]:
-                conn.setdefault(setting, "")
-
-            test_settings = conn.setdefault("TEST", {})
-            default_test_settings = [
-                ("CHARSET", None),
-                ("COLLATION", None),
-                ("MIRROR", None),
-                ("NAME", None),
-            ]
-            for key, value in default_test_settings:
-                test_settings.setdefault(key, value)
-
-        return databases
-
-    def create_connection(self, alias):
-        database_config = self.settings[alias]
-        backend = import_module(f"{database_config['ENGINE']}.base")
-        return backend.DatabaseWrapper(database_config, alias)
-
-    def __getitem__(self, alias):
-        try:
-            return getattr(self._connections, alias)
-        except AttributeError:
-            if alias not in self.settings:
-                raise ConnectionDoesNotExist(f"The connection '{alias}' doesn't exist.")
-        conn = self.create_connection(alias)
-        setattr(self._connections, alias, conn)
-        return conn
-
-    def __setitem__(self, key, value):
-        setattr(self._connections, key, value)
-
-    def __delitem__(self, key):
-        delattr(self._connections, key)
-
-    def __iter__(self):
-        return iter(self.settings)
-
-    def all(self, initialized_only=False):
-        return [
-            self[alias]
-            for alias in self
-            # If initialized_only is True, return only initialized connections.
-            if not initialized_only or hasattr(self._connections, alias)
+        database = plain_settings.DATABASE
+
+        database.setdefault("AUTOCOMMIT", True)
+        database.setdefault("CONN_MAX_AGE", 0)
+        database.setdefault("CONN_HEALTH_CHECKS", False)
+        database.setdefault("OPTIONS", {})
+        database.setdefault("TIME_ZONE", None)
+        for setting in ["NAME", "USER", "PASSWORD", "HOST", "PORT"]:
+            database.setdefault(setting, "")
+
+        test_settings = database.setdefault("TEST", {})
+        default_test_settings = [
+            ("CHARSET", None),
+            ("COLLATION", None),
+            ("MIRROR", None),
+            ("NAME", None),
         ]
+        for key, value in default_test_settings:
+            test_settings.setdefault(key, value)
+
+        return database
+
+    def create_connection(self):
+        database_config = self.configure_settings()
+        backend = import_module(f"{database_config['ENGINE']}.base")
+        return backend.DatabaseWrapper(database_config)
+
+    def has_connection(self):
+        return hasattr(self._local, "conn")
+
+    def __getattr__(self, attr):
+        if not self.has_connection():
+            self._local.conn = self.create_connection()
+
+        return getattr(self._local.conn, attr)
+
+    def __setattr__(self, name, value):
+        if name.startswith("_"):
+            super().__setattr__(name, value)
+        else:
+            if not self.has_connection():
+                self._local.conn = self.create_connection()
 
-    def close_all(self):
-        for conn in self.all(initialized_only=True):
-            conn.close()
-
-
-class ConnectionRouter:
-    def __init__(self, routers=None):
-        """
-        If routers is not specified, default to settings.DATABASE_ROUTERS.
-        """
-        self._routers = routers
-
-    @cached_property
-    def routers(self):
-        if self._routers is None:
-            self._routers = plain_settings.DATABASE_ROUTERS
-        routers = []
-        for r in self._routers:
-            if isinstance(r, str):
-                router = import_string(r)()
-            else:
-                router = r
-            routers.append(router)
-        return routers
-
-    def _router_func(action):
-        def _route_db(self, model, **hints):
-            chosen_db = None
-            for router in self.routers:
-                try:
-                    method = getattr(router, action)
-                except AttributeError:
-                    # If the router doesn't have a method, skip to the next one.
-                    pass
-                else:
-                    chosen_db = method(model, **hints)
-                    if chosen_db:
-                        return chosen_db
-            instance = hints.get("instance")
-            if instance is not None and instance._state.db:
-                return instance._state.db
-            return DEFAULT_DB_ALIAS
-
-        return _route_db
-
-    db_for_read = _router_func("db_for_read")
-    db_for_write = _router_func("db_for_write")
-
-    def allow_relation(self, obj1, obj2, **hints):
-        for router in self.routers:
-            try:
-                method = router.allow_relation
-            except AttributeError:
-                # If the router doesn't have a method, skip to the next one.
-                pass
-            else:
-                allow = method(obj1, obj2, **hints)
-                if allow is not None:
-                    return allow
-        return obj1._state.db == obj2._state.db
-
-    def allow_migrate(self, db, package_label, **hints):
-        for router in self.routers:
-            try:
-                method = router.allow_migrate
-            except AttributeError:
-                # If the router doesn't have a method, skip to the next one.
-                continue
-
-            allow = method(db, package_label, **hints)
-
-            if allow is not None:
-                return allow
-        return True
-
-    def allow_migrate_model(self, db, model):
-        return self.allow_migrate(
-            db,
-            model._meta.package_label,
-            model_name=model._meta.model_name,
-            model=model,
-        )
-
-    def get_migratable_models(self, models_registry, package_label, db):
-        """Return app models allowed to be migrated on provided db."""
-        models = models_registry.get_models(package_label=package_label)
-        return [model for model in models if self.allow_migrate_model(db, model)]
+            setattr(self._local.conn, name, value)

plain/models/constraints.py

@@ -2,7 +2,7 @@ from enum import Enum
 from types import NoneType
 
 from plain.exceptions import FieldError, ValidationError
-from plain.models.db import DEFAULT_DB_ALIAS, connections
+from plain.models.db import db_connection
 from plain.models.expressions import Exists, ExpressionList, F, OrderBy
 from plain.models.indexes import IndexExpression
 from plain.models.lookups import Exact
@@ -41,7 +41,7 @@ class BaseConstraint:
     def remove_sql(self, model, schema_editor):
         raise NotImplementedError("This method must be implemented by a subclass.")
 
-    def validate(self, model, instance, exclude=None, using=DEFAULT_DB_ALIAS):
+    def validate(self, model, instance, exclude=None):
         raise NotImplementedError("This method must be implemented by a subclass.")
 
     def get_violation_error_message(self):
@@ -83,7 +83,7 @@ class CheckConstraint(BaseConstraint):
     def _get_check_sql(self, model, schema_editor):
         query = Query(model=model, alias_cols=False)
         where = query.build_where(self.check)
-        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)
 
@@ -98,10 +98,10 @@ class CheckConstraint(BaseConstraint):
     def remove_sql(self, model, schema_editor):
         return schema_editor._delete_check_sql(model, self.name)
 
-    def validate(self, model, instance, exclude=None, using=DEFAULT_DB_ALIAS):
+    def validate(self, model, instance, exclude=None):
         against = instance._get_field_value_map(meta=model._meta, exclude=exclude)
         try:
-            if not Q(self.check).check(against, using=using):
+            if not Q(self.check).check(against):
                 raise ValidationError(
                     self.get_violation_error_message(), code=self.violation_error_code
                 )
@@ -227,7 +227,7 @@ class UniqueConstraint(BaseConstraint):
             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)
 
@@ -347,8 +347,8 @@ class UniqueConstraint(BaseConstraint):
             kwargs["opclasses"] = self.opclasses
         return path, self.expressions, kwargs
 
-    def validate(self, model, instance, exclude=None, using=DEFAULT_DB_ALIAS):
-        queryset = model._default_manager.using(using)
+    def validate(self, model, instance, exclude=None):
+        queryset = model._default_manager
         if self.fields:
             lookup_kwargs = {}
             for field_name in self.fields:
@@ -358,7 +358,7 @@ class UniqueConstraint(BaseConstraint):
                 lookup_value = getattr(instance, field.attname)
                 if lookup_value is None or (
                     lookup_value == ""
-                    and connections[using].features.interprets_empty_strings_as_nulls
+                    and db_connection.features.interprets_empty_strings_as_nulls
                 ):
                     # A composite constraint containing NULL value cannot cause
                     # a violation since NULL != NULL in SQL.
@@ -410,7 +410,7 @@ class UniqueConstraint(BaseConstraint):
             against = instance._get_field_value_map(meta=model._meta, exclude=exclude)
             try:
                 if (self.condition & Exists(queryset.filter(self.condition))).check(
-                    against, using=using
+                    against
                 ):
                     raise ValidationError(
                         self.get_violation_error_message(),

plain/models/db.py

@@ -1,10 +1,6 @@
 from plain import signals
 
-from .connections import (
-    DEFAULT_DB_ALIAS,
-    ConnectionHandler,
-    ConnectionRouter,
-)
+from .connections import DatabaseConnection
 from .exceptions import (
     ConnectionDoesNotExist,
     DatabaseError,
@@ -22,15 +18,13 @@ from .exceptions import (
 PLAIN_VERSION_PICKLE_KEY = "_plain_version"
 
 
-connections = ConnectionHandler()
-
-router = ConnectionRouter()
+db_connection = DatabaseConnection()
 
 
 # Register an event to reset saved queries when a Plain request is started.
 def reset_queries(**kwargs):
-    for conn in connections.all(initialized_only=True):
-        conn.queries_log.clear()
+    if db_connection.has_connection():
+        db_connection.queries_log.clear()
 
 
 signals.request_started.connect(reset_queries)
@@ -39,8 +33,8 @@ signals.request_started.connect(reset_queries)
 # Register an event to reset transaction state and close connections past
 # their lifetime.
 def close_old_connections(**kwargs):
-    for conn in connections.all(initialized_only=True):
-        conn.close_if_unusable_or_obsolete()
+    if db_connection.has_connection():
+        db_connection.close_if_unusable_or_obsolete()
 
 
 signals.request_started.connect(close_old_connections)
@@ -48,9 +42,7 @@ signals.request_finished.connect(close_old_connections)
 
 
 __all__ = [
-    "connections",
-    "router",
-    "DEFAULT_DB_ALIAS",
+    "db_connection",
     "PLAIN_VERSION_PICKLE_KEY",
     "Error",
     "InterfaceError",

plain/models/default_settings.py

@@ -2,25 +2,18 @@ from os import environ
 
 from . import database_url
 
-# Make DATABASES a required setting
-DATABASES: dict
+# Make DATABASE a required setting
+DATABASE: dict
 
-# Automatically configure DATABASES if a DATABASE_URL was given in the environment
+# Automatically configure DATABASE if a DATABASE_URL was given in the environment
 if "DATABASE_URL" in environ:
-    DATABASES = {
-        "default": database_url.parse_database_url(
-            environ["DATABASE_URL"],
-            # Enable persistent connections by default
-            conn_max_age=int(environ.get("DATABASE_CONN_MAX_AGE", 600)),
-            conn_health_checks=environ.get(
-                "DATABASE_CONN_HEALTH_CHECKS", "true"
-            ).lower()
-            in [
-                "true",
-                "1",
-            ],
-        )
-    }
-
-# Classes used to implement DB routing behavior.
-DATABASE_ROUTERS = []
+    DATABASE = database_url.parse_database_url(
+        environ["DATABASE_URL"],
+        # Enable persistent connections by default
+        conn_max_age=int(environ.get("DATABASE_CONN_MAX_AGE", 600)),
+        conn_health_checks=environ.get("DATABASE_CONN_HEALTH_CHECKS", "true").lower()
+        in [
+            "true",
+            "1",
+        ],
+    )