sqlbuild 0.22.1__tar.gz → 0.24.0__tar.gz

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

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

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.24.0](https://github.com/chio-labs/sqlbuild/compare/v0.23.0...v0.24.0) (2026-05-28)
+
+
+### Features
+
+* add rivers integration ([82de30c](https://github.com/chio-labs/sqlbuild/commit/82de30ca29f4cde1deba35f08d6575fa82657c62))
+* add rivers integration ([9268beb](https://github.com/chio-labs/sqlbuild/commit/9268beb1cae3bd78f51f9e17241767c892d51722))
+
+## [0.23.0](https://github.com/chio-labs/sqlbuild/compare/v0.22.1...v0.23.0) (2026-05-28)
+
+
+### Features
+
+* support virtual custom materializations ([c9a1447](https://github.com/chio-labs/sqlbuild/commit/c9a144788ad77b301c830856d917a177234f359d))
+* support virtual custom materializations ([21bba32](https://github.com/chio-labs/sqlbuild/commit/21bba32086ca9ad5c175b7525679de76fced9752))
+
+
+### Bug Fixes
+
+* include virtual table functions ([68d2781](https://github.com/chio-labs/sqlbuild/commit/68d278112d008f1ece4eae744ca507dd52ad8347))
+* include virtual table functions ([b667184](https://github.com/chio-labs/sqlbuild/commit/b6671848990eb8a824faf2fe636197be26a08bd4))
+* seed virtual versions lazily ([0b2d683](https://github.com/chio-labs/sqlbuild/commit/0b2d683105a7777f94a4fd20675601d98811e632))
+* seed virtual versions lazily ([400c161](https://github.com/chio-labs/sqlbuild/commit/400c16109bd1bc1a805c9859083c628e10b160b1))
+
 ## [0.22.1](https://github.com/chio-labs/sqlbuild/compare/v0.22.0...v0.22.1) (2026-05-28)
 
 

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.22.1
+Version: 0.24.0
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -21,6 +21,8 @@ Provides-Extra: performance
 Requires-Dist: sqlglot[c]>=30.7.0; extra == 'performance'
 Provides-Extra: postgres
 Requires-Dist: psycopg[binary]>=3.2.0; extra == 'postgres'
+Provides-Extra: rivers
+Requires-Dist: rivers>=0.1.4; extra == 'rivers'
 Provides-Extra: snowflake
 Requires-Dist: snowflake-connector-python>=3.17.3; extra == 'snowflake'
 Provides-Extra: sqlserver

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.22.1"
+version = "0.24.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -41,6 +41,9 @@ sqlserver = [
 ingestr = [
   "ingestr>=1.0.0",
 ]
+rivers = [
+  "rivers>=0.1.4",
+]
 
 [project.scripts]
 sqb = "sqlbuild.cli.commands.main.entry:main"

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/scripts/structure/structure_conventions/rules.py

@@ -145,7 +145,7 @@ def check_nested_runtime_package_direct_modules(
     relative_parts = file_path.resolve().relative_to(repo_root.resolve()).parts
     if len(relative_parts) < 5 or relative_parts[:2] != ("src", "sqlbuild"):
         return []
-    if _is_dagster_integration_public_module(relative_parts):
+    if _is_orchestration_integration_public_module(relative_parts):
         return []
     if file_path.name == "main.py" and (
         relative_parts[:3]
@@ -345,7 +345,7 @@ def check_init_module(file_path: Path, module: ast.Module) -> list[Violation]:
 
     if file_path.name != "__init__.py":
         return []
-    if _is_dagster_integration_public_init(file_path):
+    if _is_orchestration_integration_public_init(file_path):
         return []
 
     if is_docstring_only_module(module):
@@ -1296,7 +1296,7 @@ def check_entry_module_shape(file_path: Path, module: ast.Module) -> list[Violat
 
     if not _is_entry_module(file_path):
         return []
-    if _is_dagster_integration_public_entry(file_path):
+    if _is_orchestration_integration_public_entry(file_path):
         return []
 
     public_function_nodes = [
@@ -1534,32 +1534,31 @@ def _is_direct_child_of_main_package(relative_parts: tuple[str, ...]) -> bool:
     )
 
 
-def _is_dagster_integration_public_module(relative_parts: tuple[str, ...]) -> bool:
+def _is_orchestration_integration_public_module(relative_parts: tuple[str, ...]) -> bool:
     return (
-        relative_parts[:4] == ("src", "sqlbuild", "integrations", "dagster")
-        and len(relative_parts) == 5
+        len(relative_parts) == 5
+        and relative_parts[:3] == ("src", "sqlbuild", "integrations")
+        and relative_parts[3] in {"dagster", "rivers"}
         and relative_parts[-1] in {"assets.py", "translator.py", "project.py", "resource.py"}
     )
 
 
-def _is_dagster_integration_public_init(file_path: Path) -> bool:
+def _is_orchestration_integration_public_init(file_path: Path) -> bool:
     parts: tuple[str, ...] = file_path.parts
-    return len(parts) >= 5 and parts[-5:] == (
-        "src",
-        "sqlbuild",
-        "integrations",
-        "dagster",
-        "__init__.py",
+    return (
+        len(parts) >= 5
+        and parts[-5:-2] == ("src", "sqlbuild", "integrations")
+        and parts[-2] in {"dagster", "rivers"}
+        and parts[-1] == "__init__.py"
     )
 
 
-def _is_dagster_integration_public_entry(file_path: Path) -> bool:
+def _is_orchestration_integration_public_entry(file_path: Path) -> bool:
     parts: tuple[str, ...] = file_path.parts
-    return len(parts) >= 5 and parts[-5:-1] == (
-        "src",
-        "sqlbuild",
-        "integrations",
-        "dagster",
+    return (
+        len(parts) >= 5
+        and parts[-5:-2] == ("src", "sqlbuild", "integrations")
+        and parts[-2] in {"dagster", "rivers"}
     )
 
 

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/cli/commands/main/helpers/playground/constants.py

@@ -4,5 +4,6 @@ PLAYGROUND_TEMPLATE_VALUES: tuple[str, ...] = (
     "waffle_shop",
     "loader_waffle_shop",
     "dagster",
+    "rivers",
     "virtual",
 )

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/cli/commands/main/helpers/playground/copy.py

@@ -306,6 +306,87 @@ The definitions use `SqlBuildProject.prepare_if_dev()` to generate `target/sqlbu
 when Dagster starts in dev mode.
 """
 
+_RIVERS_DEFINITIONS: str = '''"""Rivers definitions for the SQLBuild waffle shop playground."""
+
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+import rivers as rs
+
+from sqlbuild.integrations.rivers import SqlBuildProject, sqlbuild_assets
+
+PROJECT_DIR = Path(__file__).resolve().parent.parent
+SQLBUILD_PROJECT = SqlBuildProject(project_dir=PROJECT_DIR)
+
+if __name__ == "__main__":
+    SQLBUILD_PROJECT.prepare()
+else:
+    SQLBUILD_PROJECT.prepare_if_dev()
+
+
+@sqlbuild_assets(project=SQLBUILD_PROJECT)
+def waffle_shop_assets(context: Any) -> Iterator[Any]:
+    completed = subprocess.run(
+        ["sqb", "build"],
+        cwd=PROJECT_DIR,
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise RuntimeError(completed.stderr or completed.stdout)
+    for output_name in context.output_selection:
+        yield rs.Materialization(output_name=output_name)
+
+
+repo = rs.CodeRepository(
+    assets=[waffle_shop_assets],
+    jobs=[
+        rs.Job(
+            name="waffle_shop",
+            assets=[waffle_shop_assets],
+            executor=rs.Executor.in_process(),
+        ),
+    ],
+    default_executor=rs.Executor.in_process(),
+)
+
+
+if __name__ == "__main__":
+    result = repo.get_job("waffle_shop").execute()
+    raise SystemExit(0 if result.success else 1)
+'''
+
+_RIVERS_README: str = """# SQLBuild + Rivers playground
+
+This directory contains a Rivers repository definition for the generated SQLBuild
+waffle shop project.
+
+## Run Rivers
+
+Install SQLBuild with the Rivers extra, then start Rivers from the project root:
+
+```bash
+uv add "sqlbuild[rivers]"
+uv run rivers dev rivers_pipeline.definitions
+```
+
+You can also run a local materialization directly:
+
+```bash
+uv run python rivers_pipeline/definitions.py
+```
+
+The repository defines a `waffle_shop` job for UI-triggered materialization.
+
+The definitions use `SqlBuildProject.prepare_if_dev()` to generate `target/sqlbuild_dag.json`
+when `rivers dev` starts with `RIVERS_DEPLOYMENT=dev`.
+"""
+
 
 def create_playground_project(*, target_dir: Path, template: str = "waffle_shop") -> None:
     """Create a DuckDB-backed waffle shop playground project."""
@@ -338,6 +419,8 @@ def create_playground_project(*, target_dir: Path, template: str = "waffle_shop"
     _copy_tree(source=template_root, target=target_dir)
     if template == "dagster":
         _write_dagster_template_files(target_dir=target_dir)
+    if template == "rivers":
+        _write_rivers_template_files(target_dir=target_dir)
     if template == "virtual":
         _write_virtual_template_files(target_dir=target_dir)
 
@@ -366,6 +449,16 @@ def _write_dagster_template_files(*, target_dir: Path) -> None:
     (dagster_dir / "README.md").write_text(_DAGSTER_README, encoding="utf-8")
 
 
+def _write_rivers_template_files(*, target_dir: Path) -> None:
+    rivers_dir: Path = target_dir / "rivers_pipeline"
+    rivers_dir.mkdir()
+    (rivers_dir / "__init__.py").write_text(
+        '"""Rivers playground definitions package."""\n', encoding="utf-8"
+    )
+    (rivers_dir / "definitions.py").write_text(_RIVERS_DEFINITIONS, encoding="utf-8")
+    (rivers_dir / "README.md").write_text(_RIVERS_README, encoding="utf-8")
+
+
 def _write_virtual_template_files(*, target_dir: Path) -> None:
     (target_dir / "sqlbuild_project.toml").write_text(_VIRTUAL_PROJECT_TOML, encoding="utf-8")
     (target_dir / "README.md").write_text(_VIRTUAL_README, encoding="utf-8")

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/cli/commands/main/playground.py

@@ -39,6 +39,8 @@ def run_playground(
     example_name: str = (
         "waffle shop + Dagster"
         if template == "dagster"
+        else "waffle shop + Rivers"
+        if template == "rivers"
         else "virtual environments waffle shop"
         if template == "virtual"
         else "loader-focused waffle shop"
@@ -65,4 +67,6 @@ def run_playground(
         print(f"{command_prefix}sqb audit")
     if template == "dagster":
         print(f"{command_prefix}DAGSTER_IS_DEV_CLI=1 dagster dev -f dagster/definitions.py")
+    if template == "rivers":
+        print(f"{command_prefix}rivers dev rivers_pipeline.definitions")
     return 0

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/compiler/pipeline/helpers/materializations.py

@@ -36,3 +36,31 @@ def load_custom_materializations(
             )
         registry[mat_file.name] = materialize_fn
     return registry
+
+
+def load_custom_prepare_version_functions(
+    materialization_files: tuple[DiscoveredMaterializationFile, ...],
+) -> dict[str, Callable[..., None]]:
+    """Import discovered materialization modules and extract optional prepare_version callables."""
+
+    registry: dict[str, Callable[..., None]] = {}
+    mat_file: DiscoveredMaterializationFile
+    for mat_file in materialization_files:
+        spec: Any = importlib.util.spec_from_file_location(mat_file.name, mat_file.file_path)
+        if spec is None or spec.loader is None:
+            raise PlannerInputError(
+                f"materialization '{mat_file.name}' at {mat_file.file_path} "
+                f"could not be loaded as a Python module"
+            )
+        module: ModuleType = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        prepare_version_fn: Any = getattr(module, "prepare_version", None)
+        if prepare_version_fn is None:
+            continue
+        if not callable(prepare_version_fn):
+            raise PlannerInputError(
+                f"materialization '{mat_file.name}' at {mat_file.file_path} "
+                f"defines a non-callable 'prepare_version' attribute"
+            )
+        registry[mat_file.name] = prepare_version_fn
+    return registry

sqlbuild-0.24.0/src/sqlbuild/compiler/pipeline/main/materializations.py

@@ -0,0 +1,19 @@
+"""Public entrypoint for custom materialization loading."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from sqlbuild.compiler.discovery.models import DiscoveredMaterializationFile
+from sqlbuild.compiler.pipeline.helpers.materializations import (
+    load_custom_materializations as _load_custom_materializations,
+)
+from sqlbuild.executor.custom.models import MaterializationContext, MaterializationResult
+
+
+def load_custom_materializations(
+    materialization_files: tuple[DiscoveredMaterializationFile, ...],
+) -> dict[str, Callable[[MaterializationContext], MaterializationResult]]:
+    """Load custom materialization callables from discovered project files."""
+
+    return _load_custom_materializations(materialization_files)

sqlbuild-0.24.0/src/sqlbuild/compiler/pipeline/main/prepare_versions.py

@@ -0,0 +1,18 @@
+"""Public entrypoint for custom prepare_version loading."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from sqlbuild.compiler.discovery.models import DiscoveredMaterializationFile
+from sqlbuild.compiler.pipeline.helpers.materializations import (
+    load_custom_prepare_version_functions as _load_custom_prepare_version_functions,
+)
+
+
+def load_custom_prepare_version_functions(
+    materialization_files: tuple[DiscoveredMaterializationFile, ...],
+) -> dict[str, Callable[..., None]]:
+    """Load optional custom prepare_version callables from discovered project files."""
+
+    return _load_custom_prepare_version_functions(materialization_files)

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/compiler/planner/helpers/selectors.py

@@ -152,14 +152,51 @@ def resolve_selectors(
             )
             excluded.update(resolved)
 
-    scoped: set[CompiledObjectKey] = selected - excluded
+    scoped: frozenset[CompiledObjectKey] = frozenset(selected - excluded)
+    return expand_required_build_resources(
+        selected_keys=scoped,
+        upstream=upstream,
+        downstream=downstream,
+        include_upstream_functions=True,
+        include_upstream_seeds=False,
+        include_downstream_functions=False,
+    )
+
+
+def expand_required_build_resources(
+    *,
+    selected_keys: frozenset[CompiledObjectKey],
+    upstream: dict[CompiledObjectKey, tuple[CompiledObjectKey, ...]],
+    downstream: dict[CompiledObjectKey, tuple[CompiledObjectKey, ...]],
+    include_upstream_functions: bool = True,
+    include_upstream_seeds: bool = False,
+    include_downstream_functions: bool = False,
+) -> frozenset[CompiledObjectKey]:
+    """Add non-model resources needed to build a coherent selected model scope."""
+
+    expanded: set[CompiledObjectKey] = set(selected_keys)
     key: CompiledObjectKey
-    for key in tuple(scoped):
+    for key in tuple(selected_keys):
         upstream_key: CompiledObjectKey
         for upstream_key in expand_upstream(key, upstream):
-            if upstream_key.resource_type == CompiledResourceType.FUNCTION:
-                scoped.add(upstream_key)
-    return frozenset(scoped)
+            if (
+                include_upstream_functions
+                and upstream_key.resource_type == CompiledResourceType.FUNCTION
+            ):
+                expanded.add(upstream_key)
+            if include_upstream_seeds and upstream_key.resource_type == CompiledResourceType.SEED:
+                expanded.add(upstream_key)
+    if not include_downstream_functions:
+        return frozenset(expanded)
+    selected_model_keys: frozenset[CompiledObjectKey] = frozenset(
+        key for key in selected_keys if key.resource_type == CompiledResourceType.MODEL
+    )
+    for key in selected_model_keys:
+        downstream_key: CompiledObjectKey
+        for downstream_key in downstream.get(key, ()):
+            if downstream_key.resource_type == CompiledResourceType.FUNCTION:
+                expanded.add(downstream_key)
+    return frozenset(expanded)
 
 
 def _resolve_token(

sqlbuild-0.24.0/src/sqlbuild/compiler/planner/main/build_resources.py

@@ -0,0 +1,29 @@
+"""Public entrypoint for build resource expansion."""
+
+from __future__ import annotations
+
+from sqlbuild.compiler.compile.models.core import CompiledObjectKey
+from sqlbuild.compiler.planner.helpers.selectors import (
+    expand_required_build_resources as _expand_required_build_resources,
+)
+
+
+def expand_build_resource_selection(
+    *,
+    selected_keys: frozenset[CompiledObjectKey],
+    upstream: dict[CompiledObjectKey, tuple[CompiledObjectKey, ...]],
+    downstream: dict[CompiledObjectKey, tuple[CompiledObjectKey, ...]],
+    include_upstream_functions: bool = True,
+    include_upstream_seeds: bool = False,
+    include_downstream_functions: bool = False,
+) -> frozenset[CompiledObjectKey]:
+    """Add non-model resources needed to build a coherent selected model scope."""
+
+    return _expand_required_build_resources(
+        selected_keys=selected_keys,
+        upstream=upstream,
+        downstream=downstream,
+        include_upstream_functions=include_upstream_functions,
+        include_upstream_seeds=include_upstream_seeds,
+        include_downstream_functions=include_downstream_functions,
+    )

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/executor/build/helpers/scheduler.py

@@ -7,7 +7,7 @@ import logging
 import queue
 import time
 from collections import deque
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from typing import Any
@@ -110,7 +110,8 @@ class BuildScheduler:
         on_node_start: Callable[[str, ExecutionResourceKind], None] | None,
         on_node_complete: Callable[[object], None] | None,
         on_progress: Callable[[str], None] | None,
-        custom_materializations: dict[str, Callable[..., MaterializationResult]] | None = None,
+        before_model_materialize: Callable[[ModelPlanEntry, Any], None] | None = None,
+        custom_materializations: Mapping[str, Callable[..., MaterializationResult]] | None = None,
         loader_functions: tuple[DiscoveredLoaderFunction, ...] = (),
         loader_is_reload: bool = False,
         start_cursor_ts: datetime | None = None,
@@ -143,7 +144,10 @@ class BuildScheduler:
         self._on_node_start: Callable[[str, ExecutionResourceKind], None] | None = on_node_start
         self._on_node_complete: Callable[[object], None] | None = on_node_complete
         self._on_progress: Callable[[str], None] | None = on_progress
-        self._custom_materializations: dict[str, Callable[..., MaterializationResult]] = (
+        self._before_model_materialize: Callable[[ModelPlanEntry, Any], None] | None = (
+            before_model_materialize
+        )
+        self._custom_materializations: Mapping[str, Callable[..., MaterializationResult]] = (
             custom_materializations or {}
         )
         self._loader_functions_by_name: dict[str, DiscoveredLoaderFunction] = {
@@ -599,23 +603,33 @@ class BuildScheduler:
             sqlbuild_name=model_entry.name,
             sqlbuild_kind=model_entry.materialization_type,
         ):
-            result: ModelExecutionResult = _dispatch_model(
-                entry=model_entry,
-                adapter=self._adapter,
-                connection=connection,
-                plan=self._plan,
-                model_audits=model_audits,
-                promotion_mode=self._promotion_mode,
-                run_id=self._run_id,
-                query_change_tracking=self._query_change_tracking,
-                snapshots=self._snapshots,
-                allow_snapshot_schema_change=self._allow_snapshot_schema_change,
-                custom_materializations=self._custom_materializations,
-                environment=self._environment,
-                effective_vars=self._effective_vars,
-                warehouse_relations=self._warehouse_relations,
-                on_progress=self._on_sub_progress,
-            )
+            try:
+                if self._before_model_materialize is not None:
+                    self._before_model_materialize(model_entry, connection)
+                result: ModelExecutionResult = _dispatch_model(
+                    entry=model_entry,
+                    adapter=self._adapter,
+                    connection=connection,
+                    plan=self._plan,
+                    model_audits=model_audits,
+                    promotion_mode=self._promotion_mode,
+                    run_id=self._run_id,
+                    query_change_tracking=self._query_change_tracking,
+                    snapshots=self._snapshots,
+                    allow_snapshot_schema_change=self._allow_snapshot_schema_change,
+                    custom_materializations=self._custom_materializations,
+                    environment=self._environment,
+                    effective_vars=self._effective_vars,
+                    warehouse_relations=self._warehouse_relations,
+                    on_progress=self._on_sub_progress,
+                )
+            except Exception as error:
+                result = ModelExecutionResult(
+                    model_name=model_entry.name,
+                    status=ExecutionStatus.FAILED,
+                    error_code=BUILD_WORKER_FAILED_CODE,
+                    error_message=str(error),
+                )
         duration: int = int((time.monotonic() - start) * 1000)
         completed_result: ModelExecutionResult = dataclasses.replace(result, duration_ms=duration)
         log_debug_event(
@@ -786,7 +800,7 @@ def _dispatch_model(
     query_change_tracking: bool,
     snapshots: SnapshotsConfig,
     allow_snapshot_schema_change: bool,
-    custom_materializations: dict[str, Callable[..., MaterializationResult]] | None = None,
+    custom_materializations: Mapping[str, Callable[..., MaterializationResult]] | None = None,
     environment: str = "",
     effective_vars: dict[str, object] | None = None,
     warehouse_relations: dict[str, RelationInfo] | None = None,
@@ -796,7 +810,7 @@ def _dispatch_model(
 
     if entry.action == PlanAction.CUSTOM:
         mat_name: str | None = entry.custom_materialization_name
-        registry: dict[str, Callable[..., MaterializationResult]] = custom_materializations or {}
+        registry: Mapping[str, Callable[..., MaterializationResult]] = custom_materializations or {}
         if mat_name is None or mat_name not in registry:
             return ModelExecutionResult(
                 model_name=entry.name,

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/executor/build/main/execute.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from datetime import datetime
 from typing import Any
 
@@ -12,7 +12,7 @@ from sqlbuild.adapter.shared.types import TablePromotionMode
 from sqlbuild.compiler.auditing.types import AuditOutcome
 from sqlbuild.compiler.compile.models.core import CompiledObjectKey
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction
-from sqlbuild.compiler.planner.models import PlanOutput
+from sqlbuild.compiler.planner.models import ModelPlanEntry, PlanOutput
 from sqlbuild.executor.auditing.models import AuditExecutionResult
 from sqlbuild.executor.build.helpers.indexes import build_execution_indexes
 from sqlbuild.executor.build.helpers.scheduler import BuildScheduler
@@ -51,7 +51,8 @@ def execute_build_plan(
     on_progress: Callable[[str], None] | None = None,
     on_node_start: Callable[[str, ExecutionResourceKind], None] | None = None,
     on_node_complete: Callable[[object], None] | None = None,
-    custom_materializations: dict[str, Callable[..., MaterializationResult]] | None = None,
+    before_model_materialize: Callable[[ModelPlanEntry, Any], None] | None = None,
+    custom_materializations: Mapping[str, Callable[..., MaterializationResult]] | None = None,
     loader_functions: tuple[DiscoveredLoaderFunction, ...] = (),
     loader_is_reload: bool = False,
     start_cursor_ts: datetime | None = None,
@@ -88,6 +89,7 @@ def execute_build_plan(
         on_node_start=on_node_start,
         on_node_complete=on_node_complete,
         on_progress=on_progress,
+        before_model_materialize=before_model_materialize,
         custom_materializations=custom_materializations,
         loader_functions=loader_functions,
         loader_is_reload=loader_is_reload,

{sqlbuild-0.22.1 → sqlbuild-0.24.0}/src/sqlbuild/executor/pipeline/main/run.py

@@ -4,14 +4,14 @@ from __future__ import annotations
 
 import logging
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from datetime import datetime
 from typing import Any
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.adapter.shared.types import TablePromotionMode
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction
-from sqlbuild.compiler.planner.models import PlanOutput
+from sqlbuild.compiler.planner.models import ModelPlanEntry, PlanOutput
 from sqlbuild.executor.build.main.execute import execute_build_plan
 from sqlbuild.executor.build.main.external_source_loads import (
     run_external_source_loads_before_connections,
@@ -61,7 +61,8 @@ def run_build_pipeline(
     on_node_complete: Callable[[object], None] | None = None,
     on_progress: Callable[[str], None] | None = None,
     on_sub_progress: Callable[[str], None] | None = None,
-    custom_materializations: dict[str, Callable[..., MaterializationResult]] | None = None,
+    before_model_materialize: Callable[[ModelPlanEntry, Any], None] | None = None,
+    custom_materializations: Mapping[str, Callable[..., MaterializationResult]] | None = None,
     loader_functions: tuple[DiscoveredLoaderFunction, ...] = (),
     loader_is_reload: bool = False,
     start_cursor_ts: datetime | None = None,
@@ -148,6 +149,7 @@ def run_build_pipeline(
             on_node_start=on_node_start,
             on_node_complete=on_node_complete,
             on_progress=on_progress,
+            before_model_materialize=before_model_materialize,
             custom_materializations=custom_materializations,
             loader_functions=loader_functions,
             loader_is_reload=loader_is_reload,

sqlbuild-0.24.0/src/sqlbuild/integrations/rivers/__init__.py

@@ -0,0 +1,7 @@
+"""Optional Rivers integration for SQLBuild."""
+
+from sqlbuild.integrations.rivers.assets import sqlbuild_assets
+from sqlbuild.integrations.rivers.project import SqlBuildProject
+from sqlbuild.integrations.rivers.translator import SqlBuildRiversTranslator
+
+__all__ = ["SqlBuildProject", "SqlBuildRiversTranslator", "sqlbuild_assets"]