Merge pull request #12 from tinybirdco/wire-sdk-init-command

Wire up SDK-owned init command with --folder support

Author: rmorehig

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tinybird-sdk"
-version = "0.1.5"
+version = "0.1.6"
 description = "Python SDK for Tinybird Forward"
 readme = "README.md"
 authors = [

src/tinybird_sdk/cli/commands/init.py

@@ -6,14 +6,14 @@
 from pathlib import Path
 from typing import Any
 
-from ..config import get_client_path, get_config_path, get_datasources_path, get_pipes_path
-from ..utils.package_manager import detect_package_manager_run_cmd
-from .login import run_login
+from ..config import find_existing_config_path
 
 
-DATASOURCES_TEMPLATE = '''from tinybird_sdk import define_datasource, t, engine
+RESOURCES_TEMPLATE = '''from tinybird_sdk import define_datasource, define_endpoint, engine, node, p, t
 
 
+# --- Datasources ---
+
 page_views = define_datasource("page_views", {
     "description": "Page view tracking data",
     "schema": {
@@ -26,10 +26,9 @@
         "sorting_key": ["pathname", "timestamp"],
     }),
 })
-'''
 
-PIPES_TEMPLATE = '''from tinybird_sdk import define_endpoint, node, t, p
 
+# --- Endpoints ---
 
 top_pages = define_endpoint("top_pages", {
     "description": "Get the most visited pages",
@@ -59,35 +58,78 @@
 })
 '''
 
-CLIENT_TEMPLATE = '''from tinybird_sdk import Tinybird
-from .datasources import page_views
-from .pipes import top_pages
 
+def _client_template(resources_import_path: str) -> str:
+    return f'''import os
 
-tinybird = Tinybird({
-    "datasources": {"page_views": page_views},
-    "pipes": {"top_pages": top_pages},
-})
+from tinybird_sdk import Tinybird
+from {resources_import_path} import page_views, top_pages
+
+tinybird = Tinybird(
+    {{
+        "datasources": {{"page_views": page_views}},
+        "pipes": {{"top_pages": top_pages}},
+        "base_url": os.getenv("TINYBIRD_API_URL", "https://api.tinybird.co"),
+        "token": os.getenv("TINYBIRD_TOKEN"),
+    }}
+)
+'''
+
+
+def _main_template(client_import_path: str) -> str:
+    return f'''from datetime import datetime, timezone
+
+from dotenv import load_dotenv
+
+
+def main():
+    load_dotenv(".env.local")
+
+    from {client_import_path} import tinybird
+
+    now = datetime.now(timezone.utc).isoformat(timespec="milliseconds")
+
+    # Ingest data using the Events API
+    tinybird.page_views.ingest(
+        {{
+            "timestamp": now,
+            "session_id": "abc123",
+            "pathname": "/home",
+            "referrer": "https://google.com",
+        }}
+    )
+
+    # Query the endpoint
+    result = tinybird.top_pages.query(
+        {{
+            "start_date": "2026-01-01 00:00:00",
+            "end_date": now,
+            "limit": 5,
+        }}
+    )
+
+    for row in result["data"]:
+        print(row["pathname"], row["views"])
+
+
+if __name__ == "__main__":
+    main()
 '''
 
 
 @dataclass(frozen=True, slots=True)
 class InitOptions:
     cwd: str | None = None
+    folder: str | None = None
     force: bool = False
-    skip_login: bool = False
-    dev_mode: str | None = None
-    client_path: str | None = None
 
 
 @dataclass(frozen=True, slots=True)
 class InitResult:
     success: bool
+    resources_path: str | None = None
     client_path: str | None = None
-    logged_in: bool | None = None
-    workspace_name: str | None = None
-    user_email: str | None = None
-    existing_datafiles: list[str] | None = None
+    main_path: str | None = None
     error: str | None = None
 
 
@@ -106,46 +148,87 @@ def _write_file(path: Path, content: str, force: bool) -> None:
     path.write_text(content, encoding="utf-8")
 
 
+def _run_tinybird_cli_init(argv: list[str]) -> int:
+    try:
+        from tinybird.tb.cli import cli as upstream_cli  # type: ignore[import-not-found]
+    except ModuleNotFoundError:
+        return 1
+
+    try:
+        upstream_cli.main(args=argv, prog_name="tinybird")
+        return 0
+    except SystemExit as error:
+        code = error.code
+        if code is None:
+            return 0
+        return code if isinstance(code, int) else 1
+
+
 def run_init(options: InitOptions | dict[str, Any] | None = None) -> InitResult:
     normalized = options if isinstance(options, InitOptions) else InitOptions(**(options or {}))
     cwd = Path(normalized.cwd or os.getcwd()).resolve()
 
     try:
-        config_path = Path(get_config_path(str(cwd)))
-        datasources_path = Path(get_datasources_path(str(cwd)))
-        pipes_path = Path(get_pipes_path(str(cwd)))
-        client_path = Path(normalized.client_path) if normalized.client_path else Path(get_client_path(str(cwd)))
-        if not client_path.is_absolute():
-            client_path = cwd / client_path
-
-        existing_datafiles = find_existing_datafiles(str(cwd))
-
-        include = [str(datasources_path.relative_to(cwd)), str(pipes_path.relative_to(cwd))]
-        include.extend(existing_datafiles)
-
-        config_payload = {
-            "include": include,
-            "token": "${TINYBIRD_TOKEN}",
-            "base_url": "${TINYBIRD_URL}",
-            "dev_mode": normalized.dev_mode or "branch",
-        }
-
-        _write_file(config_path, json.dumps(config_payload, indent=2) + "\n", normalized.force)
-        _write_file(datasources_path, DATASOURCES_TEMPLATE, normalized.force)
-        _write_file(pipes_path, PIPES_TEMPLATE, normalized.force)
-        _write_file(client_path, CLIENT_TEMPLATE, normalized.force)
-
-        login_result = None
-        if not normalized.skip_login:
-            login_result = run_login({"cwd": str(cwd)})
+        # 1. Delegate to tinybird CLI for interactive flow (dev mode, CI/CD, skills, login)
+        cli_argv = ["init", "--type", "python"]
+        if normalized.folder:
+            cli_argv.extend(["--folder", normalized.folder])
+        _run_tinybird_cli_init(cli_argv)
+
+        # 2. Determine the target folder for SDK template files
+        #    Priority: --folder flag > folder from tinybird.config.json > default
+        folder: Path | None = None
+        if normalized.folder:
+            folder = Path(normalized.folder)
+            if not folder.is_absolute():
+                folder = cwd / folder
+        else:
+            # Read the folder the tinybird CLI configured (from the interactive prompt)
+            config_path_check = find_existing_config_path(str(cwd))
+            if config_path_check and config_path_check.endswith(".json"):
+                with open(config_path_check, "r", encoding="utf-8") as fp:
+                    cli_config = json.load(fp)
+                include = cli_config.get("include", [])
+                if include:
+                    folder = cwd / Path(include[0])
+
+        if folder is None:
+            src = cwd / "src"
+            folder = (src / "lib") if src.is_dir() else (cwd / "lib")
+
+        resources_path = folder / "tinybird_resources.py"
+        client_path = folder / "client.py"
+        main_path = cwd / "main.py"
+
+        # Compute import paths based on folder relative to cwd
+        relative_folder = str(folder.relative_to(cwd)).replace(os.sep, ".")
+        resources_import = f"{relative_folder}.tinybird_resources"
+        client_import = f"{relative_folder}.client"
+
+        _write_file(resources_path, RESOURCES_TEMPLATE, normalized.force)
+        _write_file(client_path, _client_template(resources_import), normalized.force)
+        # Always overwrite main.py — the default from `uv init` is a placeholder
+        _write_file(main_path, _main_template(client_import), force=True)
+
+        # 3. Add the resources file to tinybird.config.json include list
+        config_path = find_existing_config_path(str(cwd))
+        if config_path and config_path.endswith(".json"):
+            relative_resources = str(resources_path.relative_to(cwd))
+            with open(config_path, "r", encoding="utf-8") as fp:
+                config_data = json.load(fp)
+            include = config_data.get("include", [])
+            if relative_resources not in include:
+                include.append(relative_resources)
+                config_data["include"] = include
+                with open(config_path, "w", encoding="utf-8") as fp:
+                    json.dump(config_data, fp, indent=2)
+                    fp.write("\n")
 
         return InitResult(
             success=True,
+            resources_path=str(resources_path.relative_to(cwd)),
             client_path=str(client_path.relative_to(cwd)),
-            logged_in=login_result.success if login_result else False,
-            workspace_name=login_result.workspace_name if login_result else None,
-            user_email=login_result.user_email if login_result else None,
-            existing_datafiles=existing_datafiles,
+            main_path=str(main_path.relative_to(cwd)),
         )
     except Exception as error:
         return InitResult(success=False, error=str(error))

src/tinybird_sdk/cli/index.py

@@ -6,6 +6,7 @@
 import sys
 
 from .commands.generate import run_generate
+from .commands.init import run_init
 from .commands.migrate import run_migrate
 from .output import output
 
@@ -41,9 +42,13 @@ def _run_installed_tinybird_cli(argv: list[str]) -> int:
 
 
 def create_cli() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="tinybird", description="Tinybird Python SDK generate command")
+    parser = argparse.ArgumentParser(prog="tinybird", description="Tinybird Python SDK CLI")
     sub = parser.add_subparsers(dest="command", required=True)
 
+    init_cmd = sub.add_parser("init", help="Initialize a new Tinybird project with Python SDK templates")
+    init_cmd.add_argument("--folder", help="Target folder for generated Python files")
+    init_cmd.add_argument("--force", action="store_true", help="Overwrite existing files")
+
     generate_cmd = sub.add_parser("generate", help="Generate Tinybird datafiles from Python definitions")
     generate_cmd.add_argument("--json", action="store_true")
     generate_cmd.add_argument("-o", "--output-dir")
@@ -69,12 +74,30 @@ def main(argv: list[str] | None = None) -> int:
     normalized_argv = list(argv) if argv is not None else list(sys.argv[1:])
 
     # SDK-owned commands stay local; all other commands are delegated to Tinybird CLI.
-    if not normalized_argv or normalized_argv[0] not in {"generate", "migrate"}:
+    if not normalized_argv or normalized_argv[0] not in {"init", "generate", "migrate"}:
         return _run_installed_tinybird_cli(normalized_argv)
 
     parser = create_cli()
     args = parser.parse_args(normalized_argv)
 
+    if args.command == "init":
+        result = run_init({
+            "folder": args.folder,
+            "force": args.force,
+        })
+        if not result.success:
+            output.error(result.error or "Init failed")
+            return 1
+
+        output.success("\n✓ Python SDK files created:")
+        if result.resources_path:
+            output.info(f"  {result.resources_path}")
+        if result.client_path:
+            output.info(f"  {result.client_path}")
+        if result.main_path:
+            output.info(f"  {result.main_path}")
+        return 0
+
     if args.command == "generate":
         result = run_generate({"output_dir": args.output_dir})
         if not result.success:

tests/test_cli_workflows.py

@@ -15,8 +15,20 @@
 
 
 def test_init_build_and_deploy_workflow(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    init_result = run_init({"cwd": str(tmp_path), "skip_login": True})
+    monkeypatch.setattr(
+        "tinybird_sdk.cli.commands.init._run_tinybird_cli_init",
+        lambda _argv: 0,
+    )
+    init_result = run_init({"cwd": str(tmp_path)})
     assert init_result.success is True
+    assert init_result.resources_path is not None
+    assert (tmp_path / init_result.resources_path).exists()
+
+    # Create config that the tinybird CLI would have created
+    (tmp_path / "tinybird.config.json").write_text(
+        f'{{"include":["{init_result.resources_path}"],"token":"${{TINYBIRD_TOKEN}}","base_url":"${{TINYBIRD_URL}}"}}\n',
+        encoding="utf-8",
+    )
 
     monkeypatch.setenv("TINYBIRD_TOKEN", "p.workspace")
     monkeypatch.setenv("TINYBIRD_URL", "https://api.tinybird.co")