sqlbuild 0.66.2__tar.gz → 0.66.4__tar.gz

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/Cargo.lock

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

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/PKG-INFO

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

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/pyproject.toml

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

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/_helpers/build_execution/execution.py

@@ -4,6 +4,9 @@ from __future__ import annotations
 
 from typing import Any
 
+from sqlbuild.cli.commands._helpers.build_execution.run_context import (
+    write_build_run_context,
+)
 from sqlbuild.cli.commands._helpers.build_python_nodes.python_lifecycle import (
     prepare_direct_python_lifecycle,
 )
@@ -19,6 +22,7 @@ from sqlbuild.cli.commands.models import (
     BuildCommandRequest,
     BuildExecutionPreparation,
     BuildInvocation,
+    BuildRunContext,
     BuildRunOutcome,
     DirectLifecycleCallbacks,
 )
@@ -60,13 +64,30 @@ def prepare_build_execution(
         if request.concurrency is not None
         else pipeline_result.project.settings.concurrency
     )
-    write_execution_header(
-        stream=invocation.progress_stream,
-        command="sqb build",
-        target=None,
-        concurrency=effective_concurrency,
-        use_color=invocation.use_color,
-    )
+    if request.verbose or request.debug:
+        write_build_run_context(
+            stream=invocation.progress_stream,
+            context=BuildRunContext(
+                command="sqb build",
+                project=pipeline_result.project,
+                plan=pipeline_result.plan_output,
+                discovered_inputs=invocation.discovered_inputs,
+                python_plan_entries=pipeline_result.python_plan_entries,
+                connection_config=invocation.connection_config,
+                concurrency=effective_concurrency,
+                full_refresh=request.full_refresh,
+                selector_files=request.selector_files,
+            ),
+            use_color=invocation.use_color,
+        )
+    else:
+        write_execution_header(
+            stream=invocation.progress_stream,
+            command="sqb build",
+            target=None,
+            concurrency=effective_concurrency,
+            use_color=invocation.use_color,
+        )
     has_ingress_source_loads: bool = bool(pipeline_result.plan_output.source_load_entries)
     execution_connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
         adapter_name=invocation.adapter_name,

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/_helpers/build_execution/no_work.py

@@ -3,11 +3,15 @@
 from datetime import UTC, datetime
 
 from sqlbuild.cli.commands._helpers.build_execution.outputs import write_no_work_build_json
+from sqlbuild.cli.commands._helpers.build_execution.run_context import (
+    write_build_run_context,
+)
 from sqlbuild.cli.commands._helpers.cost.collection import finalize_build_cost
 from sqlbuild.cli.commands.models import (
     BuildCommandRequest,
     BuildCostFinalization,
     BuildInvocation,
+    BuildRunContext,
 )
 from sqlbuild.compiler.pipeline.main.plan_work import plan_has_executable_work
 from sqlbuild.compiler.pipeline.models import CompilePipelineResult
@@ -27,6 +31,27 @@ def finalize_no_work_build_if_needed(
         python_plan_entries=pipeline_result.python_plan_entries,
     ):
         return False
+    if request.verbose or request.debug:
+        effective_concurrency: int = (
+            request.concurrency
+            if request.concurrency is not None
+            else pipeline_result.project.settings.concurrency
+        )
+        write_build_run_context(
+            stream=invocation.progress_stream,
+            context=BuildRunContext(
+                command="sqb build",
+                project=pipeline_result.project,
+                plan=pipeline_result.plan_output,
+                discovered_inputs=invocation.discovered_inputs,
+                python_plan_entries=pipeline_result.python_plan_entries,
+                connection_config=invocation.connection_config,
+                concurrency=effective_concurrency,
+                full_refresh=request.full_refresh,
+                selector_files=request.selector_files,
+            ),
+            use_color=invocation.use_color,
+        )
     completed_at: datetime = datetime.now(UTC)
     cost_record: CostRunRecord | None = finalize_build_cost(
         BuildCostFinalization(

sqlbuild-0.66.4/src/sqlbuild/cli/commands/_helpers/build_execution/run_context.py

@@ -0,0 +1,137 @@
+"""Resolved verbose build-start context output."""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+from pathlib import Path
+from typing import TextIO
+
+from sqlbuild.cli.commands.constants import (
+    C0_CONTROL_CODE_LIMIT,
+    C1_CONTROL_CODE_LIMIT,
+    C1_CONTROL_CODE_START,
+)
+from sqlbuild.cli.commands.models import BuildRunContext
+from sqlbuild.presentation.classes.cli_document import CliDocument
+from sqlbuild.presentation.classes.cli_style import CliStyle
+
+
+def write_build_run_context(*, stream: TextIO, context: BuildRunContext, use_color: bool) -> None:
+    """Write resolved non-secret build placement, mode, and selection context."""
+
+    stream.write(_format_build_run_context(context=context, use_color=use_color))
+    stream.flush()
+
+
+def _format_build_run_context(*, context: BuildRunContext, use_color: bool) -> str:
+    style: CliStyle = CliStyle(use_color=use_color)
+    document: CliDocument = CliDocument(style)
+    selected_count: int = (
+        len(context.plan.model_entries)
+        + len(context.plan.seed_entries)
+        + len(context.plan.function_entries)
+        + len(context.plan.source_load_entries)
+        + len(context.python_plan_entries)
+    )
+    total_source_load_count: int = sum(
+        source.source_entry.loader is not None for source in context.project.sources
+    )
+    total_count: int = (
+        len(context.project.models)
+        + len(context.project.seeds)
+        + len(context.project.functions)
+        + total_source_load_count
+        + len(context.discovered_inputs.task_functions)
+        + len(context.discovered_inputs.asset_functions)
+    )
+    placement_rows: tuple[tuple[str, str], ...]
+    if context.virtual_logical_schema is not None or context.virtual_physical_schema is not None:
+        placement_rows = (
+            ("logical schema", _display_value(context.virtual_logical_schema)),
+            ("physical schema", _display_value(context.virtual_physical_schema)),
+        )
+    else:
+        placement_rows = (("schema", _display_value(context.project.effective_target_schema)),)
+    document.header(text="Execution")
+    document.fields(
+        rows=(
+            ("command", _display_value(context.command)),
+            ("run_id", _display_value(context.project.run_id)),
+            ("target", _display_value(context.project.effective_target_name)),
+            ("database", _display_value(context.project.effective_target_database)),
+            *placement_rows,
+            ("warehouse", _display_value(context.connection_config.get("warehouse"))),
+            ("concurrency", f"{context.concurrency} configured limit"),
+            ("full_refresh", str(context.full_refresh).lower()),
+            ("selected", f"{selected_count:,} of {total_count:,} build resources"),
+            ("date vars", _date_vars_display(context.project.effective_vars)),
+        ),
+        label_width=12,
+    )
+    if context.selector_files:
+        document.blank()
+        document.header(text="Selection files")
+        for selector_file in context.selector_files:
+            selector_noun: str = "selector" if selector_file.selector_count == 1 else "selectors"
+            document.fields(
+                rows=(
+                    (
+                        "selector_file",
+                        f"{_safe_path(selector_file.path)} "
+                        f"({selector_file.selector_count:,} {selector_noun})",
+                    ),
+                ),
+                label_width=12,
+            )
+    document.blank()
+    return document.render()
+
+
+def _display_value(value: object) -> str:
+    display_value: str | None = _safe_display_value(value)
+    return display_value if display_value is not None else "not set"
+
+
+def _safe_display_value(value: object) -> str | None:
+    if isinstance(value, str | int | float) and not isinstance(value, bool):
+        return _sanitize(str(value))
+    return None
+
+
+def _safe_path(path: Path) -> str:
+    return _sanitize(str(path))
+
+
+def _sanitize(value: str) -> str:
+    return "".join(
+        f"\\x{ord(character):02x}"
+        if ord(character) < C0_CONTROL_CODE_LIMIT
+        or C1_CONTROL_CODE_START <= ord(character) < C1_CONTROL_CODE_LIMIT
+        else character
+        for character in value
+    )
+
+
+def _validated_iso_value(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        date.fromisoformat(value)
+    except ValueError:
+        try:
+            datetime.fromisoformat(value)
+        except ValueError:
+            return None
+    return _sanitize(value)
+
+
+def _date_vars_display(effective_vars: dict[str, object]) -> str:
+    start_date: str | None = _validated_iso_value(effective_vars.get("start_date"))
+    end_date: str | None = _validated_iso_value(effective_vars.get("end_date"))
+    if start_date is None and end_date is None:
+        return "not set"
+    if start_date is None:
+        return f"end_date={end_date}"
+    if end_date is None:
+        return f"start_date={start_date}"
+    return f"{start_date} to {end_date}"

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/_helpers/build_virtual/virtual_execution.py

@@ -28,6 +28,8 @@ from sqlbuild.compiler.compile.models import CompiledProject
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
 from sqlbuild.compiler.pipeline.models import PythonPlanEntry
 from sqlbuild.compiler.planner.models import CursorOverrides, PlanOutput
+from sqlbuild.spec.contracts.main.resolve_target_config import resolve_target_config
+from sqlbuild.spec.contracts.main.resolve_target_name import resolve_target_name
 from sqlbuild.virtual.executor.main.build import run_virtual_build as run_virtual_build_pipeline
 from sqlbuild.virtual.executor.models import (
     VirtualBuildExecutionHooks,
@@ -65,6 +67,20 @@ def execute_virtual_build(
         stream=stream,
         use_color=request.use_color,
     )
+    physical_target_name: str | None = resolve_target_name(
+        project_config=discovered_inputs.project_config,
+        local_config=discovered_inputs.local_config,
+        selected_target=request.selected_target,
+    )
+    unsuffixed_virtual_environment_name: str | None = (
+        resolve_target_config(
+            project_config=discovered_inputs.project_config,
+            local_config=discovered_inputs.local_config,
+            target_name=physical_target_name,
+        ).state.unsuffixed_virtual_env
+        if physical_target_name is not None
+        else None
+    )
     plan_hook: VirtualBuildPlanHook = VirtualBuildPlanHook(
         stream=stream,
         project_dir=project_dir,
@@ -79,6 +95,12 @@ def execute_virtual_build(
             json_output=request.json_output,
             execution_command=request.execution_command,
             concurrency=request.concurrency,
+            connection_config=connection_config,
+            selector_files=request.selector_files,
+            virtual_environment_name=(
+                request.virtual_environment_name or physical_target_name or "default"
+            ),
+            unsuffixed_virtual_environment_name=unsuffixed_virtual_environment_name,
         ),
     )
     cursor_overrides: CursorOverrides = request.cursor_overrides or CursorOverrides()

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -6,7 +6,7 @@ import logging
 from pathlib import Path
 
 from sqlbuild.cli.commands._helpers.diff.validation import parse_diff_name_range
-from sqlbuild.cli.commands._helpers.entry.parsing import read_selector_files
+from sqlbuild.cli.commands._helpers.entry.parsing import read_selector_file_inputs
 from sqlbuild.cli.commands.classes.cli_namespace import CliNamespace
 from sqlbuild.cli.commands.constants import (
     DBT_INIT_COMMAND,
@@ -42,6 +42,7 @@ from sqlbuild.cli.commands.models import (
     ScenarioTestCommandRequest,
     ScopeCommandRequest,
     SeedCommandRequest,
+    SelectorInputs,
     TestCommandRequest,
 )
 from sqlbuild.cli.commands.types import CliCommand, CompileLineageMode
@@ -59,7 +60,8 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
     project_dir: Path | None = None if args.project_dir is None else Path(args.project_dir)
     effective_project_dir: Path = project_dir if project_dir is not None else Path.cwd()
     _configure_diagnostics(args=args, effective_project_dir=effective_project_dir)
-    select: tuple[str, ...] = (*tuple(args.select), *read_selector_files(args.select_file))
+    selector_inputs: SelectorInputs = read_selector_file_inputs(args.select_file)
+    select: tuple[str, ...] = (*tuple(args.select), *selector_inputs.selectors)
     if args.command == CliCommand.COMPILE:
         return handlers.run_compile(
             CompileCommandRequest(
@@ -177,6 +179,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 allow_snapshot_schema_change=args.allow_snapshot_schema_change,
                 concurrency=args.concurrency,
                 select=select,
+                selector_files=selector_inputs.files,
                 exclude=tuple(args.exclude),
                 verbose=args.verbose,
                 debug=args.debug,

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/_helpers/entry/parsing.py

@@ -18,7 +18,11 @@ from sqlbuild.cli.commands.constants import (
     SCOPE_GLOBAL_SUMMARY,
     SQLBUILD_CONCURRENCY_ENV_VAR,
 )
-from sqlbuild.cli.commands.models import ParsedCliInvocation
+from sqlbuild.cli.commands.models import (
+    ParsedCliInvocation,
+    SelectorFileSummary,
+    SelectorInputs,
+)
 from sqlbuild.cli.commands.types import CliCommand
 from sqlbuild.compiler.scopes.types import DeclarationKind
 from sqlbuild.integrations.dbt.types import DbtInteropCommand
@@ -53,17 +57,27 @@ def resolve_env_default_concurrency(explicit_concurrency: int | None) -> int | N
 
 
 def read_selector_files(paths: list[str]) -> tuple[str, ...]:
-    """Read newline-delimited selector files."""
+    """Read newline-delimited selectors."""
+
+    return read_selector_file_inputs(paths).selectors
+
+
+def read_selector_file_inputs(paths: list[str]) -> SelectorInputs:
+    """Read newline-delimited selectors while retaining file provenance."""
 
     selectors: list[str] = []
+    files: list[SelectorFileSummary] = []
     for raw_path in paths:
         path: Path = Path(raw_path)
+        file_selector_count: int = 0
         for line in path.read_text(encoding="utf-8").splitlines():
             stripped: str = line.strip()
             if not stripped or stripped.startswith("#"):
                 continue
             selectors.append(stripped)
-    return tuple(selectors)
+            file_selector_count += 1
+        files.append(SelectorFileSummary(path=path, selector_count=file_selector_count))
+    return SelectorInputs(selectors=tuple(selectors), files=tuple(files))
 
 
 def parse_cli_invocation(

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/classes/virtual_build_plan_hook.py

@@ -7,14 +7,18 @@ from pathlib import Path
 from typing import TextIO
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.cli.commands._helpers.build_execution.run_context import (
+    write_build_run_context,
+)
 from sqlbuild.cli.commands._helpers.build_planning.full_refresh import (
     enforce_snapshot_full_refresh_policy,
 )
 from sqlbuild.cli.commands._helpers.compile.target_writer import write_compile_target
 from sqlbuild.cli.commands.classes.build_progress_callbacks import BuildProgressCallbacks
-from sqlbuild.cli.commands.models import VirtualBuildPlanHookConfig
+from sqlbuild.cli.commands.models import BuildRunContext, VirtualBuildPlanHookConfig
 from sqlbuild.cli.output.main.plan import format_plan
 from sqlbuild.cli.progress.main._write_execution_header import write_execution_header
+from sqlbuild.compiler.compile.models import CompiledProject
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
 from sqlbuild.compiler.pipeline.models import PythonPlanEntry
 from sqlbuild.compiler.planner.models import PlanOutput
@@ -46,6 +50,10 @@ class VirtualBuildPlanHook:
         self._json_output = config.json_output
         self._execution_command = config.execution_command
         self._concurrency = config.concurrency
+        self._connection_config = config.connection_config
+        self._selector_files = config.selector_files
+        self._virtual_environment_name = config.virtual_environment_name or "default"
+        self._unsuffixed_virtual_environment_name = config.unsuffixed_virtual_environment_name
         self.callbacks: BuildProgressCallbacks | None = None
 
     @property
@@ -57,13 +65,12 @@ class VirtualBuildPlanHook:
     def on_plan_ready(
         self,
         *,
-        project: object,
+        project: CompiledProject,
         plan_output: PlanOutput,
         python_plan_entries: tuple[PythonPlanEntry, ...],
     ) -> VirtualBuildExecutionHooks:
         """Render the plan and return node progress hooks for execution."""
 
-        del project
         plan_text: str = format_plan(
             plan=plan_output,
             full_refresh=self._full_refresh,
@@ -92,15 +99,45 @@ class VirtualBuildPlanHook:
             debug=self._debug or self._json_output,
         )
         self.callbacks = callbacks
-        write_execution_header(
-            stream=self._stream,
-            command=f"sqb {self._execution_command}",
-            target=None,
-            concurrency=self._concurrency
-            if self._concurrency is not None
-            else self._discovered_inputs.project_config.settings.concurrency,
-            use_color=self._use_color,
+        effective_concurrency: int = (
+            self._concurrency if self._concurrency is not None else project.settings.concurrency
         )
+        if self._verbose or self._debug:
+            base_schema: str | None = project.effective_target_schema
+            logical_schema: str | None = base_schema
+            if (
+                base_schema is not None
+                and self._unsuffixed_virtual_environment_name != self._virtual_environment_name
+            ):
+                logical_schema = f"{base_schema}__{self._virtual_environment_name}"
+            physical_schema: str | None = (
+                f"{base_schema}__sqb_physical" if base_schema is not None else None
+            )
+            write_build_run_context(
+                stream=self._stream,
+                context=BuildRunContext(
+                    command=f"sqb {self._execution_command}",
+                    project=project,
+                    plan=plan_output,
+                    discovered_inputs=self._discovered_inputs,
+                    python_plan_entries=python_plan_entries,
+                    connection_config=self._connection_config,
+                    concurrency=effective_concurrency,
+                    full_refresh=self._full_refresh,
+                    selector_files=self._selector_files,
+                    virtual_logical_schema=logical_schema,
+                    virtual_physical_schema=physical_schema,
+                ),
+                use_color=self._use_color,
+            )
+        else:
+            write_execution_header(
+                stream=self._stream,
+                command=f"sqb {self._execution_command}",
+                target=None,
+                concurrency=effective_concurrency,
+                use_color=self._use_color,
+            )
         return VirtualBuildExecutionHooks(
             on_node_start=lambda name, resource_kind: callbacks.on_node_start(
                 name=name, resource_kind=resource_kind

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/constants.py

@@ -4,6 +4,9 @@ from sqlbuild.cli.commands.types import CompileLineageMode, PlaygroundTemplate
 from sqlbuild.compiler.lineage.types import ColumnLineageMode
 from sqlbuild.compiler.planner.types import SelectorKind
 
+C0_CONTROL_CODE_LIMIT: int = 32
+C1_CONTROL_CODE_START: int = 127
+C1_CONTROL_CODE_LIMIT: int = 160
 COMPILE_LINEAGE_MODE_VALUES: tuple[str, ...] = tuple(mode.value for mode in CompileLineageMode)
 RICH_LINEAGE_STATUS_MODEL_THRESHOLD: int = 100
 EMPTY_DAG_PATH: str = ""

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/main/execution/_build.py

@@ -80,6 +80,7 @@ def run_build(request: BuildCommandRequest) -> int:
                     reload_sources=request.reload_sources,
                     include_python=request.include_python,
                     select=request.select,
+                    selector_files=request.selector_files,
                     exclude=request.exclude,
                     fail_fast=request.fail_fast,
                     allow_snapshot_full_refresh=request.allow_snapshot_full_refresh,

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/cli/commands/models.py

@@ -55,6 +55,7 @@ from sqlbuild.compiler.pipeline.models import (
     ClonePipelineResult,
     CompilePipelineResult,
     ProjectGraph,
+    PythonPlanEntry,
 )
 from sqlbuild.compiler.planner.models import CursorOverrides, PlanOutput
 from sqlbuild.compiler.python_nodes.models import PythonNodeGraph, PythonSqlRunLifecyclePlan
@@ -150,6 +151,39 @@ class AuditExecutionPreparation:
     execution_connection_progress: ConnectionProgressReporter
 
 
+@dataclass(frozen=True)
+class SelectorFileSummary:
+    """Non-expanded provenance for one selector file."""
+
+    path: Path
+    selector_count: int
+
+
+@dataclass(frozen=True)
+class SelectorInputs:
+    """Expanded selectors paired with selector-file provenance."""
+
+    selectors: tuple[str, ...]
+    files: tuple[SelectorFileSummary, ...]
+
+
+@dataclass(frozen=True)
+class BuildRunContext:
+    """Resolved inputs needed to render one build execution context."""
+
+    command: str
+    project: CompiledProject
+    plan: PlanOutput
+    discovered_inputs: DiscoveredProjectInputs
+    python_plan_entries: tuple[PythonPlanEntry, ...]
+    connection_config: dict[str, object]
+    concurrency: int
+    full_refresh: bool
+    selector_files: tuple[SelectorFileSummary, ...]
+    virtual_logical_schema: str | None = None
+    virtual_physical_schema: str | None = None
+
+
 @dataclass(frozen=True)
 class BuildCommandRequest:
     """CLI inputs for one build command invocation."""
@@ -185,6 +219,7 @@ class BuildCommandRequest:
     json_output_path: Path | None = None
     event_output_path: Path | None = None
     no_cache: bool = False
+    selector_files: tuple[SelectorFileSummary, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -285,6 +320,10 @@ class VirtualBuildPlanHookConfig:
     json_output: bool
     execution_command: str
     concurrency: int | None
+    connection_config: dict[str, object] = field(default_factory=dict)
+    selector_files: tuple[SelectorFileSummary, ...] = ()
+    virtual_environment_name: str | None = None
+    unsuffixed_virtual_environment_name: str | None = None
 
 
 @dataclass(frozen=True)
@@ -321,6 +360,7 @@ class VirtualBuildCliRequest:
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None
     providers: ProviderContainer | None = None
     no_cache: bool = False
+    selector_files: tuple[SelectorFileSummary, ...] = ()
 
 
 @dataclass(frozen=True)

{sqlbuild-0.66.2 → sqlbuild-0.66.4}/src/sqlbuild/integrations/dagster/classes/sqlbuild_dagster_translator.py

@@ -58,6 +58,9 @@ class SqlBuildDagsterTranslator:
         sql: object = node.get("sql")
         if isinstance(sql, str) and sql.strip():
             return f"{description}\n\n**SQLBuild SQL:**\n```sql\n{sql.strip()}\n```"
+        path: object = node.get("path")
+        if isinstance(path, str) and path:
+            return f"{description}\n\n**Source file:** {_markdown_code_span(path)}"
         return description
 
     def get_check_name(self, check: Mapping[str, Any]) -> str:
@@ -87,6 +90,15 @@ def _normalize_name(value: str) -> str:
     return normalized or "check"
 
 
+def _markdown_code_span(value: str) -> str:
+    longest_backtick_run: int = max(
+        (len(match.group()) for match in re.finditer(r"`+", value)), default=0
+    )
+    delimiter: str = "`" * (longest_backtick_run + 1)
+    padding: str = " " if value.startswith(("`", " ")) or value.endswith(("`", " ")) else ""
+    return f"{delimiter}{padding}{value}{padding}{delimiter}"
+
+
 def _fallback_description(node: Mapping[str, Any]) -> str:
     kind: str = str(node.get("kind") or "asset").replace("_", " ")
     name: str = str(node.get("name") or "unknown")