sqlbuild 0.38.2__tar.gz → 0.38.4__tar.gz

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

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

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.38.4](https://github.com/chio-labs/sqlbuild/compare/v0.38.3...v0.38.4) (2026-06-24)
+
+
+### Bug Fixes
+
+* **dbt:** cache reuse manifests ([6562e29](https://github.com/chio-labs/sqlbuild/commit/6562e29841493ffa6476957acfc3f9812e27b5d0))
+* **dbt:** cache reuse manifests ([bbe1bc3](https://github.com/chio-labs/sqlbuild/commit/bbe1bc33b63dc91cc69175610775b8631e340a8c))
+
+## [0.38.3](https://github.com/chio-labs/sqlbuild/compare/v0.38.2...v0.38.3) (2026-06-24)
+
+
+### Bug Fixes
+
+* **dbt:** bound reuse git refresh ([bd40a8c](https://github.com/chio-labs/sqlbuild/commit/bd40a8c6abef5c08e6940391ba146ffc5543d490))
+* **dbt:** bound reuse git refresh ([0bbf200](https://github.com/chio-labs/sqlbuild/commit/0bbf2006c70f6248f05f43d2a62d3d3832838539))
+
 ## [0.38.2](https://github.com/chio-labs/sqlbuild/compare/v0.38.1...v0.38.2) (2026-06-23)
 
 

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.38.2
+Version: 0.38.4
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/pyproject.toml

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

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/cli/commands/main/shared/helpers/progress/planning.py

@@ -51,6 +51,7 @@ def _is_planning_completion_message(message: str) -> bool:
     return message.startswith(
         (
             "Built ",
+            "Checked ",
             "Compiled ",
             "Applied ",
             "Generated ",

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/compiler/discovery/helpers/yml/project.py

@@ -722,7 +722,9 @@ def _load_dbt_reuse_from(*, payload: object, file_path: Path) -> DbtReuseFromCon
     )
     _validate_allowed_keys(
         mapping=mapping,
-        allowed_keys=frozenset({"git_ref", "generate_schema_name_override"}),
+        allowed_keys=frozenset(
+            {"git_ref", "generate_schema_name_override", "refresh", "git_timeout_seconds"}
+        ),
         label="dbt.reuse_from",
         file_path=file_path,
     )
@@ -739,9 +741,18 @@ def _load_dbt_reuse_from(*, payload: object, file_path: Path) -> DbtReuseFromCon
         value=generate_schema_name_override,
         file_path=file_path,
     )
+    git_timeout_seconds: int = _optional_int(
+        mapping=mapping,
+        key="git_timeout_seconds",
+        default=30,
+    )
+    if git_timeout_seconds <= 0:
+        raise ProjectConfigError(f"{file_path} dbt.reuse_from.git_timeout_seconds must be > 0")
     return DbtReuseFromConfig(
         git_ref=git_ref,
         generate_schema_name_override=generate_schema_name_override,
+        refresh=_optional_bool(mapping=mapping, key="refresh", default=True),
+        git_timeout_seconds=git_timeout_seconds,
     )
 
 

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/integrations/dbt/helpers/cli/runner.py

@@ -30,6 +30,21 @@ def build_dbt_compile_argv(
     return argv
 
 
+def build_dbt_deps_argv(*, dbt_executable: str, options: DbtCliOptions) -> tuple[str, ...]:
+    """Build argv for dbt deps."""
+
+    argv: tuple[str, ...] = (dbt_executable, "deps")
+    if options.project_dir is not None:
+        argv = (*argv, "--project-dir", str(options.project_dir))
+    if options.profiles_dir is not None:
+        argv = (*argv, "--profiles-dir", str(options.profiles_dir))
+    if options.target is not None:
+        argv = (*argv, "--target", options.target)
+    if options.vars is not None:
+        argv = (*argv, "--vars", options.vars)
+    return argv
+
+
 def build_dbt_debug_argv(
     *, dbt_executable: str, options: DbtCliOptions, args: Sequence[str] = ()
 ) -> tuple[str, ...]:
@@ -123,6 +138,15 @@ class DbtRunner:
         )
         return self._invoke(argv=argv, cwd=options.project_dir)
 
+    def deps(self, *, options: DbtCliOptions) -> DbtCommandResult:
+        """Run dbt deps."""
+
+        argv: tuple[str, ...] = build_dbt_deps_argv(
+            dbt_executable=self.dbt_executable,
+            options=options,
+        )
+        return self._invoke(argv=argv, cwd=options.project_dir)
+
     def debug(self, *, options: DbtCliOptions, args: Sequence[str] = ()) -> DbtCommandResult:
         """Run dbt debug."""
 

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/integrations/dbt/helpers/reuse/reuse_from.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import hashlib
 import io
+import json
 import shutil
 import subprocess
 import tarfile
@@ -23,6 +25,8 @@ from sqlbuild.integrations.dbt.models import (
 from sqlbuild.integrations.dbt.types import DbtReuseUnavailableReason
 from sqlbuild.spec.models.project import DbtReuseFromConfig
 
+_REUSE_MANIFEST_CACHE_VERSION: int = 1
+
 
 def compile_reuse_from_manifest(
     *,
@@ -60,14 +64,47 @@ def compile_reuse_from_manifest(
         archive_ref: str = _refresh_git_ref_for_archive(
             git_root=git_root,
             git_ref=reuse_from.git_ref,
+            refresh=reuse_from.refresh,
+            timeout_seconds=reuse_from.git_timeout_seconds,
         )
         _raise_if_missing_git_ref(
             git_root=git_root,
             git_ref=archive_ref,
             configured_ref=reuse_from.git_ref,
             project_file=sqlbuild_project_dir / "sqlbuild_project.toml",
+            timeout_seconds=reuse_from.git_timeout_seconds,
+        )
+        commit_sha: str = _git_commit_sha(
+            git_root=git_root,
+            git_ref=archive_ref,
+            timeout_seconds=reuse_from.git_timeout_seconds,
+        )
+        cache_key: str = _reuse_manifest_cache_key(
+            commit_sha=commit_sha,
+            dbt_relative_dir=dbt_relative_dir,
+            macro_source=macro_source,
+            dbt_options=dbt_options,
+            dbt_executable=runner.dbt_executable,
+        )
+        cached_manifest_contents: str | None = _read_reuse_manifest_cache(
+            sqlbuild_project_dir=sqlbuild_project_dir,
+            cache_key=cache_key,
+        )
+        if cached_manifest_contents is not None:
+            return DbtReuseFromCompileResult(
+                git_ref=reuse_from.git_ref,
+                manifest_contents=cached_manifest_contents,
+                command=DbtCommandResult(
+                    argv=("sqlbuild", "cache", "dbt-reuse-manifest"),
+                    returncode=0,
+                ),
+            )
+        _extract_git_ref(
+            git_root=git_root,
+            git_ref=archive_ref,
+            destination=checkout_dir,
+            timeout_seconds=reuse_from.git_timeout_seconds,
         )
-        _extract_git_ref(git_root=git_root, git_ref=archive_ref, destination=checkout_dir)
 
         temp_dbt_project_dir: Path = checkout_dir / dbt_relative_dir
         _inject_generate_schema_name_override(
@@ -86,6 +123,13 @@ def compile_reuse_from_manifest(
             state=dbt_options.state,
             defer=dbt_options.defer,
         )
+        if _has_dbt_dependency_file(dbt_project_dir=temp_dbt_project_dir):
+            deps_command: DbtCommandResult = runner.deps(options=compile_options)
+            if deps_command.returncode != 0:
+                raise DbtInteropRuntimeError(
+                    "dbt reuse_from deps failed",
+                    help=deps_command.stderr or deps_command.stdout or None,
+                )
         command: DbtCommandResult = runner.compile(options=compile_options)
         if command.returncode != 0:
             raise DbtInteropRuntimeError(
@@ -98,9 +142,15 @@ def compile_reuse_from_manifest(
                 "dbt reuse_from compile did not produce manifest.json",
                 help=f"Expected manifest at {manifest_path}.",
             )
+        manifest_contents: str = manifest_path.read_text(encoding="utf-8")
+        _write_reuse_manifest_cache(
+            sqlbuild_project_dir=sqlbuild_project_dir,
+            cache_key=cache_key,
+            manifest_contents=manifest_contents,
+        )
         return DbtReuseFromCompileResult(
             git_ref=reuse_from.git_ref,
-            manifest_contents=manifest_path.read_text(encoding="utf-8"),
+            manifest_contents=manifest_contents,
             command=command,
         )
 
@@ -118,6 +168,93 @@ def _git_root(*, path: Path) -> Path:
     return Path(result.stdout.strip()).resolve()
 
 
+def _has_dbt_dependency_file(*, dbt_project_dir: Path) -> bool:
+    return (dbt_project_dir / "packages.yml").is_file() or (
+        dbt_project_dir / "dependencies.yml"
+    ).is_file()
+
+
+def _git_commit_sha(*, git_root: Path, git_ref: str, timeout_seconds: int) -> str:
+    result: subprocess.CompletedProcess[str] = _run_git_text(
+        "-C",
+        str(git_root),
+        "rev-parse",
+        f"{git_ref}^{{commit}}",
+        timeout_seconds=timeout_seconds,
+    )
+    if result.returncode != 0:
+        raise DbtReuseUnavailableError(
+            f"dbt reuse_from git_ref '{git_ref}' could not be resolved to a commit",
+            reason=DbtReuseUnavailableReason.GIT_REF_MISSING,
+            help=result.stderr or result.stdout or None,
+        )
+    return result.stdout.strip()
+
+
+def _reuse_manifest_cache_key(
+    *,
+    commit_sha: str,
+    dbt_relative_dir: Path,
+    macro_source: Path,
+    dbt_options: DbtCliOptions,
+    dbt_executable: str,
+) -> str:
+    payload: dict[str, object] = {
+        "version": _REUSE_MANIFEST_CACHE_VERSION,
+        "commit_sha": commit_sha,
+        "dbt_executable": dbt_executable,
+        "dbt_relative_dir": dbt_relative_dir.as_posix(),
+        "macro_sha256": hashlib.sha256(macro_source.read_bytes()).hexdigest(),
+        "profiles_dir": None if dbt_options.profiles_dir is None else str(dbt_options.profiles_dir),
+        "target": dbt_options.target,
+        "vars": dbt_options.vars,
+        "state": None if dbt_options.state is None else str(dbt_options.state),
+        "defer": dbt_options.defer,
+    }
+    raw_key: str = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(raw_key.encode("utf-8")).hexdigest()
+
+
+def _reuse_manifest_cache_file(*, sqlbuild_project_dir: Path, cache_key: str) -> Path:
+    return (
+        sqlbuild_project_dir / "target" / "sqlbuild" / "cache" / "dbt_reuse" / f"{cache_key}.json"
+    )
+
+
+def _read_reuse_manifest_cache(*, sqlbuild_project_dir: Path, cache_key: str) -> str | None:
+    cache_file: Path = _reuse_manifest_cache_file(
+        sqlbuild_project_dir=sqlbuild_project_dir,
+        cache_key=cache_key,
+    )
+    if not cache_file.is_file():
+        return None
+    try:
+        payload: object = json.loads(cache_file.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+    if payload.get("version") != _REUSE_MANIFEST_CACHE_VERSION:
+        return None
+    manifest_contents: object | None = payload.get("manifest_contents")
+    return manifest_contents if isinstance(manifest_contents, str) else None
+
+
+def _write_reuse_manifest_cache(
+    *, sqlbuild_project_dir: Path, cache_key: str, manifest_contents: str
+) -> None:
+    cache_file: Path = _reuse_manifest_cache_file(
+        sqlbuild_project_dir=sqlbuild_project_dir,
+        cache_key=cache_key,
+    )
+    cache_file.parent.mkdir(parents=True, exist_ok=True)
+    payload: dict[str, object] = {
+        "version": _REUSE_MANIFEST_CACHE_VERSION,
+        "manifest_contents": manifest_contents,
+    }
+    cache_file.write_text(json.dumps(payload, sort_keys=True), encoding="utf-8")
+
+
 def _relative_to_git_root(*, path: Path, git_root: Path, label: str) -> Path:
     resolved_path: Path = path.resolve()
     try:
@@ -148,7 +285,11 @@ def _raise_if_current_branch(*, git_root: Path, git_ref: str) -> None:
         )
 
 
-def _refresh_git_ref_for_archive(*, git_root: Path, git_ref: str) -> str:
+def _refresh_git_ref_for_archive(
+    *, git_root: Path, git_ref: str, refresh: bool, timeout_seconds: int
+) -> str:
+    if not refresh:
+        return git_ref
     tracking_ref: tuple[str, str, str] | None = _remote_tracking_ref(
         git_root=git_root,
         git_ref=git_ref,
@@ -158,7 +299,12 @@ def _refresh_git_ref_for_archive(*, git_root: Path, git_ref: str) -> str:
     remote, branch, remote_ref = tracking_ref
 
     result: subprocess.CompletedProcess[str] = _run_git_text(
-        "-C", str(git_root), "fetch", remote, branch
+        "-C",
+        str(git_root),
+        "fetch",
+        remote,
+        branch,
+        timeout_seconds=timeout_seconds,
     )
     if result.returncode != 0:
         raise DbtReuseUnavailableError(
@@ -170,10 +316,21 @@ def _refresh_git_ref_for_archive(*, git_root: Path, git_ref: str) -> str:
 
 
 def _raise_if_missing_git_ref(
-    *, git_root: Path, git_ref: str, configured_ref: str, project_file: Path
+    *,
+    git_root: Path,
+    git_ref: str,
+    configured_ref: str,
+    project_file: Path,
+    timeout_seconds: int,
 ) -> None:
     result: subprocess.CompletedProcess[str] = _run_git_text(
-        "-C", str(git_root), "rev-parse", "--verify", "--quiet", f"{git_ref}^{{commit}}"
+        "-C",
+        str(git_root),
+        "rev-parse",
+        "--verify",
+        "--quiet",
+        f"{git_ref}^{{commit}}",
+        timeout_seconds=timeout_seconds,
     )
     if result.returncode == 0:
         return
@@ -232,9 +389,11 @@ def _remote_tracking_ref(*, git_root: Path, git_ref: str) -> tuple[str, str, str
     return remote, branch, f"refs/remotes/{remote}/{branch}"
 
 
-def _extract_git_ref(*, git_root: Path, git_ref: str, destination: Path) -> None:
+def _extract_git_ref(
+    *, git_root: Path, git_ref: str, destination: Path, timeout_seconds: int
+) -> None:
     result: subprocess.CompletedProcess[bytes] = _run_git_bytes(
-        "-C", str(git_root), "archive", git_ref
+        "-C", str(git_root), "archive", git_ref, timeout_seconds=timeout_seconds
     )
     if result.returncode != 0:
         stderr: str = result.stderr.decode(errors="replace")
@@ -247,14 +406,24 @@ def _extract_git_ref(*, git_root: Path, git_ref: str, destination: Path) -> None
         archive.extractall(path=destination, filter="data")
 
 
-def _run_git_text(*args: str) -> subprocess.CompletedProcess[str]:
+def _run_git_text(*args: str, timeout_seconds: int = 30) -> subprocess.CompletedProcess[str]:
     try:
         return subprocess.run(
             ("git", *args),
             capture_output=True,
             check=False,
             text=True,
+            timeout=timeout_seconds,
         )
+    except subprocess.TimeoutExpired as error:
+        raise DbtReuseUnavailableError(
+            f"dbt reuse_from git command timed out after {timeout_seconds}s",
+            reason=DbtReuseUnavailableReason.REMOTE_REFRESH_FAILED,
+            help=(
+                "Check network/SSH access or set [dbt.reuse_from].refresh = false "
+                "to use the local ref."
+            ),
+        ) from error
     except FileNotFoundError as error:
         raise DbtInteropConfigError(
             "dbt reuse_from requires git to be installed and available on PATH",
@@ -262,13 +431,23 @@ def _run_git_text(*args: str) -> subprocess.CompletedProcess[str]:
         ) from error
 
 
-def _run_git_bytes(*args: str) -> subprocess.CompletedProcess[bytes]:
+def _run_git_bytes(*args: str, timeout_seconds: int = 30) -> subprocess.CompletedProcess[bytes]:
     try:
         return subprocess.run(
             ("git", *args),
             capture_output=True,
             check=False,
+            timeout=timeout_seconds,
         )
+    except subprocess.TimeoutExpired as error:
+        raise DbtReuseUnavailableError(
+            f"dbt reuse_from git command timed out after {timeout_seconds}s",
+            reason=DbtReuseUnavailableReason.REMOTE_REFRESH_FAILED,
+            help=(
+                "Check network/SSH access or set [dbt.reuse_from].refresh = false "
+                "to use the local ref."
+            ),
+        ) from error
     except FileNotFoundError as error:
         raise DbtInteropConfigError(
             "dbt reuse_from requires git to be installed and available on PATH",

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/integrations/dbt/pipeline/helpers/plan_output.py

@@ -209,6 +209,7 @@ def build_dbt_model_plan_output(
     on_connection_start: Callable[[int], None] | None,
     on_connection_complete: Callable[[int, float], None] | None,
     on_connection_error: Callable[[int, float], None] | None,
+    on_progress: Callable[[str], None] | None = None,
 ) -> DbtModelPlanningResult | None:
     if not candidate_unique_ids:
         return None
@@ -230,7 +231,9 @@ def build_dbt_model_plan_output(
     if on_connection_complete is not None:
         on_connection_complete(1, time.monotonic() - start)
     try:
-        return build_dbt_model_planning_result(
+        planning_start: float = time.monotonic()
+        _report_progress(on_progress, "Inspecting dbt model state...")
+        result: DbtModelPlanningResult = build_dbt_model_planning_result(
             manifest=manifest,
             candidate_unique_ids=candidate_unique_ids,
             selected_unique_ids=selected_unique_ids,
@@ -241,10 +244,20 @@ def build_dbt_model_plan_output(
             adapter=adapter,
             connection=connection,
         )
+        _report_progress(
+            on_progress,
+            f"Inspected dbt model state. ({time.monotonic() - planning_start:.2f}s)",
+        )
+        return result
     finally:
         adapter.close(connection)
 
 
+def _report_progress(on_progress: Callable[[str], None] | None, message: str) -> None:
+    if on_progress is not None:
+        on_progress(message)
+
+
 def _parse_cursor_overrides(args: tuple[str, ...]) -> CursorOverrides:
     return CursorOverrides(
         start_ts=_parse_value(args, "--start-cursor-ts"),

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/integrations/dbt/pipeline/helpers/reuse_plan.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
@@ -46,6 +47,7 @@ def build_dbt_reuse_plan_output(
     dbt_options: DbtCliOptions,
     runner: DbtRunner,
     warnings: list[str] | None = None,
+    on_progress: Callable[[str], None] | None = None,
 ) -> DbtReusePlanningResult | None:
     """Build dbt reuse_from plan output when reuse_from is configured."""
 
@@ -56,6 +58,7 @@ def build_dbt_reuse_plan_output(
         return None
 
     try:
+        _report_progress(on_progress, "Compiling dbt reuse checkout...")
         compile_result: DbtReuseFromCompileResult = compile_reuse_from_manifest(
             sqlbuild_project_dir=project_dir,
             dbt_options=dbt_options,
@@ -66,24 +69,31 @@ def build_dbt_reuse_plan_output(
         if warnings is not None:
             warnings.append(_reuse_unavailable_message(error=error, git_ref=reuse_from.git_ref))
         return None
+    _report_progress(on_progress, "Loading dbt reuse manifest...")
     reuse_manifest: DbtManifestIndex = build_dbt_manifest_index(
         raw_data=json.loads(compile_result.manifest_contents)
     )
+    _report_progress(on_progress, "Resolving dbt reuse candidates...")
     candidate_resolution: DbtReuseCandidateResolution = resolve_dbt_reuse_candidates_for_plan(
         current_manifest=current_manifest,
         reuse_manifest=reuse_manifest,
         plan=plan,
     )
+    _report_progress(on_progress, "Checking dbt reuse origin relations...")
+    existing_origin_relation_keys: frozenset[tuple[str | None, str | None, str]] = (
+        _existing_origin_relation_keys(
+            project_dir=project_dir,
+            discovered_inputs=discovered_inputs,
+            adapter=adapter,
+            adapter_name=adapter_name,
+            candidate_resolution=candidate_resolution,
+        )
+    )
+    _report_progress(on_progress, "Checked dbt reuse origin relations.")
     return build_dbt_reuse_planning_result(
         candidate_resolution=mark_missing_dbt_reuse_origin_relations(
             candidate_resolution=candidate_resolution,
-            existing_origin_relation_keys=_existing_origin_relation_keys(
-                project_dir=project_dir,
-                discovered_inputs=discovered_inputs,
-                adapter=adapter,
-                adapter_name=adapter_name,
-                candidate_resolution=candidate_resolution,
-            ),
+            existing_origin_relation_keys=existing_origin_relation_keys,
         ),
         dbt_model_plan=dbt_model_plan,
     )
@@ -173,6 +183,7 @@ def build_dbt_dependency_baseline_plan_output(
     dbt_options: DbtCliOptions,
     runner: DbtRunner,
     warnings: list[str] | None = None,
+    on_progress: Callable[[str], None] | None = None,
 ) -> DbtReusePlanningResult | None:
     """Build physical dependency baseline plan for unselected dbt refs."""
 
@@ -185,6 +196,7 @@ def build_dbt_dependency_baseline_plan_output(
         return None
 
     try:
+        _report_progress(on_progress, "Compiling dbt dependency baseline checkout...")
         compile_result: DbtReuseFromCompileResult = compile_reuse_from_manifest(
             sqlbuild_project_dir=project_dir,
             dbt_options=dbt_options,
@@ -193,24 +205,31 @@ def build_dbt_dependency_baseline_plan_output(
         )
     except DbtReuseUnavailableError:
         return None
+    _report_progress(on_progress, "Loading dbt dependency baseline manifest...")
     reuse_manifest: DbtManifestIndex = build_dbt_manifest_index(
         raw_data=json.loads(compile_result.manifest_contents)
     )
+    _report_progress(on_progress, "Resolving dbt dependency baseline candidates...")
     candidate_resolution: DbtReuseCandidateResolution = resolve_dbt_reuse_candidates(
         current_manifest=current_manifest,
         reuse_manifest=reuse_manifest,
         scoped_unique_ids=scoped_unique_ids,
     )
+    _report_progress(on_progress, "Checking dbt dependency baseline origin relations...")
+    existing_origin_relation_keys: frozenset[tuple[str | None, str | None, str]] = (
+        _existing_origin_relation_keys(
+            project_dir=project_dir,
+            discovered_inputs=discovered_inputs,
+            adapter=adapter,
+            adapter_name=adapter_name,
+            candidate_resolution=candidate_resolution,
+        )
+    )
+    _report_progress(on_progress, "Checked dbt dependency baseline origin relations.")
     return build_dbt_reuse_planning_result(
         candidate_resolution=mark_missing_dbt_reuse_origin_relations(
             candidate_resolution=candidate_resolution,
-            existing_origin_relation_keys=_existing_origin_relation_keys(
-                project_dir=project_dir,
-                discovered_inputs=discovered_inputs,
-                adapter=adapter,
-                adapter_name=adapter_name,
-                candidate_resolution=candidate_resolution,
-            ),
+            existing_origin_relation_keys=existing_origin_relation_keys,
         ),
         dbt_model_plan=dbt_model_plan,
     )
@@ -245,3 +264,8 @@ def _reuse_unavailable_message(*, error: DbtReuseUnavailableError, git_ref: str
         f"dbt reuse-from-production is enabled but git ref '{ref}' could not be refreshed "
         "from its remote. Built normally with local history. Check network or remote access."
     )
+
+
+def _report_progress(on_progress: Callable[[str], None] | None, message: str) -> None:
+    if on_progress is not None:
+        on_progress(message)

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/integrations/dbt/pipeline/main/execute.py

@@ -271,6 +271,7 @@ def execute_dbt_interop_from_project(
         on_connection_start=connection_progress.on_connection_start,
         on_connection_complete=connection_progress.on_connection_complete,
         on_connection_error=connection_progress.on_connection_error,
+        on_progress=on_progress,
     )
     if dbt_model_plan is not None:
         plan = replace(plan, dbt_model_plan=dbt_model_plan)
@@ -304,6 +305,7 @@ def execute_dbt_interop_from_project(
             dbt_options=dbt_options,
             runner=runner,
             warnings=reuse_warnings,
+            on_progress=on_progress,
         )
         if reuse_warnings:
             plan = replace(plan, warnings=(*plan.warnings, *reuse_warnings))
@@ -337,6 +339,7 @@ def execute_dbt_interop_from_project(
             on_connection_start=connection_progress.on_connection_start,
             on_connection_complete=connection_progress.on_connection_complete,
             on_connection_error=connection_progress.on_connection_error,
+            on_progress=on_progress,
         )
     dbt_dependency_baseline_plan: DbtReusePlanningResult | None = None
     if dbt_reuse_enabled:
@@ -350,6 +353,7 @@ def execute_dbt_interop_from_project(
             scoped_unique_ids=dependency_baseline_ids,
             dbt_options=dbt_options,
             runner=runner,
+            on_progress=on_progress,
         )
     if dbt_dependency_baseline_plan is not None:
         plan = replace(plan, dbt_dependency_baseline_plan=dbt_dependency_baseline_plan)

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/integrations/dbt/pipeline/main/plan.py

@@ -177,6 +177,10 @@ def plan_dbt_interop_from_project(
         dbt_executable=dbt_executable,
         sqlbuild_executable=sqlbuild_executable,
     )
+    _report_progress(
+        on_progress,
+        f"Resolved dbt and SQLBuild selection. ({time.monotonic() - selection_start:.2f}s)",
+    )
     dbt_model_plan: DbtModelPlanningResult | None = build_dbt_model_plan_output(
         project_dir=project_dir,
         discovered_inputs=discovered_inputs,
@@ -207,6 +211,7 @@ def plan_dbt_interop_from_project(
         on_connection_error=(
             None if connection_progress is None else connection_progress.on_connection_error
         ),
+        on_progress=on_progress,
     )
     if dbt_model_plan is not None:
         plan = replace(plan, dbt_model_plan=dbt_model_plan)
@@ -236,6 +241,7 @@ def plan_dbt_interop_from_project(
             dbt_options=dbt_options,
             runner=runner,
             warnings=reuse_warnings,
+            on_progress=on_progress,
         )
         if reuse_warnings:
             plan = replace(plan, warnings=(*plan.warnings, *reuse_warnings))
@@ -275,6 +281,7 @@ def plan_dbt_interop_from_project(
             on_connection_error=(
                 None if connection_progress is None else connection_progress.on_connection_error
             ),
+            on_progress=on_progress,
         )
     dbt_dependency_baseline_plan: DbtReusePlanningResult | None = (
         build_dbt_dependency_baseline_plan_output(
@@ -287,6 +294,7 @@ def plan_dbt_interop_from_project(
             scoped_unique_ids=dependency_baseline_ids,
             dbt_options=dbt_options,
             runner=runner,
+            on_progress=on_progress,
         )
     )
     if dbt_dependency_baseline_plan is not None:

{sqlbuild-0.38.2 → sqlbuild-0.38.4}/src/sqlbuild/spec/models/project.py

@@ -162,6 +162,8 @@ class DbtReuseFromConfig:
 
     git_ref: str | None = None
     generate_schema_name_override: str | None = None
+    refresh: bool = True
+    git_timeout_seconds: int = 30
 
 
 @dataclass(frozen=True)