sqlbuild 0.23.0__tar.gz → 0.24.0__tar.gz

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

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

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

@@ -1,5 +1,13 @@
 # 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)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.23.0
+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.23.0 → sqlbuild-0.24.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.23.0"
+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.23.0 → 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.23.0 → 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.23.0 → 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.23.0 → 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.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"]

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

@@ -0,0 +1,50 @@
+"""Rivers asset definitions for SQLBuild projects."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any
+
+from sqlbuild.integrations.rivers.exceptions import RiversDagInputError
+from sqlbuild.integrations.rivers.helpers.assets import build_asset_defs
+from sqlbuild.integrations.rivers.helpers.dag import load_sqlbuild_dag
+from sqlbuild.integrations.rivers.helpers.imports import load_rivers
+from sqlbuild.integrations.rivers.project import SqlBuildProject
+from sqlbuild.integrations.rivers.translator import SqlBuildRiversTranslator
+from sqlbuild.integrations.rivers.types import SqlBuildDagInput
+
+_DEFAULT_DAG_PATH: Path = Path("target/sqlbuild_dag.json")
+
+
+def sqlbuild_assets(
+    *,
+    dag: SqlBuildDagInput | None = None,
+    project: SqlBuildProject | None = None,
+    translator: SqlBuildRiversTranslator | None = None,
+    name: str | None = None,
+) -> Callable[[Callable[..., Any]], Any]:
+    """Create a Rivers multi-asset definition from a SQLBuild DAG artifact."""
+
+    rs: Any = load_rivers()
+    if dag is not None and project is not None:
+        raise RiversDagInputError(
+            "sqlbuild_assets received both 'dag' and 'project'; pass only one"
+        )
+    dag_input: SqlBuildDagInput = (
+        dag if dag is not None else project.dag_path if project is not None else _DEFAULT_DAG_PATH
+    )
+    resolved_dag: Mapping[str, Any] = load_sqlbuild_dag(dag_input)
+    resolved_translator: SqlBuildRiversTranslator = translator or SqlBuildRiversTranslator()
+    output_defs: tuple[Any, ...] = build_asset_defs(
+        dag=resolved_dag,
+        translator=resolved_translator,
+    )
+
+    def decorator(fn: Callable[..., Any]) -> Any:
+        return rs.Asset.from_multi(
+            name=name,
+            output_defs=list(output_defs),
+        )(fn)
+
+    return decorator

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

@@ -0,0 +1,33 @@
+"""Rivers integration errors."""
+
+from __future__ import annotations
+
+
+class RiversIntegrationError(Exception):
+    """Base error for SQLBuild Rivers integration failures."""
+
+    code: str = "I000"
+
+    def __init__(self, message: str, *, code: str | None = None, help: str | None = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.code = code if code is not None else self.code
+        self.help = help
+
+
+class RiversDependencyError(RiversIntegrationError):
+    """Rivers is required but not installed."""
+
+    code: str = "I001"
+
+
+class RiversDagInputError(RiversIntegrationError):
+    """Invalid SQLBuild DAG artifact input."""
+
+    code: str = "I002"
+
+
+class RiversProjectPrepareError(RiversIntegrationError):
+    """SQLBuild project artifact preparation failed."""
+
+    code: str = "I003"

sqlbuild-0.24.0/src/sqlbuild/integrations/rivers/helpers/assets.py

@@ -0,0 +1,56 @@
+"""Rivers AssetDef builders."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from sqlbuild.integrations.rivers.helpers.imports import load_rivers
+from sqlbuild.integrations.rivers.translator import SqlBuildRiversTranslator
+
+_ASSET_KINDS: frozenset[str] = frozenset({"source", "loader", "seed", "model", "function"})
+
+
+def build_asset_defs(
+    *, dag: Mapping[str, Any], translator: SqlBuildRiversTranslator
+) -> tuple[Any, ...]:
+    """Build materializable Rivers asset definitions from a SQLBuild DAG artifact."""
+
+    rs: Any = load_rivers()
+    nodes_by_id: dict[str, Mapping[str, Any]] = _nodes_by_id(dag)
+    upstream_by_id: dict[str, list[str]] = _upstream_by_id(dag)
+    project_name: object = dag.get("project_name")
+    asset_defs: list[Any] = []
+    for node in dag["nodes"]:
+        if str(node.get("kind")) not in _ASSET_KINDS:
+            continue
+        translated_node: Mapping[str, Any] = {**node, "project_name": project_name}
+        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)
+            if upstream_node is None or str(upstream_node.get("kind")) not in _ASSET_KINDS:
+                continue
+            deps.append(rs.AssetDef.dep(translator.get_asset_name(upstream_node)))
+        asset_defs.append(
+            rs.AssetDef(
+                name=translator.get_asset_name(translated_node),
+                tags=translator.get_tags(translated_node),
+                kinds=translator.get_kinds(translated_node),
+                group=translator.get_group_name(translated_node),
+                metadata=translator.get_metadata(translated_node),
+                deps=deps,
+            )
+        )
+    return tuple(asset_defs)
+
+
+def _nodes_by_id(dag: Mapping[str, Any]) -> dict[str, Mapping[str, Any]]:
+    return {str(node["id"]): node for node in dag["nodes"]}
+
+
+def _upstream_by_id(dag: Mapping[str, Any]) -> dict[str, list[str]]:
+    upstream: dict[str, list[str]] = {}
+    edge: Mapping[str, Any]
+    for edge in dag["edges"]:
+        upstream.setdefault(str(edge["to_id"]), []).append(str(edge["from_id"]))
+    return upstream

sqlbuild-0.24.0/src/sqlbuild/integrations/rivers/helpers/dag.py

@@ -0,0 +1,44 @@
+"""SQLBuild DAG artifact loading helpers for Rivers."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from sqlbuild.integrations.rivers.exceptions import RiversDagInputError
+from sqlbuild.integrations.rivers.types import SqlBuildDagInput
+
+
+def load_sqlbuild_dag(dag: SqlBuildDagInput) -> Mapping[str, Any]:
+    """Load a SQLBuild DAG artifact from a mapping or JSON file path."""
+
+    if not isinstance(dag, (str, Path)):
+        payload: Mapping[str, Any] = dag
+    else:
+        path: Path = Path(dag)
+        try:
+            loaded: Any = json.loads(path.read_text(encoding="utf-8"))
+        except OSError as error:
+            raise RiversDagInputError(f"could not read SQLBuild DAG artifact: {path}") from error
+        except json.JSONDecodeError as error:
+            raise RiversDagInputError(
+                f"SQLBuild DAG artifact is not valid JSON: {path}: {error.msg}"
+            ) from error
+        if not isinstance(loaded, Mapping):
+            raise RiversDagInputError("SQLBuild DAG artifact must be a JSON object")
+        payload = loaded
+
+    _validate_dag_payload(payload)
+    return payload
+
+
+def _validate_dag_payload(payload: Mapping[str, Any]) -> None:
+    version: object = payload.get("version")
+    if version != 1:
+        raise RiversDagInputError(f"unsupported SQLBuild DAG artifact version: {version!r}")
+    for key in ("nodes", "edges", "checks"):
+        value: object = payload.get(key)
+        if not isinstance(value, list):
+            raise RiversDagInputError(f"SQLBuild DAG artifact field '{key}' must be a list")

sqlbuild-0.24.0/src/sqlbuild/integrations/rivers/helpers/imports.py

@@ -0,0 +1,20 @@
+"""Lazy Rivers imports for the optional integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlbuild.integrations.rivers.exceptions import RiversDependencyError
+
+
+def load_rivers() -> Any:
+    """Import Rivers or raise an actionable optional-dependency error."""
+
+    try:
+        import rivers as rs
+    except ModuleNotFoundError as error:
+        raise RiversDependencyError(
+            "Rivers is required for sqlbuild.integrations.rivers. "
+            "Install SQLBuild with the rivers extra, e.g. `pip install sqlbuild[rivers]`."
+        ) from error
+    return rs

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

@@ -0,0 +1,66 @@
+"""Rivers integration runtime models."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from sqlbuild.integrations.rivers.exceptions import RiversProjectPrepareError
+
+
+@dataclass(frozen=True)
+class SqlBuildProject:
+    """SQLBuild project paths and artifact preparation settings."""
+
+    project_dir: Path
+    target_path: Path = Path("target")
+    dag_filename: str = "sqlbuild_dag.json"
+    sqb_command: Sequence[str] = ("sqb",)
+    prepare_project_cli_args: Sequence[str] = ("compile", "--dag")
+
+    @property
+    def dag_path(self) -> Path:
+        """Return the SQLBuild DAG artifact path for this project."""
+
+        return self.project_dir / self.target_path / self.dag_filename
+
+    def prepare(self) -> None:
+        """Generate the SQLBuild DAG artifact by invoking SQLBuild."""
+
+        command: tuple[str, ...] = (
+            *tuple(self.sqb_command),
+            *tuple(self.prepare_project_cli_args),
+            str(self.dag_path),
+        )
+        self.dag_path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            completed: subprocess.CompletedProcess[str]
+            completed = subprocess.run(
+                command,
+                cwd=self.project_dir,
+                capture_output=True,
+                check=False,
+                text=True,
+            )
+        except OSError as error:
+            raise RiversProjectPrepareError(
+                f"could not run SQLBuild DAG preparation command: {' '.join(command)}"
+            ) from error
+        if completed.returncode != 0:
+            raise RiversProjectPrepareError(
+                "SQLBuild DAG preparation failed with exit code "
+                f"{completed.returncode}: {' '.join(command)}\n{completed.stderr}"
+            )
+        if not self.dag_path.exists():
+            raise RiversProjectPrepareError(
+                f"did not find SQLBuild DAG artifact at expected path {self.dag_path}"
+            )
+
+    def prepare_if_dev(self) -> None:
+        """Generate the DAG artifact when running under Rivers local development."""
+
+        if os.getenv("RIVERS_DEPLOYMENT") == "dev":
+            self.prepare()

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

@@ -0,0 +1,7 @@
+"""Public SQLBuild project metadata imports for Rivers integrations."""
+
+from __future__ import annotations
+
+from sqlbuild.integrations.rivers.models import SqlBuildProject
+
+__all__ = ["SqlBuildProject"]

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

@@ -0,0 +1,68 @@
+"""SQLBuild-to-Rivers translation hooks."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Mapping
+from typing import Any
+
+
+class SqlBuildRiversTranslator:
+    """Default mapping from SQLBuild DAG records to Rivers metadata."""
+
+    def get_asset_name(self, node: Mapping[str, Any]) -> str:
+        return "__".join(str(part) for part in node["asset_key"])
+
+    def get_group_name(self, node: Mapping[str, Any]) -> str | None:
+        group_name: str = str(node.get("project_name") or "sqlbuild")
+        return group_name.replace("-", "_")
+
+    def get_tags(self, node: Mapping[str, Any]) -> list[str]:
+        tags: list[str] = [f"sqlbuild/kind:{node.get('kind', '')}"]
+        for tag in node.get("tags", ()):
+            tag_value: str = _normalize_tag(str(tag))
+            if tag_value:
+                tags.append(tag_value)
+        return tags
+
+    def get_kinds(self, node: Mapping[str, Any]) -> list[str]:
+        kind: str = str(node.get("kind"))
+        if kind == "model":
+            materialization_type: str = str(node.get("materialization_type") or "table")
+            if materialization_type == "view":
+                return ["sqlbuild", "view"]
+            return ["sqlbuild", "table"]
+        if kind in {"source", "loader", "seed", "function"}:
+            return ["sqlbuild", kind]
+        return ["sqlbuild"]
+
+    def get_metadata(self, node: Mapping[str, Any]) -> dict[str, str]:
+        metadata: dict[str, Any] = {
+            "sqlbuild_id": node.get("id"),
+            "sqlbuild_name": node.get("name"),
+            "sqlbuild_kind": node.get("kind"),
+            "sqlbuild_selector": node.get("name"),
+        }
+        for key in (
+            "path",
+            "target",
+            "description",
+            "columns",
+            "language",
+            "return_kind",
+            "loader",
+        ):
+            if key in node:
+                metadata[key] = node[key]
+        return {key: _metadata_value(value) for key, value in metadata.items() if value is not None}
+
+
+def _metadata_value(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, sort_keys=True)
+
+
+def _normalize_tag(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.\-/]+", "_", value).strip("_")

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

@@ -0,0 +1,13 @@
+"""Rivers integration shared types."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+type SqlBuildDagInput = Mapping[str, Any] | str | Path
+type DagNode = Mapping[str, Any]
+type DagCheck = Mapping[str, Any]
+type DagEdge = Mapping[str, Any]
+type AssetKeyParts = Sequence[str]

sqlbuild-0.24.0/tests/e2e/src/sqlbuild/integrations/rivers/_test_types.py

@@ -0,0 +1,25 @@
+"""Test types for Rivers integration e2e tests."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RiversSqlBuildE2ETestCase:
+    """Test case for SQLBuild Rivers integration e2e verification."""
+
+    description: str
+    expected_success: bool
+    expected_asset_names: frozenset[str]
+    expected_table_names: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class RiversPlaygroundE2ETestCase:
+    """Test case for generated Rivers playground execution."""
+
+    description: str
+    expected_success: bool
+    expected_table_names: tuple[str, ...]
+    expected_schema: str