sqlbuild 0.26.1__tar.gz → 0.26.2__tar.gz

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

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

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.26.2](https://github.com/chio-labs/sqlbuild/compare/v0.26.1...v0.26.2) (2026-06-03)
+
+
+### Bug Fixes
+
+* harden soft and hard skip semantics ([f7459d3](https://github.com/chio-labs/sqlbuild/commit/f7459d3294d164eaf2044dec6eb6e52bd5a9e4c2))
+* harden soft and hard skip semantics ([22db952](https://github.com/chio-labs/sqlbuild/commit/22db952587b41f1f7e2e4933cf02482088458d4f))
+
 ## [0.26.1](https://github.com/chio-labs/sqlbuild/compare/v0.26.0...v0.26.1) (2026-06-02)
 
 

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/PKG-INFO

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

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/pyproject.toml

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

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/cli/commands/main/helpers/playground/copy.py

@@ -99,7 +99,7 @@ def prepare_raw_orders(ctx):
 def optional_partner_feed(ctx):
     """Soft-skip an optional upstream without blocking sibling fan-in."""
 
-    return ctx.skip("partner feed is not configured", mode=SkipMode.SELF)
+    return ctx.skip("partner feed is not configured", mode=SkipMode.SOFT)
 
 
 @task(tags=["python", "optional"], group="exports")

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/cli/commands/main/shared/helpers/execution_json.py

@@ -369,6 +369,8 @@ def _format_load_assets(
                 "staging_relation": result.staging_relation,
                 "loader": result.loader_name,
                 "rows_loaded": result.rows_loaded,
+                "skip_mode": result.skip_mode.value if result.skip_mode else None,
+                "skip_reason": result.skip_reason,
                 "error_message": result.error_message,
             }
         )

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/cli/commands/main/shared/helpers/progress.py

@@ -315,7 +315,7 @@ class BuildProgressCallbacks:
             status = self._style.status(_execution_status_display(node_result.status))
             duration = _format_duration(node_result.duration_ms)
             source_name: str = _truncate_name(node_result.source_name, self._name_width)
-            detail: str = f"  rows={node_result.rows_loaded:,}"
+            detail: str = _load_result_detail(node_result)
             self._write_top_level_result_line(
                 ctr=ctr,
                 resource_type=node_result.resource_kind.value,
@@ -825,6 +825,17 @@ def _execution_status_display(status: ExecutionStatus) -> str:
     return str(status)
 
 
+def _load_result_detail(result: LoadExecutionResult) -> str:
+    if result.status != ExecutionStatus.SKIPPED:
+        return f"  rows={result.rows_loaded:,}"
+    skip_label: str = "skip"
+    if result.skip_mode is not None:
+        skip_label = f"{result.skip_mode.value} skip"
+    if result.skip_reason:
+        return f"  {skip_label}: {result.skip_reason}"
+    return f"  {skip_label}"
+
+
 def _audit_outcome_display(outcome: AuditOutcome) -> str:
     if outcome == AuditOutcome.PASS:
         return "PASS"

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/compiler/python_nodes/types.py

@@ -25,8 +25,8 @@ class PythonNodeStatus(StrEnum):
 class SkipMode(StrEnum):
     """Python-node skip propagation mode."""
 
-    SELF = "self"
-    DOWNSTREAM = "downstream"
+    SOFT = "soft"
+    HARD = "hard"
 
 
 class PythonNodeFanInAction(StrEnum):

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/load/helpers/dag_runtime.py

@@ -9,11 +9,13 @@ from typing import Any
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.adapter.shared.models import StatementRecorder
+from sqlbuild.compiler.python_nodes.types import SkipMode
 from sqlbuild.executor.load.main.execute import execute_source_load
 from sqlbuild.executor.load.models import LoadDagState, LoadExecutionIndexes, LoadExecutionResult
 from sqlbuild.executor.shared.helpers.load_execution import (
     load_resource_kind,
-    should_skip_due_to_failed_dependency,
+    should_skip_due_to_hard_dependency,
+    should_soft_skip_due_to_all_skipped_dependencies,
     skipped_load_result,
 )
 from sqlbuild.executor.shared.helpers.python_node_scheduler import (
@@ -52,6 +54,7 @@ def build_load_dag_state(
         ready=ready,
         in_flight=set(),
         failed_or_skipped=set(),
+        results_by_name={},
         source_index_by_name=source_index_by_name,
         downstream_names=downstream_names,
         completion_queue=queue.Queue(),
@@ -69,7 +72,10 @@ def complete_dag_source(
 
     source_index: int = state.source_index_by_name[source_name]
     state.results[source_index] = result
-    if result.status != ExecutionStatus.SUCCESS:
+    state.results_by_name[source_name] = result
+    if result.status == ExecutionStatus.FAILED or (
+        result.status == ExecutionStatus.SKIPPED and result.skip_mode == SkipMode.HARD
+    ):
         state.failed_or_skipped.add(source_name)
     if on_load_complete is not None:
         on_load_complete(result)
@@ -86,7 +92,8 @@ def execute_ready_dag_source(
     source_name: str,
     source_by_name: dict[str, SourceEntry],
     indexes: LoadExecutionIndexes,
-    failed_or_skipped: set[str],
+    failed_or_hard_skipped: set[str],
+    results_by_name: dict[str, LoadExecutionResult] | None = None,
     adapter: BaseAdapter,
     connection_config: dict[str, object],
     connection: Any,
@@ -103,12 +110,22 @@ def execute_ready_dag_source(
     """Execute one ready DAG node or return a skipped result."""
 
     source: SourceEntry = source_by_name[source_name]
-    if should_skip_due_to_failed_dependency(
+    if should_skip_due_to_hard_dependency(
         source=source,
-        failed_or_skipped=failed_or_skipped,
+        failed_or_hard_skipped=failed_or_hard_skipped,
         indexes=indexes,
     ):
-        return skipped_load_result(source)
+        return skipped_load_result(source, reason="Upstream loader hard-skipped")
+    if should_soft_skip_due_to_all_skipped_dependencies(
+        source=source,
+        results_by_name={} if results_by_name is None else results_by_name,
+        indexes=indexes,
+    ):
+        return skipped_load_result(
+            source,
+            reason="All upstream loaders were soft-skipped",
+            mode=SkipMode.SOFT,
+        )
     return execute_source_load(
         source_entry=source,
         loader_function=indexes.loader_by_name[source.loader or ""],
@@ -134,7 +151,8 @@ def load_dag_worker(
     source_name: str,
     source_by_name: dict[str, SourceEntry],
     indexes: LoadExecutionIndexes,
-    failed_or_skipped: set[str],
+    failed_or_hard_skipped: set[str],
+    results_by_name: dict[str, LoadExecutionResult],
     adapter: BaseAdapter,
     connection_config: dict[str, object],
     connection_pool: queue.Queue[Any],
@@ -156,7 +174,8 @@ def load_dag_worker(
             source_name=source_name,
             source_by_name=source_by_name,
             indexes=indexes,
-            failed_or_skipped=failed_or_skipped,
+            failed_or_hard_skipped=failed_or_hard_skipped,
+            results_by_name=results_by_name,
             adapter=adapter,
             connection_config=connection_config,
             connection=connection,

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/load/helpers/external.py

@@ -9,7 +9,7 @@ from datetime import datetime
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.adapter.shared.models import StatementRecorder
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction
-from sqlbuild.executor.load.models import LoaderContext, LoadExecutionResult
+from sqlbuild.executor.load.models import LoaderContext, LoaderSkipResult, LoadExecutionResult
 from sqlbuild.executor.shared.exceptions import ExecutorInputError
 from sqlbuild.executor.shared.types import ExecutionStatus
 from sqlbuild.shared.types import ExecutionResourceKind
@@ -62,6 +62,20 @@ def execute_external_source_load(
             end_cursor_int=end_cursor_int,
         )
         raw_rows: object = loader_function.function(context)
+        if isinstance(raw_rows, LoaderSkipResult):
+            return LoadExecutionResult(
+                source_name=source_entry.name,
+                loader_name=loader_function.name,
+                status=ExecutionStatus.SKIPPED,
+                target=destination_relation,
+                resource_kind=resource_kind,
+                staging_relation=None,
+                rows_loaded=0,
+                duration_ms=int((time.monotonic() - start) * 1000),
+                lifecycle_events=statement_recorder.snapshot(),
+                skip_mode=raw_rows.mode,
+                skip_reason=raw_rows.reason,
+            )
         if raw_rows is not None:
             raise ExecutorInputError(
                 f"External loader '{loader_function.name}' returned rows, but external loaders "

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/load/main/execute.py

@@ -24,7 +24,7 @@ from sqlbuild.executor.load.helpers.relation_refs import (
 )
 from sqlbuild.executor.load.helpers.schema import validate_and_evolve_existing_target
 from sqlbuild.executor.load.helpers.staging import write_loader_rows_to_staging
-from sqlbuild.executor.load.models import LoaderContext, LoadExecutionResult
+from sqlbuild.executor.load.models import LoaderContext, LoaderSkipResult, LoadExecutionResult
 from sqlbuild.executor.shared.exceptions import ExecutorInputError
 from sqlbuild.executor.shared.helpers.load_execution import (
     is_untargeted_self_managed_intermediate,
@@ -164,6 +164,20 @@ def execute_source_load(
             ),
         )
         raw_rows: object = loader_function.function(context)
+        if isinstance(raw_rows, LoaderSkipResult):
+            return LoadExecutionResult(
+                source_name=source_entry.name,
+                loader_name=loader_function.name,
+                status=ExecutionStatus.SKIPPED,
+                target=destination_relation,
+                resource_kind=resource_kind,
+                staging_relation=None,
+                rows_loaded=0,
+                duration_ms=int((time.monotonic() - start) * 1000),
+                lifecycle_events=statement_recorder.snapshot(),
+                skip_mode=raw_rows.mode,
+                skip_reason=raw_rows.reason,
+            )
         if raw_rows is None:
             if is_untargeted_self_managed_intermediate(
                 source_entry=source_entry,

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/load/main/run.py

@@ -12,6 +12,7 @@ from typing import Any
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction
 from sqlbuild.compiler.discovery.types import LoaderConnectionMode
+from sqlbuild.compiler.python_nodes.types import SkipMode
 from sqlbuild.executor.load.helpers.dag_runtime import (
     build_load_dag_state,
     complete_dag_source,
@@ -75,7 +76,7 @@ def run_load_pipeline(
         or indexes.loader_by_name[source.loader].connection_mode == LoaderConnectionMode.SQLBUILD
     )
     preloaded_results: list[LoadExecutionResult] = []
-    failed_or_skipped: set[str] = set()
+    failed_or_hard_skipped: set[str] = set()
     source_by_name: dict[str, SourceEntry] = {source.name: source for source in index_sources}
     external_source: SourceEntry
     for external_source in external_sources:
@@ -83,7 +84,8 @@ def run_load_pipeline(
             source_name=external_source.name,
             source_by_name=source_by_name,
             indexes=indexes,
-            failed_or_skipped=failed_or_skipped,
+            failed_or_hard_skipped=failed_or_hard_skipped,
+            results_by_name={},
             adapter=adapter,
             connection_config=connection_config,
             connection=None,
@@ -98,8 +100,10 @@ def run_load_pipeline(
             use_color=use_color,
         )
         preloaded_results.append(result)
-        if result.status.value != "success":
-            failed_or_skipped.add(external_source.name)
+        if result.status.value == "failed" or (
+            result.status.value == "skipped" and result.skip_mode == SkipMode.HARD
+        ):
+            failed_or_hard_skipped.add(external_source.name)
         if on_load_complete is not None:
             on_load_complete(result)
     if not sqlbuild_sources:
@@ -143,7 +147,7 @@ def run_load_pipeline(
             upstream_names=upstream_names,
             downstream_names=downstream_names,
         )
-        state.failed_or_skipped.update(failed_or_skipped)
+        state.failed_or_skipped.update(failed_or_hard_skipped)
         connection_pool: queue.Queue[Any] = queue.Queue()
         connection: Any
         for connection in connections:
@@ -159,7 +163,8 @@ def run_load_pipeline(
                         source_name=source_name,
                         source_by_name=source_by_name,
                         indexes=indexes,
-                        failed_or_skipped=state.failed_or_skipped,
+                        failed_or_hard_skipped=state.failed_or_skipped,
+                        results_by_name=state.results_by_name,
                         adapter=adapter,
                         connection_config=connection_config,
                         connection=sequential_connection,
@@ -191,6 +196,7 @@ def run_load_pipeline(
                         source_by_name,
                         indexes,
                         state.failed_or_skipped,
+                        state.results_by_name,
                         adapter,
                         connection_config,
                         connection_pool,

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/load/models.py

@@ -13,6 +13,7 @@ from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.adapter.shared.models import ColumnInfo, LifeCycleEvent, StatementRecorder
 from sqlbuild.adapter.shared.types import LoaderLogicalType
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction
+from sqlbuild.compiler.python_nodes.types import SkipMode
 from sqlbuild.executor.shared.exceptions import ExecutorInputError
 from sqlbuild.executor.shared.types import ExecutionStatus
 from sqlbuild.shared.helpers.naming import resolve_qualified_name_parts
@@ -66,6 +67,14 @@ class LoaderRelationRef:
         return row[0]
 
 
+@dataclass(frozen=True)
+class LoaderSkipResult:
+    """User-facing skip signal returned by a source loader."""
+
+    reason: str
+    mode: SkipMode = SkipMode.SOFT
+
+
 @dataclass(frozen=True)
 class LoaderContext:
     """Runtime context passed to a source loader function."""
@@ -103,6 +112,11 @@ class LoaderContext:
     def log(self, message: str) -> None:
         self.statement_recorder.log(message)
 
+    def skip(self, reason: str, *, mode: SkipMode = SkipMode.SOFT) -> LoaderSkipResult:
+        """Return a skip signal for the current source loader."""
+
+        return LoaderSkipResult(reason=reason, mode=mode)
+
     def qualify_name(
         self,
         name: str,
@@ -158,6 +172,8 @@ class LoadExecutionResult:
     rows_loaded: int = 0
     duration_ms: int | None = None
     lifecycle_events: tuple[LifeCycleEvent, ...] = field(default_factory=tuple)
+    skip_mode: SkipMode | None = None
+    skip_reason: str | None = None
     error_message: str | None = None
 
 
@@ -182,6 +198,7 @@ class LoadDagState:
     ready: list[str]
     in_flight: set[str]
     failed_or_skipped: set[str]
+    results_by_name: dict[str, LoadExecutionResult]
     source_index_by_name: dict[str, int]
     downstream_names: dict[str, tuple[str, ...]]
     completion_queue: queue.Queue[tuple[str, LoadExecutionResult]]

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/python_nodes/helpers/execution.py

@@ -223,6 +223,7 @@ def _execute_ready_node(
             node_name=node.name,
             kind=node_kind,
             status=PythonNodeStatus.SKIPPED,
+            skip_mode=decision.skip_mode,
             skip_reason=decision.reason,
         )
     if decision.action == PythonNodeFanInAction.BLOCK:

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/python_nodes/helpers/ingress_execution.py

@@ -18,7 +18,7 @@ from sqlbuild.compiler.python_nodes.models import (
     PythonNodeGraph,
     PythonSqlRunLifecyclePlan,
 )
-from sqlbuild.compiler.python_nodes.types import PythonNodeKind, PythonNodeStatus
+from sqlbuild.compiler.python_nodes.types import PythonNodeKind, PythonNodeStatus, SkipMode
 from sqlbuild.executor.load.main.execute import execute_source_load
 from sqlbuild.executor.load.models import LoadExecutionResult
 from sqlbuild.executor.python_nodes.helpers.lifecycle_nodes import build_ingress_lifecycle_nodes
@@ -340,7 +340,11 @@ def _record_scheduler_skips(
         if discovered_node.kind == PythonNodeKind.LOADER:
             source_entry: SourceEntry | None = source_by_loader_name.get(result.name)
             if source_entry is not None and result.name not in load_results_by_name:
-                load_results_by_name[result.name] = skipped_load_result(source_entry)
+                load_results_by_name[result.name] = skipped_load_result(
+                    source_entry,
+                    reason=result.skip_reason,
+                    mode=result.skip_mode or SkipMode.HARD,
+                )
             continue
         if result.name not in python_results_by_name:
             python_results_by_name[result.name] = PythonNodeExecutionResult(
@@ -348,6 +352,7 @@ def _record_scheduler_skips(
                 kind=discovered_node.kind,
                 status=PythonNodeStatus.SKIPPED,
                 skip_reason=result.skip_reason,
+                skip_mode=result.skip_mode,
             )
 
 
@@ -389,6 +394,7 @@ def _python_result_to_lifecycle_result(result: PythonNodeExecutionResult) -> Lif
         status=status,
         error_message=result.error_message,
         skip_reason=result.skip_reason,
+        skip_mode=result.skip_mode,
     )
 
 
@@ -400,6 +406,8 @@ def _load_result_to_lifecycle_result(
         kind=PythonNodeKind.LOADER.value,
         status=_execution_status_to_lifecycle_status(result.status),
         error_message=result.error_message,
+        skip_reason=result.skip_reason,
+        skip_mode=result.skip_mode,
     )
 
 

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/python_nodes/helpers/results.py

@@ -105,18 +105,20 @@ def evaluate_python_node_fan_in(
     hard_skipped_names: tuple[str, ...] = tuple(
         result.node_name
         for result in upstream_results
-        if result.status == PythonNodeStatus.SKIPPED and result.skip_mode == SkipMode.DOWNSTREAM
+        if result.status == PythonNodeStatus.SKIPPED and result.skip_mode == SkipMode.HARD
     )
     if hard_skipped_names:
         return PythonNodeFanInDecision(
             action=PythonNodeFanInAction.SKIP,
-            reason=f"Upstream Python node skipped downstream: {', '.join(hard_skipped_names)}",
+            reason=f"Upstream Python node hard-skipped: {', '.join(hard_skipped_names)}",
+            skip_mode=SkipMode.HARD,
         )
     if any(result.status == PythonNodeStatus.SUCCESS for result in upstream_results):
         return PythonNodeFanInDecision(action=PythonNodeFanInAction.RUN)
     return PythonNodeFanInDecision(
         action=PythonNodeFanInAction.SKIP,
         reason="All upstream Python nodes were skipped",
+        skip_mode=SkipMode.SOFT,
     )
 
 

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/python_nodes/models.py

@@ -38,7 +38,7 @@ class PythonNodeSkipResult:
     """User-facing skip signal returned by a Python node."""
 
     reason: str
-    mode: SkipMode = SkipMode.DOWNSTREAM
+    mode: SkipMode = SkipMode.SOFT
     metadata: dict[str, object] = field(default_factory=dict)
 
 
@@ -97,6 +97,7 @@ class PythonNodeFanInDecision:
 
     action: PythonNodeFanInAction
     reason: str | None = None
+    skip_mode: SkipMode | None = None
 
 
 @dataclass
@@ -253,7 +254,7 @@ class BasePythonNodeContext:
         self,
         reason: str,
         *,
-        mode: SkipMode | str = SkipMode.DOWNSTREAM,
+        mode: SkipMode | str = SkipMode.SOFT,
         metadata: dict[str, object] | None = None,
     ) -> PythonNodeSkipResult:
         """Return a skip signal for the current Python node."""

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/shared/helpers/lifecycle_scheduler.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 
+from sqlbuild.compiler.python_nodes.types import SkipMode
 from sqlbuild.executor.shared.exceptions import ExecutorInputError
 from sqlbuild.executor.shared.models.lifecycle_scheduler import (
     LifecycleExecutionNode,
@@ -50,7 +51,19 @@ def run_lifecycle_scheduler(
                 name=node.name,
                 kind=node.kind,
                 status=LifecycleNodeStatus.SKIPPED,
-                skip_reason=f"Upstream node did not succeed: {dependency_result.name}",
+                skip_reason=_dependency_skip_reason(dependency_result),
+                skip_mode=SkipMode.HARD,
+            )
+        elif _should_soft_skip_due_to_all_skipped_dependencies(
+            upstream_names=upstream_names[node_name],
+            results_by_name=results_by_name,
+        ):
+            result = LifecycleNodeResult(
+                name=node.name,
+                kind=node.kind,
+                status=LifecycleNodeStatus.SKIPPED,
+                skip_reason="All upstream nodes were skipped",
+                skip_mode=SkipMode.SOFT,
             )
         else:
             result = handler(node)
@@ -107,6 +120,28 @@ def _blocking_dependency_result(
     upstream_name: str
     for upstream_name in upstream_names:
         result: LifecycleNodeResult = results_by_name[upstream_name]
-        if result.status != LifecycleNodeStatus.SUCCESS:
+        if result.status == LifecycleNodeStatus.FAILED:
+            return result
+        if result.status == LifecycleNodeStatus.SKIPPED and result.skip_mode == SkipMode.HARD:
             return result
     return None
+
+
+def _should_soft_skip_due_to_all_skipped_dependencies(
+    *,
+    upstream_names: tuple[str, ...],
+    results_by_name: dict[str, LifecycleNodeResult],
+) -> bool:
+    if not upstream_names:
+        return False
+    return all(
+        results_by_name[upstream_name].status == LifecycleNodeStatus.SKIPPED
+        and results_by_name[upstream_name].skip_mode == SkipMode.SOFT
+        for upstream_name in upstream_names
+    )
+
+
+def _dependency_skip_reason(result: LifecycleNodeResult) -> str:
+    if result.status == LifecycleNodeStatus.SKIPPED:
+        return f"Upstream node hard-skipped: {result.name}"
+    return f"Upstream node did not succeed: {result.name}"

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/shared/helpers/load_execution.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections.abc import Callable
 
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction
+from sqlbuild.compiler.python_nodes.types import SkipMode
 from sqlbuild.executor.load.models import LoadExecutionIndexes, LoadExecutionResult
 from sqlbuild.executor.shared.types import ExecutionStatus
 from sqlbuild.shared.models import SqlResourceRef
@@ -119,20 +120,39 @@ def build_source_downstream_names(
     return {name: tuple(dependents) for name, dependents in downstream_names.items()}
 
 
-def should_skip_due_to_failed_dependency(
+def should_skip_due_to_hard_dependency(
     *,
     source: SourceEntry,
-    failed_or_skipped: set[str],
+    failed_or_hard_skipped: set[str],
     indexes: LoadExecutionIndexes,
 ) -> bool:
-    """Return whether a source should skip because an upstream dependency failed."""
+    """Return whether a source should skip because an upstream dependency is blocking."""
 
     return any(
-        dependency in failed_or_skipped
+        dependency in failed_or_hard_skipped
         for dependency in dependency_node_names(source=source, indexes=indexes)
     )
 
 
+def should_soft_skip_due_to_all_skipped_dependencies(
+    *,
+    source: SourceEntry,
+    results_by_name: dict[str, LoadExecutionResult],
+    indexes: LoadExecutionIndexes,
+) -> bool:
+    """Return whether every upstream dependency completed as a non-blocking skip."""
+
+    dependencies: tuple[str, ...] = dependency_node_names(source=source, indexes=indexes)
+    if not dependencies:
+        return False
+    return all(
+        (result := results_by_name.get(dependency)) is not None
+        and result.status == ExecutionStatus.SKIPPED
+        and result.skip_mode == SkipMode.SOFT
+        for dependency in dependencies
+    )
+
+
 def load_resource_kind(source: SourceEntry) -> ExecutionResourceKind:
     """Return the display/execution kind for one load node."""
 
@@ -143,7 +163,12 @@ def load_resource_kind(source: SourceEntry) -> ExecutionResourceKind:
     )
 
 
-def skipped_load_result(source: SourceEntry) -> LoadExecutionResult:
+def skipped_load_result(
+    source: SourceEntry,
+    *,
+    reason: str | None = None,
+    mode: SkipMode = SkipMode.HARD,
+) -> LoadExecutionResult:
     """Build a skipped result for a loader/source node."""
 
     return LoadExecutionResult(
@@ -152,6 +177,8 @@ def skipped_load_result(source: SourceEntry) -> LoadExecutionResult:
         status=ExecutionStatus.SKIPPED,
         target=source.table or source.name,
         resource_kind=load_resource_kind(source),
+        skip_mode=mode,
+        skip_reason=reason,
     )
 
 

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/src/sqlbuild/executor/shared/models/lifecycle_scheduler.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
+from sqlbuild.compiler.python_nodes.types import SkipMode
 from sqlbuild.executor.shared.types import LifecycleNodeStatus
 
 
@@ -27,6 +28,7 @@ class LifecycleNodeResult:
     status: LifecycleNodeStatus
     error_message: str | None = None
     skip_reason: str | None = None
+    skip_mode: SkipMode | None = None
 
 
 @dataclass(frozen=True)

{sqlbuild-0.26.1 → sqlbuild-0.26.2}/tests/e2e/src/sqlbuild/cli/commands/main/build/test_build.py

@@ -81,10 +81,11 @@ DIRECT_PYTHON_BUILD_HARDENING_TEST_CASES: list[DirectPythonBuildHardeningE2ETest
                 'database = "python_build_ingress_skip_project.duckdb"\n'
             ),
             "tasks/prepare.py": (
+                "from sqlbuild.compiler.python_nodes.types import SkipMode\n"
                 "from sqlbuild.tasks import task\n\n"
                 "@task\n"
                 "def prepare_orders(ctx):\n"
-                "    return ctx.skip('no input')\n"
+                "    return ctx.skip('no input', mode=SkipMode.HARD)\n"
             ),
             "loaders/raw.py": (
                 "from tasks.prepare import prepare_orders\n"
@@ -177,11 +178,12 @@ DIRECT_PYTHON_BUILD_HARDENING_TEST_CASES: list[DirectPythonBuildHardeningE2ETest
                 'MODEL (materialized table);\n\nSELECT * FROM __source("raw_orders")\n'
             ),
             "tasks/profile.py": (
+                "from sqlbuild.compiler.python_nodes.types import SkipMode\n"
                 "from sqlbuild.refs import model\n"
                 "from sqlbuild.tasks import task\n\n"
                 "@task(depends_on=model('fact_orders'))\n"
                 "def skip_after_fact(ctx):\n"
-                "    return ctx.skip('no profile needed')\n"
+                "    return ctx.skip('no profile needed', mode=SkipMode.HARD)\n"
             ),
         },
         expected_exit_code=0,
@@ -221,7 +223,7 @@ DIRECT_PYTHON_BUILD_HARDENING_TEST_CASES: list[DirectPythonBuildHardeningE2ETest
                 "from sqlbuild.tasks import task\n\n"
                 "@task(depends_on=model('fact_orders'))\n"
                 "def soft_skip_after_fact(ctx):\n"
-                "    return ctx.skip('optional profile skipped', mode=SkipMode.SELF)\n"
+                "    return ctx.skip('optional profile skipped', mode=SkipMode.SOFT)\n"
             ),
         },
         expected_exit_code=0,