databricks-agent-notebooks 0.1.0__py3-none-any.whl

databricks_agent_notebooks/__init__.py

@@ -0,0 +1,5 @@
+"""Standalone Databricks notebook conversion and execution tooling."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

databricks_agent_notebooks/__main__.py

@@ -0,0 +1,9 @@
+"""Allow ``python -m databricks_agent_notebooks`` invocation."""
+
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+sys.exit(main())

databricks_agent_notebooks/_constants.py

@@ -0,0 +1,26 @@
+"""Shared constants for the databricks_agent_notebooks library."""
+
+from __future__ import annotations
+
+# Kernel metadata per language — single source of truth.
+# Used by _converter.py, _dbr_source.py, and cli.py to set/read kernel metadata.
+KERNELSPECS: dict[str, dict[str, str]] = {
+    "python": {
+        "name": "python3",
+        "display_name": "Python 3",
+        "language": "python",
+    },
+    "scala": {
+        "name": "scala212-dbr-connect",
+        "display_name": "Scala 2.12 (Databricks Connect)",
+        "language": "scala",
+    },
+    "sql": {
+        "name": "python3",
+        "display_name": "Python 3 (SQL wrapper)",
+        "language": "sql",
+    },
+}
+
+DATABRICKS_CONNECT_VERSION = "16.4.7"
+DATABRICKS_CONNECT_LINE = "16.4"

databricks_agent_notebooks/cli.py

@@ -0,0 +1,514 @@
+"""CLI entry point for agent-notebook — normalize, inject, execute, and render notebooks.
+
+Provides subcommands for the full notebook pipeline (run), standalone rendering,
+cluster discovery, kernel installation, and environment validation.  Follows the
+same argparse/subparsers/dispatch-table pattern as ``libs.continuum.cli``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from databricks_agent_notebooks.config.frontmatter import DatabricksConfig, merge_config
+from databricks_agent_notebooks.execution.executor import execute_notebook
+from databricks_agent_notebooks.execution.injection import inject_cells
+from databricks_agent_notebooks.execution.rendering import render
+from databricks_agent_notebooks.formats.conversion import to_notebook, validate_single_language
+from databricks_agent_notebooks.integrations.databricks.clusters import ClusterError, default_service
+from databricks_agent_notebooks.runtime.doctor import Check, run_checks
+from databricks_agent_notebooks.runtime.inventory import doctor_installed_runtimes, list_installed_runtimes
+from databricks_agent_notebooks.runtime.kernel import (
+    KERNEL_DISPLAY_NAME,
+    KERNEL_ID,
+    install_kernel,
+    list_installed_kernels,
+    remove_kernel,
+)
+
+import nbformat
+
+
+# ---------------------------------------------------------------------------
+# Parser
+# ---------------------------------------------------------------------------
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="agent-notebook",
+        description="Databricks notebook execution: normalize, inject, execute, render.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # -- run --
+    run = subparsers.add_parser("run", help="Normalize, inject, execute, and render a notebook")
+    run.add_argument("file", help="Input file (markdown, ipynb, or Databricks source)")
+    run.add_argument("--cluster", default=None, help="Cluster name or ID")
+    run.add_argument("--profile", default=None, help="Databricks CLI profile")
+    run.add_argument("--format", default="all", choices=["all", "md", "html"], dest="fmt", help="Output format (default: all)")
+    run.add_argument("--output-dir", default=None, help="Output directory (default: input file's parent)")
+    run.add_argument("--timeout", type=int, default=600, help="Per-cell timeout in seconds (default: 600)")
+    run.add_argument("--allow-errors", action="store_true", help="Continue execution on cell errors")
+    run.add_argument("--no-inject-session", action="store_true", help="Skip Databricks Connect session injection")
+    run.add_argument("--language", default=None, help="Override notebook language (python, scala)")
+
+    # -- clusters --
+    clusters = subparsers.add_parser("clusters", help="List Databricks clusters")
+    clusters.add_argument("--profile", required=True, help="Databricks CLI profile")
+
+    # -- install-kernel --
+    ik = subparsers.add_parser("install-kernel", help="Install the Databricks Connect Almond kernel")
+    ik.add_argument("--kernels-dir", default=None, help="Jupyter kernels directory")
+
+    # -- kernels --
+    kernels = subparsers.add_parser("kernels", help="Manage installed Databricks kernels")
+    kernel_subparsers = kernels.add_subparsers(dest="kernels_command", required=True)
+
+    kernels_install = kernel_subparsers.add_parser("install", help="Install the Databricks Connect Almond kernel")
+    kernels_install.add_argument("--id", default=KERNEL_ID, help="Stable kernel identifier")
+    kernels_install.add_argument("--display-name", default=KERNEL_DISPLAY_NAME, help="User-facing kernel display name")
+    install_location = kernels_install.add_mutually_exclusive_group()
+    install_location.add_argument("--user", action="store_true", help="Install into the user Jupyter kernels directory")
+    install_location.add_argument("--prefix", default=None, help="Install under PREFIX/share/jupyter/kernels")
+    install_location.add_argument("--sys-prefix", action="store_true", help="Install under sys.prefix/share/jupyter/kernels")
+    install_location.add_argument("--jupyter-path", default=None, help="Install into an explicit Jupyter kernels directory")
+    install_location.add_argument("--kernels-dir", default=None, help=argparse.SUPPRESS)
+    kernels_install.add_argument("--force", action="store_true", help="Overwrite an existing kernelspec if present")
+
+    kernels_list = kernel_subparsers.add_parser("list", help="List installed kernels under runtime-home and overrides")
+    kernels_list.add_argument(
+        "--jupyter-path",
+        action="append",
+        default=[],
+        help="Additional kernels directory to inspect (can be passed multiple times)",
+    )
+    kernels_list.add_argument(
+        "--kernels-dir",
+        action="append",
+        default=[],
+        help=argparse.SUPPRESS,
+    )
+
+    kernels_remove = kernel_subparsers.add_parser("remove", help="Remove a named installed kernel")
+    kernels_remove.add_argument("name", help="Kernel directory name to remove")
+    kernels_remove.add_argument(
+        "--jupyter-path",
+        action="append",
+        default=[],
+        help="Additional kernels directory to search (can be passed multiple times)",
+    )
+    kernels_remove.add_argument(
+        "--kernels-dir",
+        action="append",
+        default=[],
+        help=argparse.SUPPRESS,
+    )
+
+    kernels_doctor = kernel_subparsers.add_parser("doctor", help="Validate kernel installation and environment")
+    kernels_doctor.add_argument("--id", default=KERNEL_ID, help="Kernel identifier to validate")
+    kernels_doctor.add_argument("--profile", default=None, help="Databricks CLI profile to validate")
+    kernels_doctor.add_argument("--jupyter-path", default=None, help="Validate an explicit Jupyter kernels directory")
+    kernels_doctor.add_argument("--kernels-dir", default=None, help=argparse.SUPPRESS)
+
+    # -- runtimes --
+    runtimes = subparsers.add_parser("runtimes", help="Inspect managed runtimes recorded under runtime-home")
+    runtime_subparsers = runtimes.add_subparsers(dest="runtimes_command", required=True)
+
+    runtime_subparsers.add_parser("list", help="List managed runtimes from runtime-home receipts")
+    runtime_subparsers.add_parser("doctor", help="Validate managed runtime receipts and install roots")
+
+    # -- render --
+    rnd = subparsers.add_parser("render", help="Render an already-executed notebook")
+    rnd.add_argument("file", help="Path to executed .ipynb notebook")
+    rnd.add_argument("--format", default="all", choices=["all", "md", "html"], dest="fmt", help="Output format (default: all)")
+    rnd.add_argument("--output-dir", default=None, help="Output directory (default: input file's parent)")
+
+    # -- doctor --
+    doctor = subparsers.add_parser("doctor", help="Validate environment for Databricks Connect")
+    doctor.add_argument("--id", default=KERNEL_ID, help="Kernel identifier to validate")
+    doctor.add_argument("--profile", default=None, help="Databricks CLI profile to validate")
+
+    # -- help --
+    subparsers.add_parser("help", help="Show usage information")
+
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# Subcommand handlers
+# ---------------------------------------------------------------------------
+
+
+def _cmd_run(args: argparse.Namespace) -> int:
+    """Full pipeline: normalize -> merge config -> inject -> execute -> render."""
+    input_path = Path(args.file).resolve()
+    if not input_path.is_file():
+        print(f"error: file not found: {args.file}", file=sys.stderr)
+        return 1
+
+    # Step 1: Normalize to notebook
+    notebook, frontmatter_config = to_notebook(input_path)
+
+    # Step 1b: Validate single language (fail fast on mixed-language notebooks)
+    try:
+        validate_single_language(notebook)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    # Step 2: Merge config
+    config = merge_config(
+        frontmatter_config or DatabricksConfig(),
+        cli_profile=args.profile,
+        cli_cluster=args.cluster,
+        cli_language=args.language,
+    )
+
+    # Step 3: Resolve cluster
+    service = default_service()
+    if config.cluster:
+        try:
+            cluster = service.resolve_cluster(config.cluster, config.profile or "DEFAULT")
+            config = DatabricksConfig(
+                profile=config.profile,
+                cluster=cluster.cluster_id,
+                language=config.language,
+            )
+        except ClusterError as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return 1
+    else:
+        print(
+            "No cluster specified — using serverless compute "
+            "(Beta for Scala, some limitations apply).",
+            file=sys.stderr,
+        )
+
+    # Step 4: Inject session setup
+    if not args.no_inject_session:
+        notebook = inject_cells(notebook, config, input_path)
+
+    # Step 5: Set up output directory
+    stem = input_path.stem
+    output_dir = Path(args.output_dir).resolve() if args.output_dir else input_path.parent
+    run_output_dir = output_dir / f"{stem}_output"
+    run_output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Step 6: Write notebook to temp file for execution
+    with tempfile.NamedTemporaryFile(
+        suffix=".ipynb", dir=str(run_output_dir), delete=False, mode="w"
+    ) as tmp:
+        nbformat.write(notebook, tmp)
+        temp_notebook = Path(tmp.name)
+
+    # Step 7: If input was not .ipynb, save pre-execution notebook
+    if input_path.suffix.lower() != ".ipynb":
+        pre_exec_path = run_output_dir / f"{stem}.ipynb"
+        shutil.copy2(temp_notebook, pre_exec_path)
+
+    # Step 8: Execute — use the kernel from the notebook's own metadata
+    kernel_name = notebook.metadata.get("kernelspec", {}).get("name", "scala212-dbr-connect")
+    result = execute_notebook(
+        temp_notebook,
+        kernel=kernel_name,
+        timeout=args.timeout,
+        allow_errors=args.allow_errors,
+    )
+
+    # Step 9: Copy executed notebook to output dir
+    executed_path = run_output_dir / f"{stem}.executed.ipynb"
+    if result.output_path and result.output_path.is_file():
+        shutil.copy2(result.output_path, executed_path)
+    elif result.success:
+        # output_path might be the same as the temp file
+        shutil.copy2(temp_notebook, executed_path)
+
+    # Step 10: Render
+    if executed_path.is_file():
+        render_paths = render(executed_path, run_output_dir, args.fmt)
+    else:
+        render_paths = {}
+
+    # Step 11: Clean up temp file
+    try:
+        temp_notebook.unlink(missing_ok=True)
+        # Also clean up the default executed output if it exists alongside temp
+        default_executed = temp_notebook.with_suffix(".executed.ipynb")
+        if default_executed.is_file() and default_executed != executed_path:
+            default_executed.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+    # Step 12: Print summary
+    if result.success:
+        print(f"Execution succeeded ({result.duration_seconds:.1f}s)")
+    else:
+        print(f"Execution failed ({result.duration_seconds:.1f}s): {result.error}", file=sys.stderr)
+
+    print(f"Output directory: {run_output_dir}")
+    for fmt_name, path in render_paths.items():
+        print(f"  {fmt_name}: {path}")
+
+    return 0 if result.success else 1
+
+
+def _cmd_clusters(args: argparse.Namespace) -> int:
+    """List available Databricks clusters."""
+    service = default_service()
+    try:
+        clusters = service.list_clusters(args.profile)
+    except ClusterError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    if not clusters:
+        print("No clusters found.", file=sys.stderr)
+        return 0
+
+    # Header
+    print(f"{'NAME':<40} {'STATE':<12} {'ID'}")
+    print("-" * 80)
+    for c in clusters:
+        print(f"{c.cluster_name:<40} {c.state:<12} {c.cluster_id}")
+
+    return 0
+
+
+def _cmd_install_kernel(args: argparse.Namespace) -> int:
+    shim_args = argparse.Namespace(
+        id=KERNEL_ID,
+        display_name=KERNEL_DISPLAY_NAME,
+        kernels_dir=args.kernels_dir,
+        user=False,
+        prefix=None,
+        sys_prefix=False,
+        jupyter_path=None,
+        force=True,
+    )
+    return _cmd_kernels_install(shim_args)
+
+
+def _resolve_kernel_dir_args(args: argparse.Namespace) -> list[Path]:
+    raw_dirs = []
+    for attribute in ("kernels_dir", "jupyter_path"):
+        value = getattr(args, attribute, None)
+        if value is None:
+            continue
+        if isinstance(value, list):
+            raw_dirs.extend(value)
+        else:
+            raw_dirs.append(value)
+
+    resolved: list[Path] = []
+    seen: set[Path] = set()
+    for raw_dir in raw_dirs:
+        path = Path(raw_dir)
+        if path in seen:
+            continue
+        resolved.append(path)
+        seen.add(path)
+    return resolved
+
+
+def _resolve_single_kernel_dir(value: str | None) -> Path | None:
+    return Path(value) if value is not None else None
+
+
+def _cmd_kernels_install(args: argparse.Namespace) -> int:
+    """Install the Databricks Connect Almond kernel."""
+    try:
+        kernel_dir = install_kernel(
+            kernel_id=getattr(args, "id", KERNEL_ID),
+            display_name=getattr(args, "display_name", KERNEL_DISPLAY_NAME),
+            kernels_dir=_resolve_single_kernel_dir(getattr(args, "kernels_dir", None)),
+            user=getattr(args, "user", False),
+            prefix=_resolve_single_kernel_dir(getattr(args, "prefix", None)),
+            sys_prefix=getattr(args, "sys_prefix", False),
+            jupyter_path=_resolve_single_kernel_dir(getattr(args, "jupyter_path", None)),
+            force=getattr(args, "force", False),
+        )
+        print(f"Kernel installed: {kernel_dir}")
+        return 0
+    except (RuntimeError, ValueError, subprocess.CalledProcessError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+
+def _cmd_kernels_list(args: argparse.Namespace) -> int:
+    """List installed kernels from runtime-home and any explicit override dirs."""
+    kernels = list_installed_kernels(kernels_dirs=_resolve_kernel_dir_args(args))
+    if not kernels:
+        print("No kernels installed.")
+        return 0
+
+    print(f"{'NAME':<24} {'SOURCE':<20} {'RUNTIME':<24} {'LAUNCHER':<18} {'CONTRACT':<18} {'RECEIPT':<18} DIRECTORY")
+    for kernel in kernels:
+        runtime_id = kernel.runtime_id or "missing"
+        launcher = kernel.launcher_path or "missing"
+        contract = str(kernel.launcher_contract_path) if kernel.launcher_contract_path is not None else "missing"
+        receipt = str(kernel.receipt_path) if kernel.receipt_path is not None else "missing"
+        print(
+            f"{kernel.name:<24} {kernel.source:<20} {runtime_id:<24} "
+            f"{launcher:<18} {contract:<18} {receipt:<18} {kernel.directory}"
+        )
+    return 0
+
+
+def _cmd_kernels_remove(args: argparse.Namespace) -> int:
+    """Remove a named installed kernel safely."""
+    try:
+        removed_dir = remove_kernel(args.name, kernels_dirs=_resolve_kernel_dir_args(args))
+        print(f"Kernel removed: {removed_dir}")
+        return 0
+    except (FileNotFoundError, RuntimeError, ValueError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+
+def _cmd_render(args: argparse.Namespace) -> int:
+    """Render an already-executed notebook."""
+    input_path = Path(args.file).resolve()
+    if not input_path.is_file():
+        print(f"error: file not found: {args.file}", file=sys.stderr)
+        return 1
+
+    output_dir = Path(args.output_dir).resolve() if args.output_dir else input_path.parent
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        render_paths = render(input_path, output_dir, args.fmt)
+    except Exception as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    for fmt_name, path in render_paths.items():
+        print(f"{fmt_name}: {path}")
+
+    return 0
+
+
+def _cmd_doctor(args: argparse.Namespace) -> int:
+    return _cmd_kernels_doctor(args)
+
+
+def _cmd_kernels_doctor(args: argparse.Namespace) -> int:
+    """Run environment validation checks."""
+    kernel_dirs = _resolve_kernel_dir_args(args)
+    if kernel_dirs:
+        checks = run_checks(profile=args.profile, kernels_dir=kernel_dirs[0], kernel_id=getattr(args, "id", KERNEL_ID))
+    else:
+        checks = run_checks(profile=args.profile, kernel_id=getattr(args, "id", KERNEL_ID))
+
+    status_symbols = {"ok": "[ok]", "warn": "[!!]", "fail": "[FAIL]"}
+
+    for check in checks:
+        symbol = status_symbols.get(check.status, "[??]")
+        print(f"  {symbol} {check.name}: {check.message}")
+
+    failures = [c for c in checks if c.status == "fail"]
+    if failures:
+        print(f"\n{len(failures)} check(s) failed.", file=sys.stderr)
+        return 1
+
+    print("\nAll checks passed.")
+    return 0
+
+
+def _cmd_kernels(args: argparse.Namespace) -> int:
+    handler = _KERNEL_HANDLERS.get(args.kernels_command)
+    if handler is None:
+        print(f"error: unknown kernels command: {args.kernels_command}", file=sys.stderr)
+        return 1
+    return handler(args)
+
+
+def _cmd_runtimes_list(_args: argparse.Namespace) -> int:
+    """List managed runtimes discovered from runtime-home receipts."""
+    runtimes = list_installed_runtimes()
+    if not runtimes:
+        print("No runtimes installed.")
+        return 0
+
+    print(f"{'RUNTIME ID':<24} {'STATUS':<16} {'DBR':<8} {'PYTHON':<8} {'RECEIPT':<18} INSTALL ROOT")
+    for runtime in runtimes:
+        print(
+            f"{runtime.runtime_id:<24} {runtime.status:<16} {runtime.databricks_line:<8} "
+            f"{runtime.python_line:<8} {runtime.receipt_path!s:<18} {runtime.install_root}"
+        )
+    return 0
+
+
+def _cmd_runtimes_doctor(_args: argparse.Namespace) -> int:
+    """Validate managed runtime receipts rooted under runtime-home."""
+    checks = doctor_installed_runtimes()
+    status_symbols = {"ok": "[ok]", "warn": "[!!]", "fail": "[FAIL]"}
+
+    for check in checks:
+        symbol = status_symbols.get(check.status, "[??]")
+        print(f"  {symbol} {check.name}: {check.message}")
+
+    failures = [check for check in checks if check.status == "fail"]
+    if failures:
+        print(f"\n{len(failures)} check(s) failed.", file=sys.stderr)
+        return 1
+
+    print("\nAll checks passed.")
+    return 0
+
+
+def _cmd_runtimes(args: argparse.Namespace) -> int:
+    handler = _RUNTIME_HANDLERS.get(args.runtimes_command)
+    if handler is None:
+        print(f"error: unknown runtimes command: {args.runtimes_command}", file=sys.stderr)
+        return 1
+    return handler(args)
+
+
+# ---------------------------------------------------------------------------
+# Dispatch table
+# ---------------------------------------------------------------------------
+
+
+_HANDLERS = {
+    "run": _cmd_run,
+    "clusters": _cmd_clusters,
+    "install-kernel": _cmd_install_kernel,
+    "kernels": _cmd_kernels,
+    "runtimes": _cmd_runtimes,
+    "render": _cmd_render,
+    "doctor": _cmd_doctor,
+}
+
+_KERNEL_HANDLERS = {
+    "install": _cmd_kernels_install,
+    "list": _cmd_kernels_list,
+    "remove": _cmd_kernels_remove,
+    "doctor": _cmd_kernels_doctor,
+}
+
+_RUNTIME_HANDLERS = {
+    "list": _cmd_runtimes_list,
+    "doctor": _cmd_runtimes_doctor,
+}
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point for ``python -m databricks_agent_notebooks`` and ``bin/agent-notebook``."""
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command is None or args.command == "help":
+        parser.print_help()
+        return 0
+
+    handler = _HANDLERS.get(args.command)
+    if handler is None:
+        print(f"error: unknown command: {args.command}", file=sys.stderr)
+        return 1
+
+    return handler(args)

databricks_agent_notebooks/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration surfaces for databricks_agent_notebooks."""

databricks_agent_notebooks/config/frontmatter.py

@@ -0,0 +1,84 @@
+"""YAML frontmatter parsing for Databricks notebook markdown files.
+
+Extracts Databricks connection configuration (profile, cluster, language)
+from ``---`` delimited YAML frontmatter blocks, and merges with CLI overrides.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass(frozen=True)
+class DatabricksConfig:
+    """Immutable Databricks connection parameters extracted from frontmatter.
+
+    All fields default to None, meaning "not specified" — callers decide
+    what defaults to apply when a field is absent.
+    """
+
+    profile: str | None = None
+    cluster: str | None = None
+    language: str | None = None
+
+
+_FRONTMATTER_RE = re.compile(r"\A---\s*\n(.*?)\n---", re.DOTALL)
+
+
+def parse_frontmatter(path: Path) -> DatabricksConfig:
+    """Parse YAML frontmatter from a markdown file and extract Databricks config.
+
+    Looks for a ``---`` delimited YAML block at the very start of the file.
+    Within that block, reads the ``databricks:`` mapping for ``profile``,
+    ``cluster``, and ``language`` keys.
+
+    Returns a default (all-None) config when:
+    - The file has no frontmatter block
+    - The frontmatter has no ``databricks:`` key
+    - The ``databricks:`` value is not a mapping
+    """
+    text = path.read_text(encoding="utf-8")
+    match = _FRONTMATTER_RE.match(text)
+    if match is None:
+        return DatabricksConfig()
+
+    try:
+        parsed: Any = yaml.safe_load(match.group(1))
+    except yaml.YAMLError:
+        return DatabricksConfig()
+
+    if not isinstance(parsed, dict):
+        return DatabricksConfig()
+
+    db = parsed.get("databricks")
+    if not isinstance(db, dict):
+        return DatabricksConfig()
+
+    return DatabricksConfig(
+        profile=db.get("profile"),
+        cluster=db.get("cluster"),
+        language=db.get("language"),
+    )
+
+
+def merge_config(
+    frontmatter: DatabricksConfig,
+    cli_profile: str | None = None,
+    cli_cluster: str | None = None,
+    cli_language: str | None = None,
+) -> DatabricksConfig:
+    """Merge frontmatter config with CLI overrides.
+
+    CLI arguments take precedence: a non-None CLI value always wins.
+    When the CLI value is None, the frontmatter value is preserved.
+    """
+    return DatabricksConfig(
+        profile=cli_profile if cli_profile is not None else frontmatter.profile,
+        cluster=cli_cluster if cli_cluster is not None else frontmatter.cluster,
+        language=cli_language if cli_language is not None else frontmatter.language,
+    )

databricks_agent_notebooks/execution/__init__.py

@@ -0,0 +1 @@
+"""Notebook execution, injection, rendering, and lineage helpers."""