plain.models 0.51.0__tar.gz → 0.52.0__tar.gz

{plain_models-0.51.0 → plain_models-0.52.0}/PKG-INFO

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

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/CHANGELOG.md

@@ -1,5 +1,27 @@
 # plain-models changelog
 
+## [0.52.0](https://github.com/dropseed/plain/releases/plain-models@0.52.0) (2025-10-10)
+
+### What's changed
+
+- The `plain migrate` command now shows detailed operation descriptions and SQL statements for each migration step, replacing the previous verbosity levels with a cleaner `--quiet` flag ([d6b041bd24](https://github.com/dropseed/plain/commit/d6b041bd24))
+- Migration output format has been improved to display each operation's description and the actual SQL being executed, making it easier to understand what changes are being made to the database ([d6b041bd24](https://github.com/dropseed/plain/commit/d6b041bd24))
+- The `-v/--verbosity` option has been removed from `plain migrate` in favor of the simpler `--quiet` flag for suppressing output ([d6b041bd24](https://github.com/dropseed/plain/commit/d6b041bd24))
+
+### Upgrade instructions
+
+- Replace any usage of `-v` or `--verbosity` flags in `plain migrate` commands with `--quiet` if you want to suppress migration output
+
+## [0.51.1](https://github.com/dropseed/plain/releases/plain-models@0.51.1) (2025-10-08)
+
+### What's changed
+
+- Fixed a bug in `Subquery` and `Exists` expressions that was using the old `query` attribute name instead of `sql_query` when extracting the SQL query from a QuerySet ([79ca52d](https://github.com/dropseed/plain/commit/79ca52d32e))
+
+### Upgrade instructions
+
+- No changes required
+
 ## [0.51.0](https://github.com/dropseed/plain/releases/plain-models@0.51.0) (2025-10-07)
 
 ### What's changed

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/backends/base/creation.py

@@ -52,9 +52,6 @@ class BaseDatabaseCreation:
         settings.DATABASE["NAME"] = test_database_name
         self.connection.settings_dict["NAME"] = test_database_name
 
-        # We report migrate messages at one level lower than that
-        # requested. This ensures we don't get flooded with messages during
-        # testing (unless you really ask to be flooded).
         migrate.callback(
             package_label=None,
             migration_name=None,
@@ -64,8 +61,8 @@ class BaseDatabaseCreation:
             backup=False,
             prune=False,
             no_input=True,
-            verbosity=max(verbosity - 1, 0),
             atomic_batch=False,  # No need for atomic batch when creating test database
+            quiet=verbosity < 2,  # Show migration output when verbosity is 2+
         )
 
         # Ensure a connection for the side effect of initializing the test database.

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/backends/base/schema.py

@@ -159,19 +159,16 @@ class BaseDatabaseSchemaEditor:
     def __init__(
         self,
         connection: BaseDatabaseWrapper,
-        collect_sql: bool = False,
         atomic: bool = True,
     ):
         self.connection = connection
-        self.collect_sql = collect_sql
-        if self.collect_sql:
-            self.collected_sql: list[str] = []
         self.atomic_migration = self.connection.features.can_rollback_ddl and atomic
 
     # State-managing methods
 
     def __enter__(self) -> BaseDatabaseSchemaEditor:
         self.deferred_sql: list[Any] = []
+        self.executed_sql: list[str] = []
         if self.atomic_migration:
             self.atomic = atomic()
             self.atomic.__enter__()
@@ -190,11 +187,8 @@ class BaseDatabaseSchemaEditor:
         self, sql: str | Statement, params: tuple[Any, ...] | list[Any] | None = ()
     ) -> None:
         """Execute the given SQL statement, with optional parameters."""
-        # Don't perform the transactional DDL check if SQL is being collected
-        # as it's not going to be executed anyway.
         if (
-            not self.collect_sql
-            and self.connection.in_atomic_block
+            self.connection.in_atomic_block
             and not self.connection.features.can_rollback_ddl
         ):
             raise TransactionManagementError(
@@ -207,17 +201,16 @@ class BaseDatabaseSchemaEditor:
         logger.debug(
             "%s; (params %r)", sql, params, extra={"params": params, "sql": sql}
         )
-        if self.collect_sql:
-            ending = "" if sql.rstrip().endswith(";") else ";"
-            if params is not None:
-                self.collected_sql.append(
-                    (sql % tuple(map(self.quote_value, params))) + ending
-                )
-            else:
-                self.collected_sql.append(sql + ending)
+
+        # Track executed SQL for display in migration output
+        # Store the SQL for display (interpolate params for readability)
+        if params:
+            self.executed_sql.append(sql % tuple(map(self.quote_value, params)))
         else:
-            with self.connection.cursor() as cursor:
-                cursor.execute(sql, params)
+            self.executed_sql.append(sql)
+
+        with self.connection.cursor() as cursor:
+            cursor.execute(sql, params)
 
     def quote_name(self, name: str) -> str:
         return self.connection.ops.quote_name(name)

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/cli.py

@@ -15,7 +15,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 .backups.core import DatabaseBackups
 from .db import OperationalError
 from .db import db_connection as _db_connection
 from .migrations.autodetector import MigrationAutodetector
@@ -34,6 +34,7 @@ from .registry import models_registry
 
 if TYPE_CHECKING:
     from .backends.base.base import BaseDatabaseWrapper
+    from .migrations.operations.base import Operation
 
     db_connection = cast("BaseDatabaseWrapper", _db_connection)
 else:
@@ -377,18 +378,16 @@ def makemigrations(
     is_flag=True,
     help="Tells Plain to NOT prompt the user for input of any kind.",
 )
-@click.option(
-    "-v",
-    "--verbosity",
-    type=int,
-    default=1,
-    help="Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output",
-)
 @click.option(
     "--atomic-batch/--no-atomic-batch",
     default=None,
     help="Run migrations in a single transaction (auto-detected by default)",
 )
+@click.option(
+    "--quiet",
+    is_flag=True,
+    help="Suppress migration output (used for test database creation).",
+)
 def migrate(
     package_label: str | None,
     migration_name: str | None,
@@ -398,26 +397,42 @@ def migrate(
     backup: bool | None,
     prune: bool,
     no_input: bool,
-    verbosity: int,
     atomic_batch: bool | None,
+    quiet: bool,
 ) -> None:
     """Updates database schema. Manages both packages with migrations and those without."""
 
     def migration_progress_callback(
-        action: str, migration: Migration | None = None, fake: bool = False
+        action: str,
+        *,
+        migration: Migration | None = None,
+        fake: bool = False,
+        operation: Operation | None = None,
+        sql_statements: list[str] | None = None,
     ) -> None:
-        if verbosity >= 1:
-            if action == "apply_start":
-                click.echo(f"  Applying {migration}...", nl=False)
-            elif action == "apply_success":
-                if fake:
-                    click.echo(click.style(" FAKED", fg="green"))
-                else:
-                    click.echo(click.style(" OK", fg="green"))
-            elif action == "render_start":
-                click.echo("  Rendering model states...", nl=False)
-            elif action == "render_success":
-                click.echo(click.style(" DONE", fg="green"))
+        if quiet:
+            return
+
+        if action == "apply_start":
+            click.echo()  # Always add newline between migrations
+            if fake:
+                click.secho(f"{migration} (faked)", fg="cyan")
+            else:
+                click.secho(f"{migration}", fg="cyan")
+        elif action == "apply_success":
+            pass  # Already shown via operations
+        elif action == "operation_start":
+            click.echo(f"  {operation.describe()}", nl=False)
+            click.secho("... ", dim=True, nl=False)
+        elif action == "operation_success":
+            # Show SQL statements (no OK needed, SQL implies success)
+            if sql_statements:
+                click.echo()  # newline after "..."
+                for sql in sql_statements:
+                    click.secho(f"    {sql}", dim=True)
+            else:
+                # No SQL: just add a newline
+                click.echo()
 
     def describe_operation(operation: Any) -> tuple[str, bool]:
         """Return a string that describes a migration operation for --plan."""
@@ -509,8 +524,8 @@ def migrate(
             raise click.ClickException(
                 "Migrations can be pruned only when a package is specified."
             )
-        if verbosity > 0:
-            click.secho("Pruning migrations:", fg="cyan")
+        if not quiet:
+            click.secho("Pruning migrations:", bold=True)
         to_prune = set(executor.loader.applied_migrations) - set(  # type: ignore[arg-type]
             executor.loader.disk_migrations  # type: ignore[arg-type]
         )
@@ -520,25 +535,26 @@ def migrate(
             if any(replaced in to_prune for replaced in migration_obj.replaces)
         ]
         if squashed_migrations_with_deleted_replaced_migrations:
-            click.echo(
-                click.style(
-                    "  Cannot use --prune because the following squashed "
-                    "migrations have their 'replaces' attributes and may not "
-                    "be recorded as applied:",
-                    fg="yellow",
+            if not quiet:
+                click.echo(
+                    click.style(
+                        "  Cannot use --prune because the following squashed "
+                        "migrations have their 'replaces' attributes and may not "
+                        "be recorded as applied:",
+                        fg="yellow",
+                    )
                 )
-            )
-            for migration in squashed_migrations_with_deleted_replaced_migrations:
-                package, name = migration
-                click.echo(f"    {package}.{name}")
-            click.echo(
-                click.style(
-                    "  Re-run `plain migrate` if they are not marked as "
-                    "applied, and remove 'replaces' attributes in their "
-                    "Migration classes.",
-                    fg="yellow",
+                for migration in squashed_migrations_with_deleted_replaced_migrations:
+                    package, name = migration
+                    click.echo(f"    {package}.{name}")
+                click.echo(
+                    click.style(
+                        "  Re-run `plain migrate` if they are not marked as "
+                        "applied, and remove 'replaces' attributes in their "
+                        "Migration classes.",
+                        fg="yellow",
+                    )
                 )
-            )
         else:
             to_prune = sorted(
                 migration for migration in to_prune if migration[0] == package_label
@@ -546,32 +562,31 @@ def migrate(
             if to_prune:
                 for migration in to_prune:
                     package, name = migration
-                    if verbosity > 0:
-                        click.echo(
-                            click.style(f"  Pruning {package}.{name}", fg="yellow"),
-                            nl=False,
-                        )
+                    if not quiet:
+                        click.echo(f"  Pruning {package}.{name}...", nl=False)
                     executor.recorder.record_unapplied(package, name)
-                    if verbosity > 0:
-                        click.echo(click.style(" OK", fg="green"))
-            elif verbosity > 0:
-                click.echo("  No migrations to prune.")
+                    if not quiet:
+                        click.echo(" OK")
+            else:
+                if not quiet:
+                    click.echo("  No migrations to prune.")
 
     migration_plan = executor.migration_plan(targets)
 
     if plan:
-        click.secho("Planned operations:", fg="cyan")
-        if not migration_plan:
-            click.echo("  No planned migration operations.")
-        else:
-            for migration in migration_plan:
-                click.secho(str(migration), fg="cyan")
-                for operation in migration.operations:
-                    message, is_error = describe_operation(operation)
-                    if is_error:
-                        click.secho("    " + message, fg="yellow")
-                    else:
-                        click.echo("    " + message)
+        if not quiet:
+            click.secho("Planned operations:", fg="cyan")
+            if not migration_plan:
+                click.echo("  No planned migration operations.")
+            else:
+                for migration in migration_plan:
+                    click.secho(str(migration), fg="cyan")
+                    for operation in migration.operations:
+                        message, is_error = describe_operation(operation)
+                        if is_error:
+                            click.secho("    " + message, fg="yellow")
+                        else:
+                            click.echo("    " + message)
         if check_unapplied:
             sys.exit(1)
         return
@@ -585,29 +600,23 @@ def migrate(
         return
 
     # Print some useful info
-    if verbosity >= 1:
-        click.secho("Operations to perform:", fg="cyan")
-
+    if not quiet:
         if target_package_labels_only:
-            click.secho(
-                "  Apply all migrations: "
-                + (", ".join(sorted({a for a, n in targets})) or "(none)"),
-                fg="yellow",
-            )
+            packages = ", ".join(sorted({a for a, n in targets})) or "(none)"
+            click.secho("Packages: ", bold=True, nl=False)
+            click.secho(packages, dim=True)
+            click.echo()  # Add newline after packages
         else:
-            click.secho(
-                f"  Target specific migration: {targets[0][1]}, from {targets[0][0]}",
-                fg="yellow",
-            )
+            click.secho("Target: ", bold=True, nl=False)
+            click.secho(f"{targets[0][1]} from {targets[0][0]}", dim=True)
+            click.echo()  # Add newline after target
 
     pre_migrate_state = executor._create_project_state(with_applied_migrations=True)
 
-    # sql = executor.loader.collect_sql(migration_plan)
-    # pprint(sql)
-
     if migration_plan:
         # Determine whether to use atomic batch
         use_atomic_batch = False
+        atomic_batch_message = None
         if len(migration_plan) > 1:
             # Check database capabilities
             can_rollback_ddl = db_connection.features.can_rollback_ddl
@@ -632,58 +641,62 @@ def migrate(
                         f"--atomic-batch requested but these migrations have atomic=False: {names}"
                     )
                 use_atomic_batch = True
-                if verbosity >= 1:
-                    click.echo(
-                        f"  Running {len(migration_plan)} migrations in atomic batch (all-or-nothing)"
-                    )
+                atomic_batch_message = (
+                    f"Running {len(migration_plan)} migrations in atomic batch"
+                )
             elif atomic_batch is False:
                 # User explicitly disabled atomic batch
                 use_atomic_batch = False
-                if verbosity >= 1:
-                    click.echo(f"  Running {len(migration_plan)} migrations separately")
+                if len(migration_plan) > 1:
+                    atomic_batch_message = (
+                        f"Running {len(migration_plan)} migrations separately"
+                    )
             else:
                 # Auto-detect (atomic_batch is None)
                 if can_rollback_ddl and not non_atomic_migrations:
                     use_atomic_batch = True
-                    if verbosity >= 1:
-                        click.echo(
-                            f"  Running {len(migration_plan)} migrations in atomic batch (all-or-nothing)"
-                        )
+                    atomic_batch_message = (
+                        f"Running {len(migration_plan)} migrations in atomic batch"
+                    )
                 else:
                     use_atomic_batch = False
-                    if verbosity >= 1:
+                    if len(migration_plan) > 1:
                         if not can_rollback_ddl:
-                            click.echo(
-                                f"  Running {len(migration_plan)} migrations separately ({db_connection.vendor} doesn't support batch transactions)"
-                            )
+                            atomic_batch_message = f"Running {len(migration_plan)} migrations separately ({db_connection.vendor} doesn't support batch)"
                         elif non_atomic_migrations:
-                            click.echo(
-                                f"  Running {len(migration_plan)} migrations separately (some migrations have atomic=False)"
-                            )
+                            atomic_batch_message = f"Running {len(migration_plan)} migrations separately (some have atomic=False)"
                         else:
-                            click.echo(
-                                f"  Running {len(migration_plan)} migrations separately"
+                            atomic_batch_message = (
+                                f"Running {len(migration_plan)} migrations separately"
                             )
 
         if backup or (backup is None and settings.DEBUG):
             backup_name = f"migrate_{time.strftime('%Y%m%d_%H%M%S')}"
-            click.secho(
-                f"Creating backup before applying migrations: {backup_name}",
-                bold=True,
+            if not quiet:
+                click.secho("Creating backup: ", bold=True, nl=False)
+                click.secho(f"{backup_name}", dim=True, nl=False)
+                click.secho("... ", dim=True, nl=False)
+
+            backups_handler = DatabaseBackups()
+            backups_handler.create(
+                backup_name,
+                pg_dump=os.environ.get("PG_DUMP", "pg_dump"),
             )
-            # Can't use ctx.invoke because this is called by the test db creation currently,
-            # which doesn't have a context.
-            create_backup.callback(
-                backup_name=backup_name,
-                pg_dump=os.environ.get(
-                    "PG_DUMP", "pg_dump"
-                ),  # Have to pass this in manually
-            )
-            print()
 
-        if verbosity >= 1:
-            click.secho("Running migrations:", fg="cyan")
+            if not quiet:
+                click.echo(click.style("OK", fg="green"))
+                click.echo()  # Add blank line after backup output
+        else:
+            if not quiet:
+                click.echo()  # Add blank line after packages/target info
 
+        if not quiet:
+            if atomic_batch_message:
+                click.secho(
+                    f"Applying migrations ({atomic_batch_message.lower()}):", bold=True
+                )
+            else:
+                click.secho("Applying migrations:", bold=True)
         post_migrate_state = executor.migrate(
             targets,
             plan=migration_plan,
@@ -712,31 +725,24 @@ def migrate(
             ]
         )
 
-    elif verbosity >= 1:
-        click.echo("  No migrations to apply.")
-        # If there's changes that aren't in migrations yet, tell them
-        # how to fix it.
-        autodetector = MigrationAutodetector(
-            executor.loader.project_state(),
-            ProjectState.from_models_registry(models_registry),
-        )
-        changes = autodetector.changes(graph=executor.loader.graph)
-        if changes:
-            click.echo(
-                click.style(
-                    f"  Your models in package(s): {', '.join(repr(package) for package in sorted(changes))} "
-                    "have changes that are not yet reflected in a migration, and so won't be applied.",
-                    fg="yellow",
-                )
+    else:
+        if not quiet:
+            click.echo("No migrations to apply.")
+            # If there's changes that aren't in migrations yet, tell them
+            # how to fix it.
+            autodetector = MigrationAutodetector(
+                executor.loader.project_state(),
+                ProjectState.from_models_registry(models_registry),
             )
-            click.echo(
-                click.style(
-                    "  Run `plain makemigrations` to make new "
-                    "migrations, and then re-run `plain migrate` to "
-                    "apply them.",
-                    fg="yellow",
+            changes = autodetector.changes(graph=executor.loader.graph)
+            if changes:
+                packages = ", ".join(sorted(changes))
+                click.echo(
+                    f"Your models have changes that are not yet reflected in migrations ({packages})."
+                )
+                click.echo(
+                    "Run 'plain makemigrations' to create migrations for these changes."
                 )
-            )
 
 
 @cli.command()

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/expressions.py

@@ -28,7 +28,9 @@ if TYPE_CHECKING:
 
     from plain.models.backends.base.base import BaseDatabaseWrapper
     from plain.models.fields import Field
+    from plain.models.query import QuerySet
     from plain.models.sql.compiler import SQLCompiler
+    from plain.models.sql.query import Query
 
 
 class SQLiteNumericMixin:
@@ -1635,9 +1637,23 @@ class Subquery(BaseExpression, Combinable):
     contains_aggregate = False
     empty_result_set_value = None
 
-    def __init__(self, queryset: Any, output_field: Field | None = None, **extra: Any):
+    def __init__(
+        self,
+        query: QuerySet[Any] | Query,
+        output_field: Field | None = None,
+        **extra: Any,
+    ):
+        # Import here to avoid circular import
+        from plain.models.sql.query import Query
+
         # Allow the usage of both QuerySet and sql.Query objects.
-        self.query = getattr(queryset, "query", queryset).clone()
+        if isinstance(query, Query):
+            # It's already a Query object, use it directly
+            sql_query = query
+        else:
+            # It's a QuerySet, extract the sql.Query
+            sql_query = query.sql_query
+        self.query = sql_query.clone()
         self.query.subquery = True
         self.extra = extra
         super().__init__(output_field)
@@ -1688,8 +1704,8 @@ class Exists(Subquery):
     output_field = fields.BooleanField()
     empty_result_set_value = False
 
-    def __init__(self, queryset: Any, **kwargs: Any):
-        super().__init__(queryset, **kwargs)
+    def __init__(self, query: QuerySet[Any] | Query, **kwargs: Any):
+        super().__init__(query, **kwargs)
         self.query = self.query.exists()
 
     def select_format(

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/migrations/executor.py

@@ -126,11 +126,7 @@ class MigrationExecutor:
                         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)
 
@@ -145,13 +141,15 @@ class MigrationExecutor:
         """Run a migration forwards."""
         migration_recorded = False
         if self.progress_callback:
-            self.progress_callback("apply_start", migration, fake)
+            self.progress_callback("apply_start", migration=migration, fake=fake)
         if not fake:
             # Alright, do it normally
             with self.connection.schema_editor(
                 atomic=migration.atomic
             ) as schema_editor:
-                state = migration.apply(state, schema_editor)
+                state = migration.apply(
+                    state, schema_editor, operation_callback=self.progress_callback
+                )
                 if not schema_editor.deferred_sql:
                     self.record_migration(migration)
                     migration_recorded = True
@@ -159,7 +157,7 @@ class MigrationExecutor:
             self.record_migration(migration)
         # Report progress
         if self.progress_callback:
-            self.progress_callback("apply_success", migration, fake)
+            self.progress_callback("apply_success", migration=migration, fake=fake)
         return state
 
     def record_migration(self, migration: Migration) -> None:

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/migrations/loader.py

@@ -370,23 +370,3 @@ class MigrationLoader:
         return self.graph.make_state(
             nodes=nodes, at_end=at_end, real_packages=self.unmigrated_packages
         )
-
-    def collect_sql(self, plan: list[Migration]) -> list[str]:
-        """
-        Take a migration plan and return a list of collected SQL statements
-        that represent the best-efforts version of that plan.
-        """
-        statements = []
-        state = None
-        for migration in plan:
-            with self.connection.schema_editor(
-                collect_sql=True, atomic=migration.atomic
-            ) as schema_editor:
-                if state is None:
-                    state = self.project_state(
-                        (migration.package_label, migration.name), at_end=False
-                    )
-
-                state = migration.apply(state, schema_editor, collect_sql=True)
-            statements.extend(schema_editor.collected_sql)
-        return statements

{plain_models-0.51.0 → plain_models-0.52.0}/plain/models/migrations/migration.py

@@ -1,11 +1,16 @@
 from __future__ import annotations
 
 import re
-from typing import Any
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
 from plain.models.migrations.utils import get_migration_name_timestamp
 from plain.models.transaction import atomic
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
+    from plain.models.migrations.state import ProjectState
+
 
 class Migration:
     """
@@ -86,8 +91,11 @@ class Migration:
         return new_state
 
     def apply(
-        self, project_state: Any, schema_editor: Any, collect_sql: bool = False
-    ) -> Any:
+        self,
+        project_state: ProjectState,
+        schema_editor: BaseDatabaseSchemaEditor,
+        operation_callback: Callable[..., Any] | None = None,
+    ) -> ProjectState:
         """
         Take a project_state representing all migrations prior to this one
         and a schema_editor for a live database and apply the migration
@@ -97,18 +105,11 @@ class Migration:
         Migrations.
         """
         for operation in self.operations:
-            # If this operation cannot be represented as SQL, place a comment
-            # there instead
-            if collect_sql:
-                schema_editor.collected_sql.append("--")
-                schema_editor.collected_sql.append(f"-- {operation.describe()}")
-                schema_editor.collected_sql.append("--")
-                if not operation.reduces_to_sql:
-                    schema_editor.collected_sql.append(
-                        "-- THIS OPERATION CANNOT BE WRITTEN AS SQL"
-                    )
-                    continue
-                collected_sql_before = len(schema_editor.collected_sql)
+            # Clear any previous SQL statements before starting this operation
+            schema_editor.executed_sql = []
+
+            if operation_callback:
+                operation_callback("operation_start", operation=operation)
             # Save the state before the operation has run
             old_state = project_state.clone()
             operation.state_forwards(self.package_label, project_state)
@@ -128,8 +129,13 @@ class Migration:
                 operation.database_forwards(
                     self.package_label, schema_editor, old_state, project_state
                 )
-            if collect_sql and collected_sql_before == len(schema_editor.collected_sql):
-                schema_editor.collected_sql.append("-- (no-op)")
+            if operation_callback:
+                # Pass the accumulated SQL statements for this operation
+                operation_callback(
+                    "operation_success",
+                    operation=operation,
+                    sql_statements=schema_editor.executed_sql,
+                )
         return project_state
 
     def suggest_name(self) -> str:

{plain_models-0.51.0 → plain_models-0.52.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.models"
-version = "0.51.0"
+version = "0.52.0"
 description = "Model your data and store it in a database."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 readme = "README.md"