sqlbuild 0.76.5__tar.gz → 0.76.7__tar.gz

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.76.5"
+version = "0.76.7"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.76.5
+Version: 0.76.7
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.76.5"
+version = "0.76.7"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.76.5"
+version = "0.76.7"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

sqlbuild-0.76.7/src/sqlbuild/cli/commands/_helpers/audit/execution.py

@@ -0,0 +1,156 @@
+"""Audit command execution phases."""
+
+from __future__ import annotations
+
+from sqlbuild.cli.commands.models import (
+    AuditCommandRequest,
+    AuditExecutionPreparation,
+    AuditInvocation,
+)
+from sqlbuild.cli.output.classes.execution_event_writer import ExecutionEventWriter
+from sqlbuild.cli.progress.classes.audit_progress_reporter import AuditProgressReporter
+from sqlbuild.cli.progress.classes.connection_progress_reporter import (
+    ConnectionProgressReporter,
+)
+from sqlbuild.cli.progress.classes.native_progress_projector import (
+    NativeProgressProjector,
+    current_native_progress_projector,
+)
+from sqlbuild.compiler.pipeline.models import CompilePipelineResult
+from sqlbuild.compiler.planner.models import AuditPlanEntry
+from sqlbuild.cost.classes.cost_context import CostContext
+from sqlbuild.executor.auditing.models import AuditExecutionResult
+from sqlbuild.executor.pipeline.main.run import (
+    AuditPipelineCallbacks,
+    run_audit_pipeline_with_callbacks,
+)
+from sqlbuild.presentation.classes.cli_style import CliStyle
+
+
+def prepare_audit_execution(
+    *,
+    request: AuditCommandRequest,
+    invocation: AuditInvocation,
+    pipeline_result: CompilePipelineResult,
+) -> AuditExecutionPreparation:
+    """Prepare nested progress reporting and write the audit section header."""
+
+    audit_count: int = len(pipeline_result.plan_output.audit_entries)
+    effective_concurrency: int = (
+        request.concurrency
+        if request.concurrency is not None
+        else pipeline_result.project.settings.concurrency
+    )
+    worker_count: int = min(effective_concurrency, audit_count)
+    progress: AuditProgressReporter = AuditProgressReporter(
+        entries=pipeline_result.plan_output.audit_entries,
+        worker_limit=worker_count,
+        stream=invocation.progress_stream,
+        use_color=invocation.use_color,
+    )
+    projector: NativeProgressProjector | None = current_native_progress_projector()
+    if projector is not None:
+        for entry in pipeline_result.plan_output.audit_entries:
+            projector.expect_resource_enrichment(resource_name=entry.name)
+    execution_connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
+        adapter_name=invocation.adapter_name,
+        stream=invocation.progress_stream,
+        use_color=invocation.use_color,
+    )
+    return AuditExecutionPreparation(
+        progress=progress,
+        execution_connection_progress=execution_connection_progress,
+        effective_concurrency=effective_concurrency,
+        worker_count=worker_count,
+    )
+
+
+def write_audit_plan_header(
+    *, invocation: AuditInvocation, pipeline_result: CompilePipelineResult
+) -> None:
+    """Write the selected audit section after effective execution settings."""
+
+    entries: tuple[AuditPlanEntry, ...] = pipeline_result.plan_output.audit_entries
+    model_count: int = len(
+        {entry.attached_target_name for entry in entries if entry.attached_target_name}
+    )
+    header: str = f"Audit ({len(entries)} selected, {model_count} models)"
+    styled_header: str = CliStyle(use_color=invocation.use_color).success_strong(header)
+    invocation.progress_stream.write(f"\n{styled_header}\n\n")
+    invocation.progress_stream.flush()
+
+
+def execute_audit_plan(
+    *,
+    invocation: AuditInvocation,
+    pipeline_result: CompilePipelineResult,
+    preparation: AuditExecutionPreparation,
+) -> tuple[AuditExecutionResult, ...]:
+    """Execute the audit plan with nested progress reporting."""
+
+    event_writer: ExecutionEventWriter = ExecutionEventWriter()
+    preparation.progress.set_result_callback(
+        lambda result: event_writer.write_build_result(
+            result=result,
+            plan=pipeline_result.plan_output,
+            command="audit",
+        )
+    )
+    projector: NativeProgressProjector | None = current_native_progress_projector()
+    if projector is not None:
+        projector.configure_resources(
+            ordinals={
+                entry.name: index
+                for index, entry in enumerate(pipeline_result.plan_output.audit_entries, start=1)
+            },
+            total=len(pipeline_result.plan_output.audit_entries),
+        )
+    try:
+        with CostContext.scope(
+            run_id=pipeline_result.project.run_id,
+            resource_type="run",
+            resource_name="audit",
+            ledger_path=(
+                invocation.effective_project_dir
+                / "target"
+                / "executions"
+                / pipeline_result.project.run_id
+                / "statements.jsonl"
+            ),
+            phase="audit",
+        ):
+            return run_audit_pipeline_with_callbacks(
+                plan=pipeline_result.plan_output,
+                connection_config=invocation.connection_config,
+                adapter=invocation.adapter,
+                max_concurrency=preparation.effective_concurrency,
+                callbacks=AuditPipelineCallbacks(
+                    on_connection_start=(
+                        preparation.execution_connection_progress.on_connection_start
+                    ),
+                    on_connection_complete=(
+                        lambda connection_count, elapsed_seconds: (
+                            preparation.execution_connection_progress.on_connection_complete(
+                                connection_count=connection_count,
+                                elapsed_seconds=elapsed_seconds,
+                            )
+                        )
+                    ),
+                    on_connection_error=(
+                        lambda connection_count, elapsed_seconds: (
+                            preparation.execution_connection_progress.on_connection_error(
+                                connection_count=connection_count,
+                                elapsed_seconds=elapsed_seconds,
+                            )
+                        )
+                    ),
+                    on_audit_start=preparation.progress.on_item_start,
+                    on_audit_physical_complete=(preparation.progress.on_item_physical_complete),
+                    on_audit_complete=preparation.progress.on_item_complete,
+                    on_audit_error=preparation.progress.on_item_error,
+                ),
+                run_id=pipeline_result.project.run_id,
+            )
+    finally:
+        preparation.progress.close()
+        event_writer.close()

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/src/sqlbuild/cli/commands/_helpers/audit/outputs.py

@@ -15,6 +15,8 @@ def write_audit_completion_output(
     request: AuditCommandRequest,
     invocation: AuditInvocation,
     results: tuple[AuditExecutionResult, ...],
+    configured_concurrency: int,
+    worker_count: int,
 ) -> None:
     """Write the audit summary footer and optional JSON output."""
 
@@ -36,7 +38,11 @@ def write_audit_completion_output(
     )
     invocation.progress_stream.flush()
     write_execution_json_output(
-        payload=format_audit_execution_json(results=results),
+        payload=format_audit_execution_json(
+            results=results,
+            configured_concurrency=configured_concurrency,
+            worker_count=worker_count,
+        ),
         json_output=request.json_output,
         json_output_path=request.json_output_path,
     )

sqlbuild-0.76.7/src/sqlbuild/cli/commands/_helpers/audit/planning.py

@@ -0,0 +1,53 @@
+"""Audit command plan compilation phase."""
+
+from __future__ import annotations
+
+from sqlbuild.cli.commands._helpers.planning.external_refs import (
+    resolve_external_sql_reference_resolver,
+)
+from sqlbuild.cli.commands.models import AuditCommandRequest, AuditInvocation
+from sqlbuild.compiler.pipeline.main.static_command import compile_static_command_context
+from sqlbuild.compiler.pipeline.main.static_result import build_static_pipeline_result
+from sqlbuild.compiler.pipeline.models import (
+    CompilePipelineOptions,
+    CompilePipelineResult,
+    StaticCommandContext,
+)
+from sqlbuild.compiler.planner.main.commands.audit import build_audit_command_plan
+
+
+def compile_audit_plan(
+    *,
+    request: AuditCommandRequest,
+    invocation: AuditInvocation,
+) -> CompilePipelineResult:
+    """Compile the audit plan for the selected scope."""
+
+    options: CompilePipelineOptions = CompilePipelineOptions(
+        selected_target=request.selected_target,
+        no_sql_validation=request.no_sql_validation,
+        defer_to=request.defer_to,
+        select=request.select,
+        exclude=request.exclude,
+        connection_config=invocation.connection_config,
+        cli_vars=request.cli_vars,
+        external_sql_reference_resolver=resolve_external_sql_reference_resolver(
+            project_dir=invocation.effective_project_dir,
+            discovered_inputs=invocation.discovered_inputs,
+        ),
+    )
+    context: StaticCommandContext = compile_static_command_context(
+        discovered_inputs=invocation.discovered_inputs,
+        adapter=invocation.adapter,
+        options=options,
+        on_progress=invocation.planning_progress.on_progress,
+    )
+    return build_static_pipeline_result(
+        context=context,
+        plan_output=build_audit_command_plan(
+            project=context.project,
+            adapter=invocation.adapter,
+            scope=context.scope,
+            relations=context.relations,
+        ),
+    )

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/src/sqlbuild/cli/commands/_helpers/check/core.py

@@ -73,6 +73,23 @@ def resolve_selected_check_names(
     return frozenset(check_names - excluded)
 
 
+def check_dependency_closure(
+    *, graph: PythonNodeGraph, check_names: frozenset[str]
+) -> frozenset[str]:
+    """Return transitive executable Python dependencies of selected checks."""
+
+    dependencies: set[str] = set()
+    pending: list[str] = list(check_names)
+    while pending:
+        name: str = pending.pop()
+        for upstream_name in graph.upstream_deps.get(name, ()):
+            if upstream_name in dependencies:
+                continue
+            dependencies.add(upstream_name)
+            pending.append(upstream_name)
+    return frozenset(dependencies - check_names)
+
+
 def _validate_check_selectors(*, select: tuple[str, ...]) -> None:
     raw_selector: str
     for raw_selector in select:
@@ -174,33 +191,21 @@ def run_check_read_side_dependencies(
     python_graph: PythonNodeGraph,
     lifecycle_plan: PythonSqlRunLifecyclePlan,
     relation_targets: dict[SqlResourceRef, str],
+    validation_refs: frozenset[SqlResourceRef] | None = None,
     providers: ProviderContainer | None = None,
 ) -> tuple[PythonNodeExecutionResult, ...]:
     """Run read-side Python dependencies for checks against existing SQL relations."""
 
     read_side_names: frozenset[str] = lifecycle_plan.read_side_python_node_names
-    if not read_side_names:
-        return ()
-    tracker: Any = create_read_side_python_execution_tracker(
-        python_graph=python_graph,
-        selected_python_names=read_side_names,
-        runtime=PythonNodeRuntime(
-            adapter=adapter,
-            connection_config=connection_config,
-            connection=connection,
-            run_id=pipeline_result.project.run_id,
-            target=pipeline_result.project.effective_target_name,
-            vars=pipeline_result.project.effective_vars,
-            is_reload=False,
-            default_database=adapter.default_database(),
-            default_schema=adapter.default_schema(),
-            relation_targets=relation_targets,
-            providers=providers,
-        ),
+    read_side_refs: frozenset[SqlResourceRef] = _read_side_sql_refs(
+        read_side_names=read_side_names, python_graph=python_graph
+    )
+    refs_to_validate: frozenset[SqlResourceRef] = (
+        validation_refs if validation_refs is not None else read_side_refs
     )
     sql_refs: tuple[SqlResourceRef, ...] = tuple(
         sorted(
-            _read_side_sql_refs(read_side_names=read_side_names, python_graph=python_graph),
+            refs_to_validate,
             key=_sql_ref_sort_key,
         )
     )
@@ -223,6 +228,26 @@ def run_check_read_side_dependencies(
             relation_lookup=relation_lookup,
             ref=sql_ref,
         )
+    if not read_side_names:
+        return ()
+    tracker: Any = create_read_side_python_execution_tracker(
+        python_graph=python_graph,
+        selected_python_names=read_side_names,
+        runtime=PythonNodeRuntime(
+            adapter=adapter,
+            connection_config=connection_config,
+            connection=connection,
+            run_id=pipeline_result.project.run_id,
+            target=pipeline_result.project.effective_target_name,
+            vars=pipeline_result.project.effective_vars,
+            is_reload=False,
+            default_database=adapter.default_database(),
+            default_schema=adapter.default_schema(),
+            relation_targets=relation_targets,
+            providers=providers,
+        ),
+    )
+    for sql_ref in sorted(read_side_refs, key=_sql_ref_sort_key):
         if sql_ref.kind == SqlResourceRefKind.MODEL:
             tracker.record_sql_result(
                 ModelExecutionResult(model_name=sql_ref.name, status=ExecutionStatus.SUCCESS)

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/src/sqlbuild/cli/commands/_helpers/check/execution.py

@@ -77,11 +77,15 @@ def prepare_check_execution(
         python_graph=python_graph,
         selected_python_names=check_names,
     )
+    relation_refs: frozenset[SqlResourceRef] = python_graph.selected_sql_refs(
+        selected_names=check_names
+    )
     return CheckExecutionPreparation(
         python_graph=python_graph,
         check_functions=check_functions,
         lifecycle_plan=lifecycle_plan,
         relation_targets=relation_targets,
+        relation_refs=relation_refs,
         default_database=_default_database(invocation=invocation, pipeline_result=pipeline_result),
         default_schema=_default_schema(invocation=invocation, pipeline_result=pipeline_result),
     )
@@ -228,6 +232,7 @@ def _execute_check_read_side(
         python_graph=preparation.python_graph,
         lifecycle_plan=preparation.lifecycle_plan,
         relation_targets=preparation.relation_targets,
+        validation_refs=preparation.relation_refs,
         providers=providers,
     )
     record_python_run_state_results(

sqlbuild-0.76.7/src/sqlbuild/cli/commands/_helpers/check/planning.py

@@ -0,0 +1,109 @@
+"""Check command plan compilation phase."""
+
+from __future__ import annotations
+
+from sqlbuild.cli.commands._helpers.check.core import (
+    check_dependency_closure,
+    resolve_selected_check_names,
+)
+from sqlbuild.cli.commands._helpers.planning.external_refs import (
+    resolve_external_sql_reference_resolver,
+)
+from sqlbuild.cli.commands.models import CheckCommandRequest, CheckInvocation
+from sqlbuild.compiler.compile.models import CompiledObjectKey
+from sqlbuild.compiler.compile.types import CompiledResourceType
+from sqlbuild.compiler.pipeline.main.static_command import compile_static_command_context
+from sqlbuild.compiler.pipeline.main.static_result import build_static_pipeline_result
+from sqlbuild.compiler.pipeline.models import (
+    CompilePipelineOptions,
+    CompilePipelineResult,
+    StaticCommandContext,
+)
+from sqlbuild.compiler.planner.main.commands.relation_plan import build_relation_command_plan
+from sqlbuild.compiler.python_nodes.main.graph import build_discovered_python_node_graph
+from sqlbuild.compiler.python_nodes.models import PythonNodeGraph
+from sqlbuild.compiler.python_nodes.types import PythonNodeKind
+from sqlbuild.python_nodes.models import SqlResourceRef
+from sqlbuild.python_nodes.types import SqlResourceRefKind
+
+
+def compile_check_plan(
+    *, request: CheckCommandRequest, invocation: CheckInvocation
+) -> CompilePipelineResult:
+    """Compile the project for Python check execution."""
+
+    python_graph: PythonNodeGraph = build_discovered_python_node_graph(
+        discovered_inputs=invocation.discovered_inputs
+    )
+    check_names: frozenset[str] = resolve_selected_check_names(
+        graph=python_graph,
+        select=request.select,
+        exclude=request.exclude,
+    )
+    required_refs: frozenset[SqlResourceRef] = python_graph.selected_sql_refs(
+        selected_names=check_names
+    )
+    dependency_names: frozenset[str] = check_dependency_closure(
+        graph=python_graph, check_names=check_names
+    )
+    required_loader_names: frozenset[str] = frozenset(
+        name
+        for name in dependency_names
+        if python_graph.nodes_by_name[name].kind == PythonNodeKind.LOADER
+    )
+    required_source_names: frozenset[str] = _required_loader_source_names(
+        invocation=invocation,
+        required_loader_names=required_loader_names,
+    )
+    selected_keys: frozenset[CompiledObjectKey] = frozenset(
+        CompiledObjectKey(
+            resource_type=(
+                CompiledResourceType.MODEL
+                if ref.kind == SqlResourceRefKind.MODEL
+                else CompiledResourceType.SOURCE
+            ),
+            name=ref.name,
+        )
+        for ref in required_refs
+        if ref.kind in {SqlResourceRefKind.MODEL, SqlResourceRefKind.SOURCE}
+    ) | frozenset(
+        CompiledObjectKey(resource_type=CompiledResourceType.SOURCE, name=name)
+        for name in required_source_names
+    )
+    context: StaticCommandContext = compile_static_command_context(
+        discovered_inputs=invocation.discovered_inputs,
+        adapter=invocation.adapter,
+        options=CompilePipelineOptions(
+            selected_target=request.selected_target,
+            no_sql_validation=request.no_sql_validation,
+            source_deferral_enabled=False,
+            connection_config=invocation.connection_config,
+            cli_vars=request.cli_vars,
+            external_sql_reference_resolver=resolve_external_sql_reference_resolver(
+                project_dir=invocation.effective_project_dir,
+                discovered_inputs=invocation.discovered_inputs,
+            ),
+        ),
+        selected_keys=selected_keys,
+        relation_keys=selected_keys,
+        on_progress=invocation.planning_progress.on_progress,
+    )
+    return build_static_pipeline_result(
+        context=context,
+        plan_output=build_relation_command_plan(
+            project=context.project,
+            scope=context.scope,
+            relations=context.relations,
+        ),
+    )
+
+
+def _required_loader_source_names(
+    *, invocation: CheckInvocation, required_loader_names: frozenset[str]
+) -> frozenset[str]:
+    names: set[str] = set()
+    for source_file in invocation.discovered_inputs.source_files:
+        for source in source_file.source_entries:
+            if source.loader in required_loader_names:
+                names.add(source.name)
+    return frozenset(names)

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -248,6 +248,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 defer_to=args.defer_to,
                 no_color=args.no_color,
                 selected_target=args.target,
+                concurrency=args.concurrency,
                 select=select,
                 exclude=tuple(args.exclude),
                 cli_vars=args.vars,

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/src/sqlbuild/cli/commands/_helpers/entry/parser.py

@@ -244,6 +244,7 @@ def _add_quality_parsers(
     audit_parser.add_argument("--no-sql-validation", action="store_true", default=False)
     audit_parser.add_argument("--defer-to", default=None)
     audit_parser.add_argument("--target", default=None)
+    audit_parser.add_argument("--concurrency", type=int, default=None)
     audit_parser.add_argument("--json", action="store_true", default=False)
     _ = add_execution_json_output_arg(audit_parser)
     _ = add_select_args(audit_parser)

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/src/sqlbuild/cli/commands/_helpers/entry/parsing.py

@@ -41,6 +41,8 @@ def resolve_env_default_concurrency(explicit_concurrency: int | None) -> int | N
     """Return CLI concurrency, falling back to SQLBUILD_CONCURRENCY when unset."""
 
     if explicit_concurrency is not None:
+        if explicit_concurrency < 1:
+            raise argparse.ArgumentTypeError("--concurrency must be >= 1")
         return explicit_concurrency
     raw_value: str | None = os.environ.get(SQLBUILD_CONCURRENCY_ENV_VAR)
     if raw_value is None or raw_value == EMPTY_ENV_VALUE:
@@ -118,7 +120,7 @@ def parse_cli_invocation(
             and not any(option in args.dbt_args for option in DBT_VERBOSE_OPTIONS)
         ):
             args.dbt_args.append("--verbose")
-        if args.command in {CliCommand.BUILD, CliCommand.LOAD, CliCommand.SEED}:
+        if args.command in {CliCommand.AUDIT, CliCommand.BUILD, CliCommand.LOAD, CliCommand.SEED}:
             try:
                 args.concurrency = resolve_env_default_concurrency(args.concurrency)
             except argparse.ArgumentTypeError as error:

{sqlbuild-0.76.5 → sqlbuild-0.76.7}/src/sqlbuild/cli/commands/_helpers/scenario_capture/capture.py

@@ -35,20 +35,18 @@ from sqlbuild.cli.commands.models import (
     ScenarioRunOutputContext,
     ScenarioSnapshotLimitInputs,
 )
-from sqlbuild.cli.progress.classes.connection_progress_reporter import ConnectionProgressReporter
 from sqlbuild.cli.progress.classes.planning_progress_reporter import PlanningProgressReporter
 from sqlbuild.cli.progress.main._write_execution_header import write_execution_header
 from sqlbuild.compiler.compile.models import CompiledSqlScenario
 from sqlbuild.compiler.discovery.main.discover import discover_project_inputs
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
-from sqlbuild.compiler.pipeline.main.compile import run_compile_pipeline
+from sqlbuild.compiler.pipeline.main.compile_only import run_compile_only_pipeline
 from sqlbuild.compiler.pipeline.models import (
     CompilePipelineOptions,
     CompilePipelineResult,
 )
 from sqlbuild.executor.scenario.models import ScenarioSnapshotCaptureLimits
 from sqlbuild.presentation.main.supports_color import supports_color
-from sqlbuild.runtime.contracts.models import ConnectionHooks
 from sqlbuild.runtime.observability.classes.operation_lifecycle import OperationLifecycle
 from sqlbuild.spec.contracts.main.resolve_effective_adapter_name import (
     resolve_effective_adapter_name,
@@ -101,11 +99,6 @@ def run_scenario_capture(request: ScenarioCaptureCommandRequest) -> int:
     use_color: bool = not no_color and supports_color()
     progress_stream: TextIO = sys.stdout
     target_label: str | None = " ".join(selectors) if selectors else None
-    connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
-        adapter_name=adapter_name,
-        stream=progress_stream,
-        use_color=use_color,
-    )
     planning_progress: PlanningProgressReporter = PlanningProgressReporter(
         stream=progress_stream,
         use_color=use_color,
@@ -122,7 +115,7 @@ def run_scenario_capture(request: ScenarioCaptureCommandRequest) -> int:
     progress_stream.flush()
 
     with OperationLifecycle(operation_kind="project", operation_name="project_compile"):
-        pipeline_result: CompilePipelineResult = run_compile_pipeline(
+        pipeline_result: CompilePipelineResult = run_compile_only_pipeline(
             discovered_inputs=discovered_inputs,
             adapter=adapter,
             options=CompilePipelineOptions(
@@ -133,20 +126,7 @@ def run_scenario_capture(request: ScenarioCaptureCommandRequest) -> int:
                     discovered_inputs=discovered_inputs,
                 ),
             ),
-            hooks=ConnectionHooks(
-                on_progress=planning_progress.on_progress,
-                on_connection_start=connection_progress.on_connection_start,
-                on_connection_complete=lambda connection_count, elapsed_seconds: (
-                    connection_progress.on_connection_complete(
-                        connection_count=connection_count, elapsed_seconds=elapsed_seconds
-                    )
-                ),
-                on_connection_error=lambda connection_count, elapsed_seconds: (
-                    connection_progress.on_connection_error(
-                        connection_count=connection_count, elapsed_seconds=elapsed_seconds
-                    )
-                ),
-            ),
+            on_progress=planning_progress.on_progress,
         )
     scenarios: tuple[CompiledSqlScenario, ...] = select_scenarios(
         project=pipeline_result.project,