sqlbuild 0.84.0__tar.gz → 0.85.0__tar.gz

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/Cargo.lock

@@ -597,7 +597,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.84.0"
+version = "0.85.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/PKG-INFO

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

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/pyproject.toml

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

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/compiler/compile/_helpers/assembly/project.py

@@ -930,6 +930,7 @@ def _assemble_compiled_function(
         entry_point=function_input.entry_point,
         packages=function_input.packages,
         replay_on_change=function_input.replay_on_change,
+        tags=function_input.tags,
     )
 
 

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/compiler/compile/_helpers/attachment/functions.py

@@ -269,6 +269,11 @@ def build_sql_function_inputs(
                     relative_path=function_file.relative_path,
                     language="SQL",
                 ),
+                tags=_parse_function_tags(
+                    header_values=header_values,
+                    relative_path=function_file.relative_path,
+                    language="SQL",
+                ),
                 declaration_usages=expansion.usages,
             )
         )
@@ -455,6 +460,11 @@ def _build_python_function_input(
             relative_path=python_function_file.relative_path,
             language="Python",
         ),
+        tags=_parse_function_tags(
+            header_values=header_values,
+            relative_path=python_function_file.relative_path,
+            language="Python",
+        ),
     )
 
 
@@ -623,6 +633,24 @@ def _parse_python_packages(*, raw_packages: object | None, relative_path: Path)
     return tuple(packages)
 
 
+def _parse_function_tags(
+    *, header_values: dict[str, object], relative_path: Path, language: str
+) -> tuple[str, ...]:
+    raw_tags: object | None = header_values.get("tags")
+    if raw_tags is None:
+        return ()
+    if not isinstance(raw_tags, list | tuple):
+        raise CompileInputError(f"{language} function file {relative_path} tags must be a list")
+    tags: list[str] = []
+    for tag in raw_tags:
+        if not isinstance(tag, str) or not tag.strip():
+            raise CompileInputError(
+                f"{language} function file {relative_path} tags entries must be non-empty strings"
+            )
+        tags.append(tag.strip())
+    return tuple(tags)
+
+
 def _expand_function_header_value(
     *, raw_value: str, effective_vars: dict[str, object], context_label: str
 ) -> str:

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/compiler/compile/models.py

@@ -511,6 +511,7 @@ class CompileSqlFunctionInput:
     packages: tuple[str, ...] = field(default_factory=tuple)
     replay_on_change: str | None = None
     declaration_usages: tuple[UsageRecord, ...] = field(default_factory=tuple)
+    tags: tuple[str, ...] = field(default_factory=tuple)
 
 
 @dataclass(frozen=True)
@@ -716,6 +717,7 @@ class CompiledFunction:
     entry_point: str | None = None
     packages: tuple[str, ...] = field(default_factory=tuple)
     replay_on_change: str | None = None
+    tags: tuple[str, ...] = field(default_factory=tuple)
 
 
 @dataclass(frozen=True)

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/compiler/dag/_helpers/artifact.py

@@ -179,6 +179,7 @@ def _build_seed_node(seed: CompiledSeed) -> DagNode:
         target=_dag_target(seed.destination),
         path=str(seed.seed_file.relative_path),
         description=seed.schema_entry.description,
+        tags=seed.schema_entry.tags,
         meta=seed.schema_entry.meta,
         columns=tuple(_schema_column(column) for column in seed.schema_entry.columns),
     )
@@ -195,6 +196,7 @@ def _build_function_node(function: CompiledFunction) -> DagNode:
         path=str(function.relative_path),
         sql=function.body_sql,
         language=function.language.value,
+        tags=function.tags,
         return_kind="table" if function.return_columns else "scalar",
         returns=function.returns,
         columns=tuple(

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/compiler/discovery/_helpers/yml/schema.py

@@ -211,6 +211,13 @@ def _parse_seed_entry(*, entry: dict[str, object], file_path: Path) -> SchemaSee
         meta=optional_mapping(
             entry=entry, key="meta", file_path=file_path, label="seed", error_class=SchemaParseError
         ),
+        tags=optional_string_tuple(
+            entry=entry,
+            key="tags",
+            file_path=file_path,
+            label="seed",
+            error_class=SchemaParseError,
+        ),
         csv_settings=_parse_seed_csv_settings(entry=entry, file_path=file_path),
         columns=columns,
     )

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/compiler/manifest/_helpers/seeds.py

@@ -40,7 +40,7 @@ def build_seed_node(
             "alias": None,
             "schema": seed.destination.schema,
             "database": seed.destination.database,
-            "tags": [],
+            "tags": list(seed.schema_entry.tags),
             "meta": {},
             "group": None,
             "materialized": "seed",
@@ -60,7 +60,7 @@ def build_seed_node(
             "delimiter": ",",
             "quote_columns": None,
         },
-        "tags": [],
+        "tags": list(seed.schema_entry.tags),
         "description": seed.schema_entry.description or "",
         "columns": build_columns_dict(seed.schema_entry),
         "meta": dict(seed.schema_entry.meta) if seed.schema_entry.meta else {},

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/compiler/planner/_helpers/graph/selector_indexes.py

@@ -1,11 +1,13 @@
-"""Model selector index implementations."""
+"""Project resource selector index implementations."""
 
 from __future__ import annotations
 
 from sqlbuild.compiler.compile.models import (
+    CompiledFunction,
     CompiledModel,
     CompiledObjectKey,
     CompiledProject,
+    CompiledSeed,
 )
 from sqlbuild.compiler.planner.constants import MODEL_SELECTOR_ROOT, MODEL_SELECTOR_ROOT_PREFIX
 
@@ -13,7 +15,7 @@ from sqlbuild.compiler.planner.constants import MODEL_SELECTOR_ROOT, MODEL_SELEC
 def build_model_tag_index_impl(
     project: CompiledProject,
 ) -> dict[str, frozenset[CompiledObjectKey]]:
-    """Build a tag-to-keys lookup from compiled model configs."""
+    """Build a tag-to-keys lookup from compiled models, seeds, and functions."""
 
     index: dict[str, set[CompiledObjectKey]] = {}
     model: CompiledModel
@@ -21,6 +23,14 @@ def build_model_tag_index_impl(
         tag: str
         for tag in _as_string_list(model.config.values.get("tags")):
             index.setdefault(tag, set()).add(model.key)
+    seed: CompiledSeed
+    for seed in project.seeds:
+        for tag in seed.schema_entry.tags:
+            index.setdefault(tag, set()).add(seed.key)
+    function: CompiledFunction
+    for function in project.functions:
+        for tag in function.tags:
+            index.setdefault(tag, set()).add(function.key)
     return {tag: frozenset(keys) for tag, keys in index.items()}
 
 

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/integrations/dagster/__init__.py

@@ -5,6 +5,9 @@ from sqlbuild.integrations.dagster.classes.sqlbuild_cli_resource import SqlBuild
 from sqlbuild.integrations.dagster.classes.sqlbuild_dagster_translator import (
     SqlBuildDagsterTranslator,
 )
+from sqlbuild.integrations.dagster.main._build_sqlbuild_asset_selection import (
+    build_sqlbuild_asset_selection,
+)
 from sqlbuild.integrations.dagster.main._sqlbuild_assets import sqlbuild_assets
 from sqlbuild.integrations.dagster.main._sqlbuild_scenario_checks import sqlbuild_scenario_checks
 from sqlbuild.integrations.dagster.models import SqlBuildProject
@@ -14,6 +17,7 @@ __all__ = [
     "SqlBuildCliResource",
     "SqlBuildDagsterTranslator",
     "SqlBuildProject",
+    "build_sqlbuild_asset_selection",
     "sqlbuild_assets",
     "sqlbuild_scenario_checks",
 ]

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/integrations/dagster/_helpers/assets.py

@@ -31,6 +31,8 @@ def build_asset_specs(
         if str(node.get("kind")) not in DAGSTER_ASSET_NODE_KINDS:
             continue
         translated_node: Mapping[str, Any] = {**node, "project_name": project_name}
+        if not translator.is_asset_node(translated_node):
+            continue
         deps: list[Any] = []
         for upstream_id in upstream_by_id.get(str(node["id"]), []):
             upstream_node: Mapping[str, Any] | None = nodes_by_id.get(upstream_id)
@@ -95,6 +97,8 @@ def _build_check_specs(
     specs: list[Any] = []
     for check in dag["checks"]:
         check_kind: str = str(check.get("kind"))
+        if not translator.is_asset_check(check):
+            continue
         if check_kind in excluded_kinds:
             continue
         if kinds is not None and check_kind not in kinds:
@@ -103,6 +107,8 @@ def _build_check_specs(
             node: Mapping[str, Any] | None = nodes_by_id.get(str(asset_id))
             if node is None:
                 continue
+            if not translator.is_asset_node(node):
+                continue
             specs.append(
                 dg.AssetCheckSpec(
                     name=translator.get_check_name(check),
@@ -115,7 +121,8 @@ def _build_check_specs(
 
 
 def _nodes_by_id(dag: Mapping[str, Any]) -> dict[str, Mapping[str, Any]]:
-    return {str(node["id"]): node for node in dag["nodes"]}
+    project_name: object = dag.get("project_name")
+    return {str(node["id"]): {**node, "project_name": project_name} for node in dag["nodes"]}
 
 
 def _upstream_by_id(dag: Mapping[str, Any]) -> dict[str, list[str]]:

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/integrations/dagster/_helpers/invocation.py

@@ -11,6 +11,10 @@ from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any, TextIO
 
 from sqlbuild.cli.output.models import IntegrationAssetResult, IntegrationResultEnvelope
+from sqlbuild.integrations.dagster._helpers.translation import (
+    is_dagster_asset_enabled,
+    is_dagster_check_enabled,
+)
 from sqlbuild.integrations.dagster.constants import (
     ASSET_SELECTION_COMMANDS,
     CHECK_COMMAND,
@@ -18,6 +22,7 @@ from sqlbuild.integrations.dagster.constants import (
     CHECK_NAME_SEPARATOR_CHARACTER,
     CLONE_COMMAND,
     COMPLETED_EXECUTION_STATUSES,
+    DAGSTER_CHECK_NAME_FIELD,
     DEFAULT_SELECTABLE_NODE_KINDS,
     EVENT_OUTPUT_FLAG,
     EXPLICIT_SELECTION_FLAGS,
@@ -152,6 +157,8 @@ def _with_selected_scenario_args(
     selectors: list[str] = []
     check: Mapping[str, Any]
     for check in dag.get("checks", ()):  # type: ignore[assignment]
+        if not is_dagster_check_enabled(check):
+            continue
         if str(check.get("kind")) != SCENARIO_CHECK_KIND:
             continue
         if not selected_asset_ids.intersection(
@@ -361,6 +368,8 @@ def _build_results_for_selected_assets(
         nodes = selected_nodes
     results: list[Any] = []
     for node in nodes:
+        if not is_dagster_asset_enabled(node):
+            continue
         if not _is_materializable_node_kind(str(node.get("kind"))):
             continue
         asset_path = []
@@ -460,6 +469,8 @@ def _build_results_from_execution_payload(
         execution_asset: Mapping[str, Any] | None = asset_results_by_id.get(node_id)
         if execution_asset is None:
             continue
+        if not is_dagster_asset_enabled(node):
+            continue
         asset_key: Any = dg.AssetKey([str(part) for part in node["asset_key"]])
         if selected_paths and tuple(asset_key.path) not in selected_paths:
             continue
@@ -556,6 +567,8 @@ def _build_results_from_integration_result(
             if projected is None:
                 continue
             projected_node, projected_asset = projected
+            if not is_dagster_asset_enabled(candidate):
+                continue
             asset_key: Any = dg.AssetKey([str(part) for part in candidate["asset_key"]])
             if selected_paths and tuple(asset_key.path) not in selected_paths:
                 continue
@@ -629,6 +642,8 @@ def _build_check_results_from_execution_check(
     seen_check_outputs: set[tuple[tuple[str, ...], str]],
 ) -> tuple[tuple[Any, ...], set[tuple[tuple[str, ...], str]]]:
     dag_check: Mapping[str, Any] | None = _dag_check_for_execution_check(dag=dag, check=check)
+    if dag_check is not None and not is_dagster_check_enabled(dag_check):
+        return (), seen_check_outputs
     asset_ids: tuple[str, ...]
     check_name: str
     if dag_check is not None:
@@ -643,6 +658,8 @@ def _build_check_results_from_execution_check(
         node: Mapping[str, Any] | None = nodes_by_id.get(asset_id)
         if node is None:
             continue
+        if not is_dagster_asset_enabled(node):
+            continue
         asset_key: Any = dg.AssetKey([str(part) for part in node["asset_key"]])
         output_key: tuple[tuple[str, ...], str] = (tuple(asset_key.path), check_name)
         if emitted_asset_paths is not None and tuple(asset_key.path) not in emitted_asset_paths:
@@ -744,6 +761,8 @@ def _selected_check_asset_paths(
     }
     paths: set[tuple[str, ...]] = set()
     for check in dag.get("checks", ()):  # type: ignore[assignment]
+        if not is_dagster_check_enabled(check):
+            continue
         check_name: str = _dagster_check_name(check)
         if not _check_is_selected(
             check=check,
@@ -769,6 +788,8 @@ def _selected_check_selectors(
     }
     selectors: list[str] = []
     for check in dag.get("checks", ()):  # type: ignore[assignment]
+        if not is_dagster_check_enabled(check):
+            continue
         if _check_is_selected(
             check=check,
             check_name=_dagster_check_name(check),
@@ -810,6 +831,9 @@ def _asset_ids_for_execution_check(
 
 
 def _dagster_check_name(check: Mapping[str, Any]) -> str:
+    translated_name: object = check.get(DAGSTER_CHECK_NAME_FIELD)
+    if translated_name is not None:
+        return str(translated_name)
     parts: list[str] = [str(check.get("kind", "check")), str(check.get("name", "check"))]
     if check.get("attached_column_name") is not None:
         parts.append(str(check["attached_column_name"]))

sqlbuild-0.85.0/src/sqlbuild/integrations/dagster/_helpers/selection.py

@@ -0,0 +1,238 @@
+"""Dagster asset selection backed by a SQLBuild DAG artifact."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from sqlbuild.compiler.planner.main.selection.selector_parse import parse_project_selector
+from sqlbuild.compiler.planner.models import ParsedSelector, PathSelector
+from sqlbuild.compiler.planner.types import SelectorKind
+from sqlbuild.integrations.dagster._helpers.dag import load_sqlbuild_dag
+from sqlbuild.integrations.dagster._helpers.imports import load_dagster
+from sqlbuild.integrations.dagster.classes.sqlbuild_dagster_translator import (
+    SqlBuildDagsterTranslator,
+)
+from sqlbuild.integrations.dagster.constants import DAGSTER_ASSET_NODE_KINDS
+from sqlbuild.integrations.dagster.exceptions import DagsterDagInputError
+from sqlbuild.integrations.dagster.types import SqlBuildDagInput
+
+
+def build_sqlbuild_asset_selection_impl(
+    *,
+    sqlbuild_assets: Sequence[Any],
+    dag: SqlBuildDagInput,
+    sqlbuild_select: str,
+    sqlbuild_exclude: str | None = None,
+    translator: SqlBuildDagsterTranslator | None = None,
+) -> Any:
+    """Resolve canonical SQLBuild selectors into a Dagster asset selection."""
+
+    if not sqlbuild_assets:
+        raise DagsterDagInputError("SQLBuild asset selection requires an asset definition")
+    resolved_dag: Mapping[str, Any] = load_sqlbuild_dag(dag)
+    resolved_translator: SqlBuildDagsterTranslator = translator or SqlBuildDagsterTranslator()
+    selected_ids: set[str] = _resolve_dag_selectors(
+        dag=resolved_dag,
+        select=sqlbuild_select,
+        exclude=sqlbuild_exclude,
+    )
+    asset_keys: list[Any] = []
+    project_name: object = resolved_dag.get("project_name")
+    for node in resolved_dag.get("nodes", ()):
+        if str(node.get("id")) not in selected_ids:
+            continue
+        if str(node.get("kind")) not in DAGSTER_ASSET_NODE_KINDS:
+            continue
+        translated_node: Mapping[str, Any] = {**node, "project_name": project_name}
+        if not resolved_translator.is_asset_node(translated_node):
+            continue
+        asset_keys.append(resolved_translator.get_asset_key(translated_node))
+    return load_dagster().AssetSelection.assets(*asset_keys)
+
+
+def _resolve_dag_selectors(*, dag: Mapping[str, Any], select: str, exclude: str | None) -> set[str]:
+    nodes_by_id: dict[str, Mapping[str, Any]] = {
+        str(node["id"]): node for node in dag.get("nodes", ())
+    }
+    upstream, downstream = _dependency_indexes(dag=dag, node_ids=set(nodes_by_id))
+    selected: set[str] = _resolve_expression(
+        expression=select,
+        dag=dag,
+        nodes_by_id=nodes_by_id,
+        upstream=upstream,
+        downstream=downstream,
+    )
+    if exclude:
+        selected.difference_update(
+            _resolve_expression(
+                expression=exclude,
+                dag=dag,
+                nodes_by_id=nodes_by_id,
+                upstream=upstream,
+                downstream=downstream,
+            )
+        )
+    return selected
+
+
+def _resolve_expression(
+    *,
+    expression: str,
+    dag: Mapping[str, Any],
+    nodes_by_id: Mapping[str, Mapping[str, Any]],
+    upstream: Mapping[str, set[str]],
+    downstream: Mapping[str, set[str]],
+) -> set[str]:
+    selected: set[str] = set()
+    for token in expression.split():
+        intersections: list[set[str]] = [
+            _resolve_atomic(
+                raw=part,
+                dag=dag,
+                nodes_by_id=nodes_by_id,
+                upstream=upstream,
+                downstream=downstream,
+            )
+            for part in token.split(",")
+        ]
+        token_selection: set[str] = intersections[0]
+        for intersection in intersections[1:]:
+            token_selection.intersection_update(intersection)
+        selected.update(token_selection)
+    return selected
+
+
+def _resolve_atomic(
+    *,
+    raw: str,
+    dag: Mapping[str, Any],
+    nodes_by_id: Mapping[str, Mapping[str, Any]],
+    upstream: Mapping[str, set[str]],
+    downstream: Mapping[str, set[str]],
+) -> set[str]:
+    parsed: ParsedSelector | PathSelector = parse_project_selector(raw)
+    if isinstance(parsed, PathSelector):
+        start_id: str = _node_id_for_name(nodes_by_id=nodes_by_id, name=parsed.start_name)
+        end_id: str = _node_id_for_name(nodes_by_id=nodes_by_id, name=parsed.end_name)
+        matched: set[str] = _shortest_path(start_id=start_id, end_id=end_id, downstream=downstream)
+        if parsed.upstream:
+            matched.update(_expand(start_ids={start_id}, adjacency=upstream))
+        if parsed.downstream:
+            matched.update(_expand(start_ids={end_id}, adjacency=downstream))
+        return matched
+
+    matched = _match_parsed_selector(parsed=parsed, dag=dag, nodes_by_id=nodes_by_id)
+    if parsed.upstream:
+        matched.update(_expand(start_ids=matched, adjacency=upstream))
+    if parsed.downstream:
+        matched.update(_expand(start_ids=matched, adjacency=downstream))
+    return matched
+
+
+def _match_parsed_selector(
+    *,
+    parsed: ParsedSelector,
+    dag: Mapping[str, Any],
+    nodes_by_id: Mapping[str, Mapping[str, Any]],
+) -> set[str]:
+    if parsed.kind == SelectorKind.TAG:
+        return {
+            node_id
+            for node_id, node in nodes_by_id.items()
+            if _node_has_tag(node=node, tag=parsed.value)
+        }
+    if parsed.kind == SelectorKind.PATH:
+        folder: str = parsed.value.replace("\\", "/").strip("/")
+        return {
+            node_id
+            for node_id, node in nodes_by_id.items()
+            if _path_is_under(path=node.get("path"), folder=folder)
+        }
+    if parsed.kind == SelectorKind.CHECK:
+        checked_ids: set[str] = set()
+        for check in dag.get("checks", ()):
+            if str(check.get("name")) == parsed.value or str(check.get("id")) == parsed.value:
+                checked_ids.update(str(asset_id) for asset_id in check.get("checked_asset_ids", ()))
+        return checked_ids
+    expected_kind: str | None = None if parsed.kind == SelectorKind.NAME else str(parsed.kind.value)
+    return {
+        node_id
+        for node_id, node in nodes_by_id.items()
+        if str(node.get("name")) == parsed.value
+        and (expected_kind is None or str(node.get("kind")) == expected_kind)
+    }
+
+
+def _node_has_tag(*, node: Mapping[str, Any], tag: str) -> bool:
+    return any(str(node_tag) == tag for node_tag in node.get("tags", ()))
+
+
+def _path_is_under(*, path: object, folder: str) -> bool:
+    if not isinstance(path, str):
+        return False
+    normalized_path: str = path.replace("\\", "/").strip("/")
+    candidates: tuple[str, ...] = (
+        folder,
+        f"models/{folder}" if folder and not folder.startswith("models/") else folder,
+    )
+    return any(
+        normalized_path == candidate or normalized_path.startswith(f"{candidate}/")
+        for candidate in candidates
+        if candidate
+    )
+
+
+def _dependency_indexes(
+    *, dag: Mapping[str, Any], node_ids: set[str]
+) -> tuple[dict[str, set[str]], dict[str, set[str]]]:
+    upstream: dict[str, set[str]] = {node_id: set() for node_id in node_ids}
+    downstream: dict[str, set[str]] = {node_id: set() for node_id in node_ids}
+    for edge in dag.get("edges", ()):
+        from_id: str = str(edge.get("from_id"))
+        to_id: str = str(edge.get("to_id"))
+        if from_id not in node_ids or to_id not in node_ids:
+            continue
+        upstream[to_id].add(from_id)
+        downstream[from_id].add(to_id)
+    return upstream, downstream
+
+
+def _expand(*, start_ids: set[str], adjacency: Mapping[str, set[str]]) -> set[str]:
+    expanded: set[str] = set(start_ids)
+    pending: list[str] = list(start_ids)
+    while pending:
+        node_id: str = pending.pop()
+        for adjacent_id in adjacency.get(node_id, set()):
+            if adjacent_id in expanded:
+                continue
+            expanded.add(adjacent_id)
+            pending.append(adjacent_id)
+    return expanded
+
+
+def _node_id_for_name(*, nodes_by_id: Mapping[str, Mapping[str, Any]], name: str) -> str:
+    matching_ids: list[str] = [
+        node_id for node_id, node in nodes_by_id.items() if str(node.get("name")) == name
+    ]
+    if len(matching_ids) != 1:
+        raise DagsterDagInputError(
+            f"SQLBuild selector name {name!r} matched {len(matching_ids)} DAG nodes"
+        )
+    return matching_ids[0]
+
+
+def _shortest_path(*, start_id: str, end_id: str, downstream: Mapping[str, set[str]]) -> set[str]:
+    pending: deque[tuple[str, tuple[str, ...]]] = deque([(start_id, (start_id,))])
+    visited: set[str] = {start_id}
+    while pending:
+        node_id, path = pending.popleft()
+        if node_id == end_id:
+            return set(path)
+        for adjacent_id in downstream.get(node_id, set()):
+            if adjacent_id in visited:
+                continue
+            visited.add(adjacent_id)
+            pending.append((adjacent_id, (*path, adjacent_id)))
+    raise DagsterDagInputError(f"no SQLBuild DAG path exists between {start_id!r} and {end_id!r}")

sqlbuild-0.85.0/src/sqlbuild/integrations/dagster/_helpers/translation.py

@@ -0,0 +1,55 @@
+"""Runtime projection of SQLBuild DAG records through a Dagster translator."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from sqlbuild.integrations.dagster.classes.sqlbuild_dagster_translator import (
+    SqlBuildDagsterTranslator,
+)
+from sqlbuild.integrations.dagster.constants import (
+    DAGSTER_ASSET_ENABLED_FIELD,
+    DAGSTER_CHECK_ENABLED_FIELD,
+    DAGSTER_CHECK_NAME_FIELD,
+)
+
+
+def translate_sqlbuild_dag(
+    *, dag: Mapping[str, Any], translator: SqlBuildDagsterTranslator
+) -> Mapping[str, Any]:
+    """Return an in-memory DAG whose runtime identities match its static Dagster specs."""
+
+    project_name: object = dag.get("project_name")
+    translated_nodes: list[dict[str, Any]] = []
+    for node in dag.get("nodes", ()):
+        translated_node: dict[str, Any] = {**node, "project_name": project_name}
+        asset_enabled: bool = translator.is_asset_node(translated_node)
+        asset_key: Any = translator.get_asset_key(translated_node)
+        translated_node["asset_key"] = [str(part) for part in asset_key.path]
+        translated_node[DAGSTER_ASSET_ENABLED_FIELD] = asset_enabled
+        translated_nodes.append(translated_node)
+
+    translated_checks: list[dict[str, Any]] = []
+    for check in dag.get("checks", ()):
+        translated_checks.append(
+            {
+                **check,
+                DAGSTER_CHECK_NAME_FIELD: translator.get_check_name(check),
+                DAGSTER_CHECK_ENABLED_FIELD: translator.is_asset_check(check),
+            }
+        )
+
+    return {**dag, "nodes": translated_nodes, "checks": translated_checks}
+
+
+def is_dagster_asset_enabled(node: Mapping[str, Any]) -> bool:
+    """Return whether a translated DAG node is owned by the SQLBuild asset definition."""
+
+    return bool(node.get(DAGSTER_ASSET_ENABLED_FIELD, True))
+
+
+def is_dagster_check_enabled(check: Mapping[str, Any]) -> bool:
+    """Return whether a translated DAG check is owned by the SQLBuild asset definition."""
+
+    return bool(check.get(DAGSTER_CHECK_ENABLED_FIELD, True))

{sqlbuild-0.84.0 → sqlbuild-0.85.0}/src/sqlbuild/integrations/dagster/classes/sqlbuild_cli_resource.py

@@ -9,7 +9,11 @@ from typing import Any
 from sqlbuild.integrations.dagster._helpers.dag import load_sqlbuild_dag
 from sqlbuild.integrations.dagster._helpers.imports import load_dagster
 from sqlbuild.integrations.dagster._helpers.invocation_factory import start_sqlbuild_cli_invocation
+from sqlbuild.integrations.dagster._helpers.translation import translate_sqlbuild_dag
 from sqlbuild.integrations.dagster.classes.sqlbuild_cli_invocation import SqlBuildCliInvocation
+from sqlbuild.integrations.dagster.classes.sqlbuild_dagster_translator import (
+    SqlBuildDagsterTranslator,
+)
 from sqlbuild.integrations.dagster.models import SqlBuildProject
 
 
@@ -47,12 +51,16 @@ class SqlBuildCliResource(load_dagster().ConfigurableResource):  # type: ignore[
         *,
         context: Any = None,
         raise_on_error: bool = True,
+        translator: SqlBuildDagsterTranslator | None = None,
     ) -> SqlBuildCliInvocation:
         """Create a SQLBuild CLI invocation for the provided command arguments."""
 
         loaded_dag: Mapping[str, Any] | None = None
         if self.dag_path is not None:
-            loaded_dag = load_sqlbuild_dag(self.dag_path)
+            loaded_dag = translate_sqlbuild_dag(
+                dag=load_sqlbuild_dag(self.dag_path),
+                translator=translator or SqlBuildDagsterTranslator(),
+            )
         return start_sqlbuild_cli_invocation(
             sqb_command=self.sqb_command,
             args=args,