tinybird 0.0.1.dev16__py3-none-any.whl → 0.0.1.dev17__py3-none-any.whl

tinybird/tb/cli.py

@@ -5,7 +5,6 @@ if sys.platform == "win32":
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 import tinybird.tb.modules.auth
-import tinybird.tb.modules.branch
 import tinybird.tb.modules.build
 import tinybird.tb.modules.cli
 import tinybird.tb.modules.common

tinybird/tb/modules/build.py

@@ -27,9 +27,10 @@ from tinybird.tb.modules.local_common import get_tinybird_local_client
 
 
 class FileChangeHandler(FileSystemEventHandler):
-    def __init__(self, filenames: List[str], process: Callable[[List[str]], None]):
+    def __init__(self, filenames: List[str], process: Callable[[List[str]], None], build_ok: bool):
         self.filenames = filenames
         self.process = process
+        self.build_ok = build_ok
 
     def on_modified(self, event: Any) -> None:
         is_not_vendor = "vendor/" not in event.src_path
@@ -41,7 +42,9 @@ class FileChangeHandler(FileSystemEventHandler):
             filename = event.src_path.split("/")[-1]
             click.echo(FeedbackManager.highlight(message=f"\n\n⟲ Changes detected in {filename}\n"))
             try:
-                self.process([event.src_path])
+                to_process = [event.src_path] if self.build_ok else self.filenames
+                self.process(to_process)
+                self.build_ok = True
             except Exception as e:
                 click.echo(FeedbackManager.error_exception(error=e))
 
@@ -51,6 +54,7 @@ def watch_files(
     process: Union[Callable[[List[str]], None], Callable[[List[str]], Awaitable[None]]],
     shell: BuildShell,
     folder: str,
+    build_ok: bool,
 ) -> None:
     # Handle both sync and async process functions
     async def process_wrapper(files: List[str]) -> None:
@@ -68,7 +72,7 @@ def watch_files(
         )
         shell.reprint_prompt()
 
-    event_handler = FileChangeHandler(filenames, lambda f: asyncio.run(process_wrapper(f)))
+    event_handler = FileChangeHandler(filenames, lambda f: asyncio.run(process_wrapper(f)), build_ok)
     observer = Observer()
 
     observer.schedule(event_handler, path=folder, recursive=True)
@@ -110,7 +114,6 @@ async def build(
     ignore_sql_errors = FeatureFlags.ignore_sql_errors()
     context.disable_template_security_validation.set(True)
     is_internal = has_internal_datafiles(folder)
-
     folder_path = os.path.abspath(folder)
     tb_client = await get_tinybird_local_client(folder_path)
 
@@ -143,30 +146,31 @@ async def build(
                 is_internal=is_internal,
                 watch=watch,
             )
-
-        filename = filenames[0]
-        if filename.endswith(".ndjson"):
-            fixture_path = Path(filename)
-            name = "_".join(fixture_path.stem.split("_")[:-1])
-            ds_path = Path(folder) / "datasources" / f"{name}.datasource"
-            if ds_path.exists():
-                await append_datasource({}, tb_client, name, str(fixture_path), silent=True)
-
-        if watch:
-            if filename.endswith(".datasource"):
-                ds_path = Path(filename)
-                name = build_fixture_name(filename, ds_path.stem, ds_path.read_text())
-                fixture_path = get_fixture_dir() / f"{name}.ndjson"
-                if fixture_path.exists():
-                    await append_datasource({}, tb_client, ds_path.stem, str(fixture_path), silent=True)
-            if not filename.endswith(".ndjson"):
-                await build_and_print_resource(tb_client, filename)
+        if len(filenames) > 0:
+            filename = filenames[0]
+            if filename.endswith(".ndjson"):
+                fixture_path = Path(filename)
+                name = "_".join(fixture_path.stem.split("_")[:-1])
+                ds_path = Path(folder) / "datasources" / f"{name}.datasource"
+                if ds_path.exists():
+                    await append_datasource({}, tb_client, name, str(fixture_path), silent=True)
+
+            if watch:
+                if filename.endswith(".datasource"):
+                    ds_path = Path(filename)
+                    name = build_fixture_name(filename, ds_path.stem, ds_path.read_text())
+                    fixture_path = get_fixture_dir() / f"{name}.ndjson"
+                    if fixture_path.exists():
+                        await append_datasource({}, tb_client, ds_path.stem, str(fixture_path), silent=True)
+                if not filename.endswith(".ndjson"):
+                    await build_and_print_resource(tb_client, filename)
 
     datafiles = get_project_filenames(folder)
     fixtures = get_project_fixtures(folder)
     filenames = datafiles + fixtures
 
     async def build_once(filenames: List[str]):
+        ok = False
         try:
             click.echo("⚡ Building project...\n")
             time_start = time.time()
@@ -181,15 +185,20 @@ async def build(
                     if fixture_path.exists():
                         await append_datasource({}, tb_client, ds_path.stem, str(fixture_path), silent=True)
             click.echo(FeedbackManager.success(message=f"\n✓ Build completed in {elapsed_time:.1f}s\n"))
+            ok = True
         except Exception as e:
             click.echo(FeedbackManager.error(message=str(e)))
+            ok = False
+        return ok
 
-    await build_once(filenames)
+    build_ok = await build_once(filenames)
 
     if watch:
         shell = BuildShell(folder=folder, client=tb_client)
         click.echo(FeedbackManager.highlight(message="◎ Watching for changes..."))
-        watcher_thread = threading.Thread(target=watch_files, args=(filenames, process, shell, folder), daemon=True)
+        watcher_thread = threading.Thread(
+            target=watch_files, args=(filenames, process, shell, folder, build_ok), daemon=True
+        )
         watcher_thread.start()
         shell.cmdloop()
 

tinybird/tb/modules/build_shell.py

@@ -14,7 +14,7 @@ from tinybird.tb.modules.table import format_table
 
 
 class BuildShell(cmd.Cmd):
-    prompt = "\n\001\033[1;32m\002TB > \001\033[0m\002"
+    prompt = "\n\001\033[1;32m\002tb > \001\033[0m\002"
 
     def __init__(self, folder: str, client: TinyB):
         super().__init__()
@@ -27,28 +27,44 @@ class BuildShell(cmd.Cmd):
     def do_quit(self, arg):
         sys.exit(0)
 
+    def do_build(self, arg):
+        click.echo(FeedbackManager.error(message=f"'tb {arg}' command is not available in watch mode"))
+
+    def do_auth(self, arg):
+        click.echo(FeedbackManager.error(message=f"'tb {arg}' command is not available in watch mode"))
+
+    def do_workspace(self, arg):
+        click.echo(FeedbackManager.error(message=f"'tb {arg}' command is not available in watch mode"))
+
+    def do_mock(self, arg):
+        subprocess.run(f"tb mock {arg} --folder {self.folder}", shell=True, text=True)
+
+    def do_tb(self, arg):
+        click.echo("")
+        arg = arg.strip().lower()
+        if arg.startswith("build"):
+            self.do_build(arg)
+        elif arg.startswith("auth"):
+            self.do_auth(arg)
+        elif arg.startswith("workspace"):
+            self.do_workspace(arg)
+        elif arg.startswith("mock"):
+            self.do_mock(arg)
+        else:
+            subprocess.run(f"tb --local {arg}", shell=True, text=True)
+
     def default(self, argline):
         click.echo("")
-        if argline.startswith("tb build"):
-            click.echo(FeedbackManager.error(message="Build command is already running"))
+        arg = argline.strip().lower()
+        if not arg:
+            return
+        if arg.startswith("with") or arg.startswith("select"):
+            try:
+                self.run_sql(argline)
+            except Exception as e:
+                click.echo(FeedbackManager.error(message=str(e)))
         else:
-            arg_stripped = argline.strip().lower()
-            if not arg_stripped:
-                return
-            if arg_stripped.startswith("tb"):
-                arg_stripped = arg_stripped.replace("tb", "tb --local")
-                extra_args = f" --folder {self.folder}" if arg_stripped.startswith("tb mock") else ""
-                subprocess.run(arg_stripped + extra_args, shell=True, text=True)
-            elif arg_stripped.startswith("with") or arg_stripped.startswith("select"):
-                try:
-                    self.run_sql(self.client, argline)
-                except Exception as e:
-                    click.echo(FeedbackManager.error(message=str(e)))
-
-            elif arg_stripped.startswith("mock "):
-                subprocess.run(f"tb {arg_stripped} --folder {self.folder}", shell=True, text=True)
-            else:
-                click.echo(FeedbackManager.error(message="Invalid command"))
+            subprocess.run(f"tb --local {arg}", shell=True, text=True)
 
     def reprint_prompt(self):
         self.stdout.write(self.prompt)

tinybird/tb/modules/cli.py

@@ -36,7 +36,6 @@ from tinybird.tb.modules.common import (
     coro,
     create_tb_client,
     echo_safe_format_table,
-    folder_init,
     get_current_main_workspace,
     getenv_bool,
     is_major_semver,
@@ -81,7 +80,6 @@ DEFAULT_PATTERNS: List[Tuple[str, Union[str, Callable[[str], str]]]] = [
 )
 @click.option("--token", help="Use auth token, defaults to TB_TOKEN envvar, then to the .tinyb file")
 @click.option("--host", help="Use custom host, defaults to TB_HOST envvar, then to https://api.tinybird.co")
-@click.option("--semver", help="Semver of a Release to run the command. Example: 1.0.0", hidden=True)
 @click.option("--gcp-project-id", help="The Google Cloud project ID", hidden=True)
 @click.option(
     "--gcs-bucket", help="The Google Cloud Storage bucket to write temp files when using the connectors", hidden=True
@@ -118,7 +116,6 @@ async def cli(
     debug: bool,
     token: str,
     host: str,
-    semver: str,
     gcp_project_id: str,
     gcs_bucket: str,
     google_application_credentials: str,
@@ -140,7 +137,7 @@ async def cli(
     """
 
     # We need to unpatch for our tests not to break
-    if show_tokens:
+    if show_tokens or local or ctx.invoked_subcommand == "build":
         __unpatch_click_output()
     else:
         __patch_click_output()
@@ -156,9 +153,7 @@ async def cli(
         config_temp.set_token(token)
     if host:
         config_temp.set_host(host)
-    if semver:
-        config_temp.set_semver(semver)
-    if token or host or semver:
+    if token or host:
         await try_update_config_with_remote(config_temp, auto_persist=False, raise_on_errors=False)
 
     # Overwrite token and host with env vars manually, without resorting to click.
@@ -170,10 +165,8 @@ async def cli(
         token = os.environ.get("TB_TOKEN", "")
     if not host and "TB_HOST" in os.environ:
         host = os.environ.get("TB_HOST", "")
-    if not semver and "TB_SEMVER" in os.environ:
-        semver = os.environ.get("TB_SEMVER", "")
 
-    config = await get_config(host, token, semver)
+    config = await get_config(host, token)
     client = _get_tb_client(config.get("token", None), config["host"])
 
     # If they have passed a token or host as paramter and it's different that record in .tinyb, refresh the workspace id
@@ -232,88 +225,13 @@ async def cli(
     logging.debug("debug enabled")
 
     ctx.ensure_object(dict)["client"] = (
-        await get_tinybird_local_client()
-        if local
-        else _get_tb_client(config.get("token", None), config["host"], semver)
+        await get_tinybird_local_client() if local else _get_tb_client(config.get("token", None), config["host"])
     )
 
     for connector in SUPPORTED_CONNECTORS:
         load_connector_config(ctx, connector, debug, check_uninstalled=True)
 
 
-@cli.command()
-@click.option(
-    "--generate-datasources",
-    is_flag=True,
-    default=False,
-    help="Generate datasources based on CSV, NDJSON and Parquet files in this folder",
-)
-@click.option(
-    "--folder",
-    default=None,
-    type=click.Path(exists=True, file_okay=False),
-    help="Folder where datafiles will be placed",
-)
-@click.option("-f", "--force", is_flag=True, default=False, help="Overrides existing files")
-@click.option(
-    "-ir",
-    "--ignore-remote",
-    is_flag=True,
-    default=False,
-    help="Ignores remote files not present in the local data project on git init",
-)
-@click.option(
-    "--git",
-    is_flag=True,
-    default=False,
-    help="Init workspace with git releases. Generates CI/CD files for your git provider",
-)
-@click.option(
-    "--override-commit",
-    default=None,
-    help="Use this option to manually override the reference commit of your workspace. This is useful if a commit is not recognized in your git log, such as after a force push (git push -f).",
-)
-@click.option(
-    "--cicd", is_flag=True, default=False, help="Generates only CI/CD files for your git provider", hidden=True
-)
-@click.pass_context
-@coro
-async def init(
-    ctx: Context,
-    generate_datasources: bool,
-    folder: Optional[str],
-    force: bool,
-    ignore_remote: bool,
-    git: bool,
-    override_commit: Optional[str],
-    cicd: Optional[bool],
-) -> None:
-    """Initialize folder layout."""
-    client: TinyB = ctx.ensure_object(dict)["client"]
-    config = CLIConfig.get_project_config()
-    if config.get("token") is None:
-        raise AuthNoTokenException
-    folder = folder if folder else getcwd()
-
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches()).get("workspaces", [])
-    current_ws: Dict[str, Any] = next(
-        (workspace for workspace in workspaces if config and workspace.get("id", ".") == config.get("id", "..")), {}
-    )
-
-    if current_ws.get("is_branch"):
-        raise CLIException(FeedbackManager.error_not_allowed_in_branch())
-
-    await folder_init(client, folder, generate_datasources, generate_releases=True, force=force)
-
-    error = False
-    final_response = None
-
-    if final_response:
-        if error:
-            raise CLIException(final_response)
-        click.echo(final_response)
-
-
 @cli.command()
 @click.argument("filenames", type=click.Path(exists=True), nargs=-1, default=None)
 @click.option("--debug", is_flag=True, default=False, help="Print internal representation")
@@ -1347,9 +1265,6 @@ async def deploy(
             check_backfill_required = getenv_bool("TB_CHECK_BACKFILL_REQUIRED", True)
         try:
             tb_client = create_tb_client(ctx)
-            if dry_run:
-                config.set_semver(None)
-                tb_client.semver = None
             await folder_push(
                 tb_client=tb_client,
                 dry_run=dry_run,

tinybird/tb/modules/common.py

@@ -218,19 +218,6 @@ async def get_current_environment(client, config):
     return next((workspace for workspace in workspaces if workspace["id"] == config["id"]), None)
 
 
-async def get_current_workspace_branches(config: CLIConfig) -> List[Dict[str, Any]]:
-    current_main_workspace: Optional[Dict[str, Any]] = await get_current_main_workspace(config)
-    if not current_main_workspace:
-        raise CLIException(FeedbackManager.error_unable_to_identify_main_workspace())
-
-    client = config.get_client()
-    user_branches: List[Dict[str, Any]] = (await client.user_workspace_branches()).get("workspaces", [])
-    all_branches: List[Dict[str, Any]] = (await client.branches()).get("environments", [])
-    branches = user_branches + [branch for branch in all_branches if branch not in user_branches]
-
-    return [branch for branch in branches if branch.get("main") == current_main_workspace["id"]]
-
-
 class AliasedGroup(click.Group):
     def get_command(self, ctx, cmd_name):
         # Step one: built-in commands as normal
@@ -320,16 +307,15 @@ def getenv_bool(key: str, default: bool) -> bool:
     return v.lower() == "true" or v == "1"
 
 
-def _get_tb_client(token: str, host: str, semver: Optional[str] = None) -> TinyB:
+def _get_tb_client(token: str, host: str) -> TinyB:
     disable_ssl: bool = getenv_bool("TB_DISABLE_SSL_CHECKS", False)
-    return TinyB(token, host, version=VERSION, disable_ssl_checks=disable_ssl, send_telemetry=True, semver=semver)
+    return TinyB(token, host, version=VERSION, disable_ssl_checks=disable_ssl, send_telemetry=True)
 
 
 def create_tb_client(ctx: Context) -> TinyB:
     token = ctx.ensure_object(dict)["config"].get("token", "")
     host = ctx.ensure_object(dict)["config"].get("host", DEFAULT_API_HOST)
-    semver = ctx.ensure_object(dict)["config"].get("semver", "")
-    return _get_tb_client(token, host, semver=semver)
+    return _get_tb_client(token, host)
 
 
 async def _analyze(filename: str, client: TinyB, format: str, connector: Optional["Connector"] = None):
@@ -776,77 +762,6 @@ async def create_workspace_interactive(
     await create_workspace_non_interactive(ctx, workspace_name, starterkit, user_token, fork)  # type: ignore
 
 
-async def create_workspace_branch(
-    branch_name: Optional[str],
-    last_partition: bool,
-    all: bool,
-    ignore_datasources: Optional[List[str]],
-    wait: Optional[bool],
-) -> None:
-    """
-    Creates a workspace branch
-    """
-    config = CLIConfig.get_project_config()
-    _ = await try_update_config_with_remote(config)
-
-    try:
-        workspace = await get_current_workspace(config)
-        if not workspace:
-            raise CLIWorkspaceException(FeedbackManager.error_workspace())
-
-        if not branch_name:
-            click.echo(FeedbackManager.info_workspace_branch_create_greeting())
-            default_name = f"{workspace['name']}_{uuid.uuid4().hex[0:4]}"
-            branch_name = click.prompt("\Branch name", default=default_name, err=True, type=str)
-        assert isinstance(branch_name, str)
-
-        response = await config.get_client().create_workspace_branch(
-            branch_name,
-            last_partition,
-            all,
-            ignore_datasources,
-        )
-        assert isinstance(response, dict)
-
-        is_job: bool = "job" in response
-        is_summary: bool = "partitions" in response
-
-        if not is_job and not is_summary:
-            raise CLIException(str(response))
-
-        if all and not is_job:
-            raise CLIException(str(response))
-
-        click.echo(
-            FeedbackManager.success_workspace_branch_created(workspace_name=workspace["name"], branch_name=branch_name)
-        )
-
-        job_id: Optional[str] = None
-
-        if is_job:
-            job_id = response["job"]["job_id"]
-            job_url = response["job"]["job_url"]
-            click.echo(FeedbackManager.info_data_branch_job_url(url=job_url))
-
-        if wait and is_job:
-            assert isinstance(job_id, str)
-
-            # Await the job to finish and get the result dict
-            job_response = await wait_job(config.get_client(), job_id, job_url, "Branch creation")
-            if job_response is None:
-                raise CLIException(f"Empty job API response (job_id: {job_id}, job_url: {job_url})")
-            else:
-                response = job_response.get("result", {})
-                is_summary = "partitions" in response
-
-        await switch_workspace(config, branch_name, only_environments=True)
-        if is_summary and (bool(last_partition) or bool(all)):
-            await print_data_branch_summary(config.get_client(), None, response)
-
-    except Exception as e:
-        raise CLIException(FeedbackManager.error_exception(error=str(e)))
-
-
 async def print_data_branch_summary(client, job_id, response=None):
     response = await client.job(job_id) if job_id else response or {"partitions": []}
     columns = ["Data Source", "Partition", "Status", "Error"]
@@ -1327,13 +1242,10 @@ def _get_setting_value(connection, setting, sensitive_settings):
     return connection.get(setting, "")
 
 
-async def switch_workspace(config: CLIConfig, workspace_name_or_id: str, only_environments: bool = False) -> None:
+async def switch_workspace(config: CLIConfig, workspace_name_or_id: str) -> None:
     try:
-        if only_environments:
-            workspaces = await get_current_workspace_branches(config)
-        else:
-            response = await config.get_client().user_workspaces()
-            workspaces = response["workspaces"]
+        response = await config.get_client().user_workspaces()
+        workspaces = response["workspaces"]
 
         workspace = next(
             (
@@ -1345,10 +1257,7 @@ async def switch_workspace(config: CLIConfig, workspace_name_or_id: str, only_en
         )
 
         if not workspace:
-            if only_environments:
-                raise CLIException(FeedbackManager.error_branch(branch=workspace_name_or_id))
-            else:
-                raise CLIException(FeedbackManager.error_workspace(workspace=workspace_name_or_id))
+            raise CLIException(FeedbackManager.error_workspace(workspace=workspace_name_or_id))
 
         config.set_token(workspace["token"])
         config.set_token_for_host(workspace["token"], config.get_host())

tinybird/tb/modules/config.py

@@ -72,7 +72,6 @@ class CLIConfig:
         "token": "TB_TOKEN",
         "user_token": "TB_USER_TOKEN",
         "host": "TB_HOST",
-        "semver": "TB_SEMVER",
     }
 
     DEFAULTS: Dict[str, str] = {"host": DEFAULT_API_HOST if not FeatureFlags.is_localhost() else DEFAULT_LOCALHOST}
@@ -178,15 +177,6 @@ class CLIConfig:
         except KeyError:
             return None
 
-    def set_semver(self, semver: Optional[str]) -> None:
-        self["semver"] = semver
-
-    def get_semver(self) -> Optional[str]:
-        try:
-            return self["semver"]
-        except KeyError:
-            return None
-
     def set_token_for_host(self, token: Optional[str], host: Optional[str]) -> None:
         """Sets the token for the specified host.