sqlbuild 0.36.0__tar.gz → 0.37.1__tar.gz

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/.gitignore

@@ -52,6 +52,7 @@ data/
 
 # Local artifacts
 target/
+.dlt/
 
 # Local SQLBuild overrides
 sqlbuild_local.yml

sqlbuild-0.37.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.37.1"
+}

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.37.1](https://github.com/chio-labs/sqlbuild/compare/v0.37.0...v0.37.1) (2026-06-21)
+
+
+### Bug Fixes
+
+* **loaders:** run external loaders before opening warehouse connection ([582b089](https://github.com/chio-labs/sqlbuild/commit/582b08964843636569c1058d72cd49e1f6345496))
+* **loaders:** run external loaders before opening warehouse connection ([32710f7](https://github.com/chio-labs/sqlbuild/commit/32710f794f512fef4634696be19c087cf118a7fa))
+
+## [0.37.0](https://github.com/chio-labs/sqlbuild/compare/v0.36.0...v0.37.0) (2026-06-21)
+
+
+### Features
+
+* **dlt:** cover real warehouse destinations ([0a595b6](https://github.com/chio-labs/sqlbuild/commit/0a595b62c436cbe6b6a6440c7b475b5b3f9a5f4c))
+* **dlt:** expose destination settings ([1fa1cd8](https://github.com/chio-labs/sqlbuild/commit/1fa1cd8f272e9c31c1730e3f5a0668b079dba962))
+* **dlt:** report live source progress ([de4609b](https://github.com/chio-labs/sqlbuild/commit/de4609bd2d9dcc7d0061fcaedadcdc257ab8e303))
+* **integrations:** add declarative dlt sources ([c25d721](https://github.com/chio-labs/sqlbuild/commit/c25d721a57cc5aa83724495cc796d9679a5f9dc9))
+
 ## [0.36.0](https://github.com/chio-labs/sqlbuild/compare/v0.35.0...v0.36.0) (2026-06-21)
 
 

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.36.0
+Version: 0.37.1
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -19,6 +19,8 @@ Provides-Extra: databricks
 Requires-Dist: databricks-sql-connector[pyarrow]>=4.1.2; extra == 'databricks'
 Provides-Extra: dbt
 Requires-Dist: jinja2>=3.1; extra == 'dbt'
+Provides-Extra: dlt
+Requires-Dist: dlt[duckdb,filesystem,sql-database]<2,>=1.28.0; extra == 'dlt'
 Provides-Extra: ingestr
 Requires-Dist: ingestr>=1.0.0; extra == 'ingestr'
 Provides-Extra: postgres

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.36.0"
+version = "0.37.1"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -43,6 +43,9 @@ sqlserver = [
 ingestr = [
   "ingestr>=1.0.0",
 ]
+dlt = [
+  "dlt[duckdb,filesystem,sql_database]>=1.28.0,<2",
+]
 rivers = [
   "rivers>=0.1.4",
 ]
@@ -64,6 +67,7 @@ dev = [
   "dbt-postgres>=1.9.0,<1.11",
   "dbt-snowflake==1.12.0b1",
   "dbt-sqlserver>=1.9.0,<1.11",
+  "dlt[duckdb,filesystem,sql_database]>=1.28.0,<2",
   "ingestr>=1.0.0",
   "jsonschema>=4.23.0",
   "pre-commit>=4.3.0",

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/audit.py

@@ -31,6 +31,7 @@ from sqlbuild.executor.auditing.models import AuditExecutionResult
 from sqlbuild.executor.pipeline.main.run import run_audit_pipeline
 from sqlbuild.shared.helpers.cli_style import CliStyle
 from sqlbuild.shared.helpers.colors import supports_color
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 from sqlbuild.spec.models.project import resolve_effective_adapter_name
 
 
@@ -151,7 +152,17 @@ def run_audit(
     warn_count: int = sum(1 for r in results if r.outcome == AuditOutcome.WARN)
     fail_count: int = sum(1 for r in results if r.outcome == AuditOutcome.ERROR)
     progress_stream.write(
-        f"\nPASS={pass_count}  WARN={warn_count}  FAIL={fail_count}  TOTAL={len(results)}\n"
+        "\n"
+        + format_summary_footer(
+            counts=(
+                ("PASS", pass_count),
+                ("WARN", warn_count),
+                ("FAIL", fail_count),
+                ("TOTAL", len(results)),
+            ),
+            use_color=use_color,
+        )
+        + "\n"
     )
     progress_stream.flush()
     write_execution_json_output(

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/build.py

@@ -298,6 +298,7 @@ def run_build(
             snapshots=discovered_inputs.project_config.snapshots,
             allow_snapshot_schema_change=allow_snapshot_schema_change,
             run_id=pipeline_result.project.run_id,
+            runtime_dir=effective_project_dir / "target",
             run_tests=run_tests,
             run_audits=run_audits,
             fail_fast=fail_fast,

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/check.py

@@ -48,6 +48,7 @@ from sqlbuild.executor.python_nodes.models import (
 )
 from sqlbuild.provider.main.session import build_provider_session
 from sqlbuild.shared.helpers.colors import supports_color
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 from sqlbuild.shared.models import SqlResourceRef
 from sqlbuild.spec.models.project import resolve_effective_adapter_name
 
@@ -226,7 +227,17 @@ def run_check(
         warn_count: int = sum(1 for result in results if result.warned)
         fail_count: int = sum(1 for result in results if result.failed)
         progress_stream.write(
-            f"\nPASS={pass_count}  WARN={warn_count}  FAIL={fail_count}  TOTAL={len(results)}\n"
+            "\n"
+            + format_summary_footer(
+                counts=(
+                    ("PASS", pass_count),
+                    ("WARN", warn_count),
+                    ("FAIL", fail_count),
+                    ("TOTAL", len(results)),
+                ),
+                use_color=use_color,
+            )
+            + "\n"
         )
         progress_stream.flush()
         write_python_check_runtime_target(

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/helpers/clone/output.py

@@ -6,6 +6,7 @@ from sqlbuild.executor.clone.models import CloneExecutionResult, CloneItemResult
 from sqlbuild.executor.clone.types import CloneAction, CloneStatus
 from sqlbuild.shared.helpers.alignment import format_aligned_name_value, resolve_name_column_width
 from sqlbuild.shared.helpers.cli_style import CliStyle
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 
 
 def render_clone_output(
@@ -60,13 +61,18 @@ def render_clone_output(
     else:
         print(style.warning_strong("Completed with warnings."))
     print(
-        f"{style.label('CLONED=')}{style.value(str(cloned_count))}  "
-        f"{style.label('COPIED=')}{style.value(str(copied_count))}  "
-        f"{style.label('RECREATED_VIEWS=')}{style.value(str(recreated_count))}  "
-        f"{style.label('PASS=')}{style.success(str(success_count))}  "
-        f"{style.label('WARN=')}{style.warning(str(warning_count))}  "
-        f"{style.label('FAIL=')}{style.error(str(fail_count))}  "
-        f"{style.label('TOTAL=')}{style.value(str(len(result.item_results)))}"
+        format_summary_footer(
+            counts=(
+                ("CLONED", cloned_count),
+                ("COPIED", copied_count),
+                ("RECREATED_VIEWS", recreated_count),
+                ("PASS", success_count),
+                ("WARN", warning_count),
+                ("FAIL", fail_count),
+                ("TOTAL", len(result.item_results)),
+            ),
+            use_color=use_color,
+        )
     )
 
 

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/helpers/dbt_sqlbuild_work.py

@@ -40,6 +40,7 @@ from sqlbuild.executor.testing.types import SqlTestOutcome
 from sqlbuild.integrations.dbt.types import DbtInteropCommand, DbtInteropSqlbuildTestAction
 from sqlbuild.shared.helpers.cli_style import CliStyle
 from sqlbuild.shared.helpers.status import TransientStatusReporter
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 
 
 def execute_sqlbuild_build_work(
@@ -216,7 +217,18 @@ def _execute_sqlbuild_tests(
     )
     pass_count: int = sum(1 for r in results if r.outcome == SqlTestOutcome.PASS)
     fail_count: int = len(results) - pass_count
-    output_stream.write(f"\nPASS={pass_count}  FAIL={fail_count}  TOTAL={len(results)}\n\n")
+    output_stream.write(
+        "\n"
+        + format_summary_footer(
+            counts=(
+                ("PASS", pass_count),
+                ("FAIL", fail_count),
+                ("TOTAL", len(results)),
+            ),
+            use_color=use_color,
+        )
+        + "\n\n"
+    )
     output_stream.flush()
     return 0 if fail_count == 0 else 1
 
@@ -276,7 +288,17 @@ def _execute_sqlbuild_audits(
     warn_count: int = sum(1 for r in results if r.outcome == AuditOutcome.WARN)
     fail_count: int = sum(1 for r in results if r.outcome == AuditOutcome.ERROR)
     output_stream.write(
-        f"\nPASS={pass_count}  WARN={warn_count}  FAIL={fail_count}  TOTAL={len(results)}\n\n"
+        "\n"
+        + format_summary_footer(
+            counts=(
+                ("PASS", pass_count),
+                ("WARN", warn_count),
+                ("FAIL", fail_count),
+                ("TOTAL", len(results)),
+            ),
+            use_color=use_color,
+        )
+        + "\n\n"
     )
     output_stream.flush()
     return 0 if fail_count == 0 else 1

sqlbuild-0.37.1/src/sqlbuild/cli/commands/main/helpers/load_progress.py

@@ -0,0 +1,202 @@
+"""Progress callbacks for sqb load execution."""
+
+from __future__ import annotations
+
+import threading
+from typing import TextIO
+
+from sqlbuild.adapter.shared.models import LifeCycleEvent
+from sqlbuild.adapter.shared.types import LifeCycleEventKind
+from sqlbuild.executor.load.models import LoadExecutionResult
+from sqlbuild.shared.helpers.cli_style import CliStyle
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
+from sqlbuild.spec.models.source import SourceEntry
+
+_SPINNER_TICK_SECONDS: float = 0.1
+_ACTIVE_SPINNER_FRAMES: tuple[str, ...] = (
+    "⠋",
+    "⠙",
+    "⠹",
+    "⠸",
+    "⠼",
+    "⠴",
+    "⠦",
+    "⠧",
+    "⠇",
+    "⠏",
+)
+
+
+class LoadProgressReporter:
+    """TTY-aware renderer for sqb load execution progress."""
+
+    def __init__(
+        self,
+        *,
+        stream: TextIO,
+        use_color: bool,
+        source_order: dict[str, int],
+        total_count: int,
+    ) -> None:
+        self._stream: TextIO = stream
+        self._style: CliStyle = CliStyle(use_color=use_color)
+        self._source_order: dict[str, int] = source_order
+        self._total_count: int = total_count
+        self._is_tty: bool = stream.isatty()
+        self._current_source: SourceEntry | None = None
+        self._current_sub_message: str = ""
+        self._spinner_frame_index: int = 0
+        self._spinner_stop_event: threading.Event | None = None
+        self._spinner_thread: threading.Thread | None = None
+        self._write_lock: threading.Lock = threading.Lock()
+        self._cursor_hidden: bool = False
+
+    def on_start(self, source: SourceEntry) -> None:
+        if not self._is_tty:
+            return
+        self._current_source = source
+        self._current_sub_message = ""
+        self._hide_cursor()
+        self._write_spinner_line()
+        self._start_spinner_loop()
+
+    def on_progress(self, source: SourceEntry, message: str) -> None:
+        if not self._is_tty or self._current_source is None:
+            return
+        if source.name != self._current_source.name:
+            return
+        self._current_sub_message = message
+        self._write_spinner_line()
+
+    def on_complete(self, result: LoadExecutionResult) -> None:
+        self._stop_spinner_loop()
+        if self._is_tty:
+            with self._write_lock:
+                self._stream.write("\r\033[K")
+                self._stream.flush()
+            self._show_cursor()
+        status_text: str = (
+            "OK"
+            if result.status.value == "success"
+            else "SKIP"
+            if result.status.value == "skipped"
+            else "FAIL"
+        )
+        status: str = self._style.status(status_text)
+        duration: str = ""
+        if result.duration_ms is not None:
+            duration = f"{result.duration_ms / 1000.0:.2f}s"
+        rows_loaded: str = f"rows={result.rows_loaded:,}"
+        ordinal: int = self._source_order[result.source_name]
+        self._stream.write(
+            f"  {ordinal}/{self._total_count}  {result.resource_kind.value:<10}"
+            f"{result.source_name:<30} {status:<6} {duration}  {rows_loaded}\n"
+        )
+        event: LifeCycleEvent
+        for event in result.lifecycle_events:
+            if event.kind == LifeCycleEventKind.LOG:
+                self._write_log_block(event.content)
+        if result.error_message is not None:
+            self._stream.write(self._style.error(f"    {result.error_message}\n"))
+        self._stream.flush()
+
+    def _write_spinner_line(self) -> None:
+        source: SourceEntry | None = self._current_source
+        if source is None:
+            return
+        ordinal: int = self._source_order[source.name]
+        status: str = self._style.status(_ACTIVE_SPINNER_FRAMES[self._spinner_frame_index])
+        self._spinner_frame_index = (self._spinner_frame_index + 1) % len(_ACTIVE_SPINNER_FRAMES)
+        resource_kind: str = (
+            "loader" if source.meta.get("sqlbuild_loader_node") is True else "source"
+        )
+        name_display: str = source.name
+        if self._current_sub_message:
+            name_display = f"{source.name}  {self._current_sub_message}"
+        line: str = (
+            f"  {ordinal}/{self._total_count}  {resource_kind:<10}{name_display:<48} {status}"
+        )
+        with self._write_lock:
+            self._stream.write(f"\r\033[K{line}")
+            self._stream.flush()
+
+    def _start_spinner_loop(self) -> None:
+        self._stop_spinner_loop()
+        stop_event: threading.Event = threading.Event()
+        self._spinner_stop_event = stop_event
+        spinner_thread: threading.Thread = threading.Thread(
+            target=self._spin_until_stopped,
+            args=(stop_event,),
+            daemon=True,
+        )
+        self._spinner_thread = spinner_thread
+        spinner_thread.start()
+
+    def _stop_spinner_loop(self) -> None:
+        if self._spinner_stop_event is not None:
+            self._spinner_stop_event.set()
+        if self._spinner_thread is not None and self._spinner_thread.is_alive():
+            self._spinner_thread.join(timeout=0.2)
+        self._spinner_stop_event = None
+        self._spinner_thread = None
+
+    def _spin_until_stopped(self, stop_event: threading.Event) -> None:
+        while not stop_event.wait(_SPINNER_TICK_SECONDS):
+            self._write_spinner_line()
+
+    def _hide_cursor(self) -> None:
+        if self._cursor_hidden:
+            return
+        with self._write_lock:
+            self._stream.write("\033[?25l")
+            self._stream.flush()
+        self._cursor_hidden = True
+
+    def _show_cursor(self) -> None:
+        if not self._cursor_hidden:
+            return
+        with self._write_lock:
+            self._stream.write("\033[?25h")
+            self._stream.flush()
+        self._cursor_hidden = False
+
+    def _write_log_block(self, message: str) -> None:
+        lines: list[str] = message.splitlines() or [""]
+        prefix: str = self._style.log_label("    log  ")
+        first_content: str = self._style.muted(lines[0])
+        self._stream.write(f"\n{prefix}{first_content}\n")
+        line: str
+        for line in lines[1:]:
+            self._stream.write(f"{self._style.muted(f'         {line}')}\n")
+
+
+def format_load_footer(
+    *,
+    success_count: int,
+    fail_count: int,
+    skip_count: int,
+    total_count: int,
+    elapsed: float,
+    use_color: bool,
+) -> str:
+    style: CliStyle = CliStyle(use_color=use_color)
+    completion_message: str = (
+        style.success("Completed successfully.")
+        if fail_count == 0
+        else style.error("Completed with errors.")
+    )
+    return (
+        f"\n{completion_message}\n"
+        + format_summary_footer(
+            counts=(
+                ("PASS", success_count),
+                ("WARN", 0),
+                ("FAIL", fail_count),
+                ("SKIP", skip_count),
+                ("TOTAL", total_count),
+            ),
+            use_color=use_color,
+            elapsed=f"{elapsed:.2f}s",
+        )
+        + "\n"
+    )

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/helpers/load_selection.py

@@ -130,7 +130,11 @@ def select_load_reference_entries(
     for source in selected_sources:
         if source.loader is None or source.loader not in upstream_loaders:
             continue
-        reference_loader_names.update(_upstream_loader_closure(source.loader, upstream_loaders))
+        dependency_name: str
+        for dependency_name in upstream_loaders[source.loader]:
+            reference_loader_names.update(
+                _upstream_loader_closure(dependency_name, upstream_loaders)
+            )
     return tuple(
         _loader_to_source_entry(loaders[loader_name], target_config)
         for loader_name in _topological_loader_order(

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/helpers/scenario/capture_run.py

@@ -25,6 +25,7 @@ from sqlbuild.executor.scenario.models import (
 )
 from sqlbuild.shared.helpers.cli_style import CliStyle
 from sqlbuild.shared.helpers.status import TransientStatusReporter
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 
 _SCENARIO_NAME_WIDTH: int = 64
 _CAPTURE_RELATION_KIND_WIDTH: int = 8
@@ -101,7 +102,18 @@ def run_scenario_capture_run(
         capture_results_out.extend(results)
     pass_count: int = sum(1 for result in results if result.status == SUCCESS_STATUS)
     fail_count: int = len(results) - pass_count
-    progress_stream.write(f"\nPASS={pass_count}  FAIL={fail_count}  TOTAL={len(results)}\n")
+    progress_stream.write(
+        "\n"
+        + format_summary_footer(
+            counts=(
+                ("PASS", pass_count),
+                ("FAIL", fail_count),
+                ("TOTAL", len(results)),
+            ),
+            use_color=use_color,
+        )
+        + "\n"
+    )
     progress_stream.flush()
     return 0 if fail_count == 0 else 1
 

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/helpers/scenario/local_run.py

@@ -18,6 +18,7 @@ from sqlbuild.executor.scenario.models import ScenarioRunResult
 from sqlbuild.executor.scenario.types import ScenarioLocalRunStatus
 from sqlbuild.shared.helpers.cli_style import CliStyle
 from sqlbuild.shared.helpers.status import TransientStatusReporter
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 
 
 def run_local_scenarios(
@@ -73,7 +74,9 @@ def run_local_scenarios(
         ),
     )
     scenario_status.close()
-    exit_code: int = _write_local_summary(results=results, stream=progress_stream)
+    exit_code: int = _write_local_summary(
+        results=results, stream=progress_stream, use_color=use_color
+    )
     write_execution_json_output(
         payload=format_scenario_execution_json(results=results, local=True),
         json_output=json_output,
@@ -82,7 +85,9 @@ def run_local_scenarios(
     return exit_code
 
 
-def _write_local_summary(*, results: tuple[ScenarioRunResult, ...], stream: TextIO) -> int:
+def _write_local_summary(
+    *, results: tuple[ScenarioRunResult, ...], stream: TextIO, use_color: bool
+) -> int:
     pass_count: int = sum(
         1 for result in results if result.local_status == ScenarioLocalRunStatus.PASS
     )
@@ -96,8 +101,18 @@ def _write_local_summary(*, results: tuple[ScenarioRunResult, ...], stream: Text
         1 for result in results if result.local_status == ScenarioLocalRunStatus.SKIP
     )
     stream.write(
-        f"\nPASS={pass_count}  FAIL={fail_count}  ERROR={error_count}  "
-        f"SKIP={skip_count}  TOTAL={len(results)}\n"
+        "\n"
+        + format_summary_footer(
+            counts=(
+                ("PASS", pass_count),
+                ("FAIL", fail_count),
+                ("ERROR", error_count),
+                ("SKIP", skip_count),
+                ("TOTAL", len(results)),
+            ),
+            use_color=use_color,
+        )
+        + "\n"
     )
     stream.flush()
     return 0 if fail_count == 0 and error_count == 0 else 1

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/helpers/scenario/runner.py

@@ -55,6 +55,7 @@ from sqlbuild.shared.constants import (
 from sqlbuild.shared.helpers.cli_style import CliStyle
 from sqlbuild.shared.helpers.colors import supports_color
 from sqlbuild.shared.helpers.status import TransientStatusReporter
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 from sqlbuild.spec.models.project import (
     resolve_effective_adapter_name,
     resolve_effective_scenario_config,
@@ -414,7 +415,15 @@ def _sync_local_snapshots(
     fail_count: int = len(results) - pass_count
     summary_prefix: str = "REFRESH" if refresh else "SYNC"
     progress_stream.write(
-        f"\n{summary_prefix}_PASS={pass_count}  {summary_prefix}_FAIL={fail_count}\n"
+        "\n"
+        + format_summary_footer(
+            counts=(
+                (f"{summary_prefix}_PASS", pass_count),
+                (f"{summary_prefix}_FAIL", fail_count),
+            ),
+            use_color=use_color,
+        )
+        + "\n"
     )
     progress_stream.flush()
     return 0 if fail_count == 0 else 1

{sqlbuild-0.36.0 → sqlbuild-0.37.1}/src/sqlbuild/cli/commands/main/helpers/scenario/warehouse_run.py

@@ -19,6 +19,7 @@ from sqlbuild.executor.pipeline.main.run import run_scenario_test_pipeline
 from sqlbuild.executor.scenario.models import ScenarioRunResult
 from sqlbuild.shared.helpers.cli_style import CliStyle
 from sqlbuild.shared.helpers.status import TransientStatusReporter
+from sqlbuild.shared.helpers.summary_footer import format_summary_footer
 
 
 def run_warehouse_scenarios(
@@ -80,7 +81,9 @@ def run_warehouse_scenarios(
         ),
     )
     scenario_status.close()
-    exit_code: int = _write_remote_summary(results=results, stream=progress_stream)
+    exit_code: int = _write_remote_summary(
+        results=results, stream=progress_stream, use_color=use_color
+    )
     write_execution_json_output(
         payload=format_scenario_execution_json(results=results, local=False),
         json_output=json_output,
@@ -89,9 +92,22 @@ def run_warehouse_scenarios(
     return exit_code
 
 
-def _write_remote_summary(*, results: tuple[ScenarioRunResult, ...], stream: TextIO) -> int:
+def _write_remote_summary(
+    *, results: tuple[ScenarioRunResult, ...], stream: TextIO, use_color: bool
+) -> int:
     pass_count: int = sum(1 for result in results if result.status == SUCCESS_STATUS)
     fail_count: int = len(results) - pass_count
-    stream.write(f"\nPASS={pass_count}  FAIL={fail_count}  TOTAL={len(results)}\n")
+    stream.write(
+        "\n"
+        + format_summary_footer(
+            counts=(
+                ("PASS", pass_count),
+                ("FAIL", fail_count),
+                ("TOTAL", len(results)),
+            ),
+            use_color=use_color,
+        )
+        + "\n"
+    )
     stream.flush()
     return 0 if fail_count == 0 else 1