tinybird 0.0.1.dev60__tar.gz → 0.0.1.dev62__tar.gz

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird
-Version: 0.0.1.dev60
+Version: 0.0.1.dev62
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/cli/introduction.html'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev60'
-__revision__ = '433b697'
+__version__ = '0.0.1.dev62'
+__revision__ = '472a5f2'

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/build.py

@@ -31,48 +31,19 @@ def build(ctx: click.Context, watch: bool) -> None:
     project: Project = ctx.ensure_object(dict)["project"]
     tb_client: TinyB = ctx.ensure_object(dict)["client"]
     click.echo(FeedbackManager.highlight_building_project())
+    process(project=project, tb_client=tb_client, watch=watch)
+    if watch:
+        run_watch(project=project, tb_client=tb_client)
 
-    def process(watch: bool, file_changed: Optional[str] = None, diff: Optional[str] = None) -> None:
-        time_start = time.time()
-        build_failed = False
-        if file_changed and file_changed.endswith(".ndjson"):
-            rebuild_fixture(project, tb_client, file_changed)
-        else:
-            try:
-                build_project(project, tb_client, file_changed)
-            except click.ClickException as e:
-                click.echo(e)
-                build_failed = True
-            try:
-                if file_changed:
-                    asyncio.run(folder_build(project, tb_client, filenames=[file_changed]))
-                    show_data(tb_client, file_changed, diff)
-            except Exception:
-                pass
-
-        time_end = time.time()
-        elapsed_time = time_end - time_start
-
-        rebuild_str = "Rebuild" if watch else "Build"
-        if build_failed:
-            click.echo(FeedbackManager.error(message=f"\n✗ {rebuild_str} failed"))
-            if not watch:
-                sys.exit(1)
-        else:
-            click.echo(FeedbackManager.success(message=f"\n✓ {rebuild_str} completed in {elapsed_time:.1f}s"))
-
-    process(watch=watch)
 
-    if watch:
-        shell = Shell(project=project, tb_client=tb_client)
-        click.echo(FeedbackManager.gray(message="\nWatching for changes..."))
-        watcher_thread = threading.Thread(
-            target=watch_project,
-            args=(shell, process, project),
-            daemon=True,
-        )
-        watcher_thread.start()
-        shell.run()
+@cli.command("dev", help="Build the project server side and watch for changes")
+@click.pass_context
+def dev(ctx: click.Context) -> None:
+    project: Project = ctx.ensure_object(dict)["project"]
+    tb_client: TinyB = ctx.ensure_object(dict)["client"]
+    click.echo(FeedbackManager.highlight_building_project())
+    process(project=project, tb_client=tb_client, watch=True)
+    run_watch(project=project, tb_client=tb_client)
 
 
 def build_project(project: Project, tb_client: TinyB, file_changed: Optional[str] = None) -> None:
@@ -116,19 +87,20 @@ def build_project(project: Project, tb_client: TinyB, file_changed: Optional[str
 
         build_result = result.get("result")
         if build_result == "success":
-            datasources = result.get("datasources", [])
-            pipes = result.get("pipes", [])
+            build = result.get("build")
+            datasources = build.get("new_datasource_names", [])
+            pipes = build.get("new_pipe_names", [])
             if not file_changed:
                 for ds in datasources:
                     ds_path_str: Optional[str] = next(
-                        (p for p in project_files if p.endswith(ds.get("name") + ".datasource")), None
+                        (p for p in project_files if p.endswith(ds + ".datasource")), None
                     )
                     if ds_path_str:
                         ds_path = Path(ds_path_str)
                         ds_path_str = ds_path_str.replace(f"{project.folder}/", "")
                         click.echo(FeedbackManager.info(message=f"✓ {ds_path_str} created"))
                 for pipe in pipes:
-                    pipe_name = pipe.get("name")
+                    pipe_name = pipe
                     pipe_path_str: Optional[str] = next(
                         (p for p in project_files if p.endswith(pipe_name + ".pipe")), None
                     )
@@ -227,3 +199,47 @@ def show_data(tb_client: TinyB, filename: str, diff: Optional[str] = None):
 
     res = asyncio.run(tb_client.query(sql, pipeline=pipeline))
     print_table_formatted(res, table_name)
+
+
+def process(
+    project: Project, tb_client: TinyB, watch: bool, file_changed: Optional[str] = None, diff: Optional[str] = None
+) -> None:
+    time_start = time.time()
+    build_failed = False
+    if file_changed and file_changed.endswith(".ndjson"):
+        rebuild_fixture(project, tb_client, file_changed)
+    else:
+        try:
+            build_project(project, tb_client, file_changed)
+        except click.ClickException as e:
+            click.echo(e)
+            build_failed = True
+        try:
+            if file_changed:
+                asyncio.run(folder_build(project, tb_client, filenames=[file_changed]))
+                show_data(tb_client, file_changed, diff)
+        except Exception:
+            pass
+
+    time_end = time.time()
+    elapsed_time = time_end - time_start
+
+    rebuild_str = "Rebuild" if watch else "Build"
+    if build_failed:
+        click.echo(FeedbackManager.error(message=f"\n✗ {rebuild_str} failed"))
+        if not watch:
+            sys.exit(1)
+    else:
+        click.echo(FeedbackManager.success(message=f"\n✓ {rebuild_str} completed in {elapsed_time:.1f}s"))
+
+
+def run_watch(project: Project, tb_client: TinyB) -> None:
+    shell = Shell(project=project, tb_client=tb_client)
+    click.echo(FeedbackManager.gray(message="\nWatching for changes..."))
+    watcher_thread = threading.Thread(
+        target=watch_project,
+        args=(shell, process, project),
+        daemon=True,
+    )
+    watcher_thread.start()
+    shell.run()

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/cli.py

@@ -57,7 +57,6 @@ VERSION = f"{__cli__.__version__} (rev {__cli__.__revision__})"
 @click.option("--show-tokens", is_flag=True, default=False, help="Enable the output of tokens")
 @click.option("--cloud/--local", is_flag=True, default=False, help="Run against cloud or local")
 @click.option("--build", is_flag=True, default=False, help="Run against build mode")
-@click.option("--folder", type=str, help="Folder where files will be placed")
 @click.version_option(version=VERSION)
 @click.pass_context
 @coro
@@ -69,12 +68,11 @@ async def cli(
     show_tokens: bool,
     cloud: bool,
     build: bool,
-    folder: Optional[str],
 ) -> None:
     """
     Use `OBFUSCATE_REGEX_PATTERN` and `OBFUSCATE_PATTERN_SEPARATOR` environment variables to define a regex pattern and a separator (in case of a single string with multiple regex) to obfuscate secrets in the CLI output.
     """
-    project = Project(folder=folder or os.getcwd())
+    project = Project(folder=os.getcwd())
     # We need to unpatch for our tests not to break
     if show_tokens or not cloud or ctx.invoked_subcommand == "build" or build:
         __unpatch_click_output()
@@ -132,18 +130,15 @@ async def cli(
 
 
 @cli.command(hidden=True)
-@click.option(
-    "--folder", default=None, type=click.Path(exists=True, file_okay=False), help="Folder where files will be placed"
-)
 @click.option("-f", "--force", is_flag=True, default=False, help="Override existing files")
 @click.option("--fmt", is_flag=True, default=False, help="Format files before saving")
 @click.pass_context
 @coro
-async def pull(ctx: Context, folder: str, force: bool, fmt: bool) -> None:
+async def pull(ctx: Context, force: bool, fmt: bool) -> None:
     """Retrieve latest versions for project files from Tinybird."""
 
     client = ctx.ensure_object(dict)["client"]
-    folder = folder if folder else getcwd()
+    folder = getcwd()
 
     return await folder_pull(client, folder, force, fmt=fmt)
 

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/config.py

@@ -321,6 +321,10 @@ class CLIConfig:
         """
         working_dir = working_dir or os.getcwd()
         path: str = os.path.join(working_dir, ".tinyb")
+
+        if not os.path.exists(path):
+            path = os.path.join(os.path.dirname(working_dir), ".tinyb")
+
         return CLIConfig(path, parent=CLIConfig.get_global_config())
 
     @staticmethod

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/create.py

@@ -33,22 +33,15 @@ from tinybird.tb.modules.project import Project
     default=None,
     help="Prompt to be used to create the project",
 )
-@click.option(
-    "--folder",
-    default="",
-    type=click.Path(exists=False, file_okay=False),
-    help="Folder where datafiles will be placed",
-)
 @click.option("--rows", type=int, default=10, help="Number of events to send")
 @click.option("--source", type=str, default="tb", help="Source of the command")
-@click.option("--skip", is_flag=True, default=False, help="Skip following up on the generated data")
+@click.option("--skip", is_flag=True, default=False, help="Skip following up on the generated resources")
 @click.pass_context
 @coro
 async def create(
     ctx: click.Context,
     data: Optional[str],
     prompt: Optional[str],
-    folder: Optional[str],
     rows: int,
     source: str,
     skip: bool,
@@ -56,7 +49,7 @@ async def create(
     """Initialize a new project."""
     project: Project = ctx.ensure_object(dict)["project"]
     local_client: TinyB = ctx.ensure_object(dict)["client"]
-    folder = folder or getcwd()
+    folder = getcwd()
     folder_path = Path(folder)
     if not folder_path.exists():
         folder_path.mkdir()

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/datafile/fixture.py

@@ -5,10 +5,7 @@ from tinybird.tb.modules.common import format_data_to_ndjson
 
 
 def get_fixture_dir(folder: str) -> Path:
-    fixture_dir = Path(folder) / "fixtures"
-    if not fixture_dir.exists():
-        fixture_dir.mkdir()
-    return fixture_dir
+    return Path(folder) / "fixtures"
 
 
 def persist_fixture(fixture_name: str, data: Union[List[Dict[str, Any]], str], folder: str, format="ndjson") -> Path:

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/endpoint.py

@@ -10,6 +10,7 @@ from urllib.parse import urlencode
 
 import click
 import humanfriendly
+import pyperclip
 import requests
 from click import Context
 
@@ -54,7 +55,7 @@ async def endpoint_ls(ctx: Context, match: str, format_: str):
         tk = get_name_version(t["name"])
         if pattern and not pattern.search(tk["name"]):
             continue
-        token = get_endpoint_token(tokens, tk["name"])
+        token = get_endpoint_token(tokens, tk["name"]) or client.token
         endpoint_url = build_endpoint_url(client, tk["name"], token)
         table_human_readable.append((tk["name"], t["updated_at"][:-7], len(t["nodes"]), endpoint_url))
         table_machine_readable.append(
@@ -151,29 +152,23 @@ async def endpoint_data(ctx: Context, pipe: str, query: str, format_: str):
 
 @endpoint.command(name="url")
 @click.argument("pipe")
+@click.option(
+    "--language",
+    default="http",
+    help="Language used for sending the request. Options: http, python, curl, javascript, rust, go",
+)
 @click.pass_context
 @coro
-async def endpoint_url(ctx: Context, pipe: str):
+async def endpoint_url(ctx: Context, pipe: str, language: str):
     """Print the URL of an endpoint"""
+    if language != "http":
+        click.echo(FeedbackManager.highlight(message=f"\n» Generating snippet for {language} language"))
     client: TinyB = ctx.ensure_object(dict)["client"]
     tokens = await client.tokens()
-    token = get_endpoint_token(tokens, pipe)
-    click.echo(build_endpoint_url(client, pipe, token))
-
-
-def build_endpoint_url(tb_client: TinyB, pipe_name: str, token: Optional[str]) -> Optional[str]:
-    try:
-        token = token or tb_client.token
-        example_params = {
-            "format": "json",
-            "pipe": pipe_name,
-            "q": "",
-            "token": token,
-        }
-        response = requests.get(f"{tb_client.host}/examples/query.http?{urlencode(example_params)}")
-        return response.text.replace("http://localhost:8001", tb_client.host)
-    except Exception:
-        return None
+    token = get_endpoint_token(tokens, pipe) or client.token
+    click.echo(build_endpoint_snippet(client, pipe, token, language))
+    if language != "http":
+        click.echo(FeedbackManager.success(message="\n✓ Code snippet copied to clipboard!\n"))
 
 
 def get_endpoint_token(tokens: List[Dict[str, Any]], pipe_name: str) -> Optional[str]:
@@ -272,3 +267,104 @@ async def endpoint_stats(ctx: click.Context, pipes: Tuple[str, ...], format_: st
             click.echo(json.dumps({"pipes": table_machine_readable}, indent=2))
         else:
             echo_safe_humanfriendly_tables_format_smart_table(table_human_readable, column_names=columns)
+
+
+def build_endpoint_snippet(tb_client: TinyB, pipe_name: str, token: Optional[str], language: str) -> Optional[str]:
+    endpoint_url = build_endpoint_url(tb_client, pipe_name, token)
+    if language == "http":
+        return endpoint_url
+
+    snippet = None
+    if language == "python":
+        snippet = build_python_snippet(endpoint_url, token)
+    elif language == "curl":
+        snippet = build_curl_snippet(endpoint_url)
+    elif language == "javascript":
+        snippet = build_javascript_snippet(endpoint_url, token)
+    elif language == "rust":
+        snippet = build_rust_snippet(endpoint_url, token)
+    elif language == "go":
+        snippet = build_go_snippet(endpoint_url, token)
+
+    if not snippet:
+        raise CLIPipeException(FeedbackManager.error(message=f"Language {language} not supported"))
+
+    pyperclip.copy(snippet.strip())
+    return snippet
+
+
+def build_endpoint_url(tb_client: TinyB, pipe_name: str, token: str) -> str:
+    example_params = {
+        "format": "json",
+        "pipe": pipe_name,
+        "q": "",
+        "token": token,
+    }
+    response = requests.get(f"{tb_client.host}/examples/query.http?{urlencode(example_params)}")
+    return response.text.replace("http://localhost:8001", tb_client.host)
+
+
+def build_python_snippet(endpoint_url: str, token: str) -> str:
+    endpoint_url = endpoint_url.replace(f"token={token}", "token={{token}}")
+    return f"""
+import requests
+
+token = "{token}"
+url = "{endpoint_url}"
+response = requests.get(url)
+print(response.json())
+    """
+
+
+def build_curl_snippet(endpoint_url: str) -> str:
+    return f"""
+curl -X GET "{endpoint_url}"
+    """
+
+
+def build_javascript_snippet(endpoint_url: str, token: str) -> str:
+    endpoint_url = endpoint_url.replace(f"token={token}", "token=${token}")
+    return f"""
+const token = "{token}";
+fetch(`{endpoint_url}`)
+.then(response => response.json())
+.then(data => console.log(data));
+    """
+
+
+def build_rust_snippet(endpoint_url: str) -> str:
+    return f"""
+use reqwest::Client;
+
+let client = Client::new();
+let response = client.get("{endpoint_url}").send().await?;
+    """
+
+
+def build_go_snippet(endpoint_url: str) -> str:
+    return f"""
+package main
+
+import (
+    "fmt"
+    "io"
+    "log"
+    "net/http"
+)
+
+func main() {{
+    url := "{endpoint_url}"
+    resp, err := http.Get(url)
+    if err != nil {{
+        log.Fatal(err)
+    }}
+    defer resp.Body.Close()
+
+    body, err := io.ReadAll(resp.Body)
+    if err != nil {{
+        log.Fatal(err)
+    }}
+
+    fmt.Println(string(body))
+}}
+    """

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/local_common.py

@@ -5,9 +5,8 @@ from typing import Any, Dict
 
 import requests
 
-from tinybird.client import AuthNoTokenException, TinyB
+from tinybird.client import AuthException, AuthNoTokenException, TinyB
 from tinybird.tb.modules.config import CLIConfig
-from tinybird.tb.modules.exceptions import CLIException
 
 TB_IMAGE_NAME = "tinybirdco/tinybird-local:beta"
 TB_CONTAINER_NAME = "tinybird-local"
@@ -33,7 +32,7 @@ async def get_tinybird_local_config(config_obj: Dict[str, Any], build: bool = Fa
         # ruff: noqa: ASYNC210
         tokens = requests.get(f"{TB_LOCAL_HOST}/tokens").json()
     except Exception:
-        raise CLIException("Tinybird local is not running. Please run `tb local start` first.")
+        raise AuthException("Error: Tinybird local is not running. Please run `tb local start` first.")
 
     user_token = tokens["user_token"]
     admin_token = tokens["admin_token"]

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/mock.py

@@ -1,3 +1,4 @@
+import glob
 import logging
 import os
 from pathlib import Path
@@ -46,11 +47,13 @@ async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, skip
         datasource_name = datasource
         folder = project.folder
         click.echo(FeedbackManager.highlight(message=f"\n» Creating fixture for {datasource_name}..."))
+
         if datasource_path.suffix == ".datasource":
             datasource_name = datasource_path.stem
         else:
-            datasource_path = Path("datasources", f"{datasource}.datasource")
-        datasource_path = Path(folder) / datasource_path
+            datasource_from_glob = glob.glob(f"**/*/{datasource}.datasource")
+            if datasource_from_glob:
+                datasource_path = Path(datasource_from_glob[0])
 
         if not datasource_path.exists():
             raise CLIException(f"Datasource '{datasource_path.stem}' not found")
@@ -61,7 +64,6 @@ async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, skip
             if prompt_path.exists():
                 prompt = prompt_path.read_text()
         else:
-            click.echo(FeedbackManager.info(message="* Overriding last prompt..."))
             prompt_path.write_text(prompt)
 
         datasource_content = datasource_path.read_text()

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/shell.py

@@ -272,7 +272,7 @@ class Shell:
         click.echo(FeedbackManager.error(message=f"'tb {arg}' command is not available in watch mode"))
 
     def handle_mock(self, arg):
-        subprocess.run(f"tb --build --folder {self.project.folder} mock {arg} --skip", shell=True, text=True)
+        subprocess.run(f"tb --build mock {arg} --skip", shell=True, text=True)
 
     def handle_tb(self, arg):
         click.echo("")
@@ -289,7 +289,7 @@ class Shell:
             need_skip = ("mock", "test create", "create")
             if any(arg.startswith(cmd) for cmd in need_skip):
                 arg = f"{arg} --skip"
-            subprocess.run(f"tb --build --folder {self.project.folder} {arg}", shell=True, text=True)
+            subprocess.run(f"tb --build {arg}", shell=True, text=True)
 
     def default(self, argline):
         click.echo("")
@@ -304,7 +304,7 @@ class Shell:
             need_skip = ("mock", "test create", "create")
             if any(arg.startswith(cmd) for cmd in need_skip):
                 arg = f"{arg} --skip"
-            subprocess.run(f"tb --build --folder {self.project.folder} {arg}", shell=True, text=True)
+            subprocess.run(f"tb --build {arg}", shell=True, text=True)
 
     def run_sql(self, query, rows_limit=20):
         try:

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird/tb/modules/test.py

@@ -193,17 +193,13 @@ async def test_create(ctx: click.Context, name_or_filename: str, prompt: str, sk
     help="Update the test expectations for a file or a test.",
 )
 @click.argument("pipe", type=str)
-@click.option(
-    "--folder",
-    default=".",
-    type=click.Path(exists=True, file_okay=False),
-    help="Folder where datafiles will be placed",
-)
 @click.pass_context
 @coro
-async def test_update(ctx: click.Context, pipe: str, folder: str) -> None:
+async def test_update(ctx: click.Context, pipe: str) -> None:
     try:
         client: TinyB = ctx.ensure_object(dict)["client"]
+        project: Project = ctx.ensure_object(dict)["project"]
+        folder = project.folder
         pipe_tests_path = Path(pipe)
         pipe_name = pipe
         if pipe_tests_path.suffix == ".yaml":
@@ -212,7 +208,7 @@ async def test_update(ctx: click.Context, pipe: str, folder: str) -> None:
             pipe_tests_path = Path("tests", f"{pipe}.yaml")
 
         click.echo(FeedbackManager.highlight(message=f"\n» Updating tests expectations for {pipe_name} endpoint..."))
-        pipe_tests_path = Path(folder) / pipe_tests_path
+        pipe_tests_path = Path(project.folder) / pipe_tests_path
         pipe_tests_content = yaml.safe_load(pipe_tests_path.read_text())
         for test in pipe_tests_content:
             test_params = test["parameters"].split("?")[1] if "?" in test["parameters"] else test["parameters"]
@@ -246,15 +242,9 @@ async def test_update(ctx: click.Context, pipe: str, folder: str) -> None:
     help="Run the test suite, a file, or a test.",
 )
 @click.argument("name", nargs=-1)
-@click.option(
-    "--folder",
-    default=".",
-    type=click.Path(exists=True, file_okay=False),
-    help="Folder where tests will be placed",
-)
 @click.pass_context
 @coro
-async def run_tests(ctx: click.Context, name: Tuple[str, ...], folder: str) -> None:
+async def run_tests(ctx: click.Context, name: Tuple[str, ...]) -> None:
     click.echo(FeedbackManager.highlight(message="\n» Running tests"))
     client: TinyB = ctx.ensure_object(dict)["client"]
     paths = [Path(n) for n in name]

{tinybird-0.0.1.dev60 → tinybird-0.0.1.dev62}/tinybird.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird
-Version: 0.0.1.dev60
+Version: 0.0.1.dev62
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird