tinybird-cli 5.8.0.dev1__tar.gz → 5.8.0.dev3__tar.gz

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird-cli
-Version: 5.8.0.dev1
+Version: 5.8.0.dev3
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird
@@ -18,6 +18,16 @@ The Tinybird command-line tool allows you to use all the Tinybird functionality
 Changelog
 ----------
 
+5.8.0.dev3
+**********
+
+- `Added` `tb datasource scheduling` commands to manage the scheduling of a Data Source
+
+5.8.0.dev2
+***********
+
+- `Added` support to `TAGS` in `tb fmt`.
+
 5.8.0.dev1
 ***********
 

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/__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__ = '5.8.0.dev1'
-__revision__ = 'a3056db'
+__version__ = '5.8.0.dev3'
+__revision__ = '43074f3'

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/client.py

@@ -474,6 +474,24 @@ class TinyB(object):
     async def datasource_sync(self, datasource_id: str):
         return await self._req(f"/v0/datasources/{datasource_id}/scheduling/runs", method="POST", data="")
 
+    async def datasource_scheduling_state(self, datasource_id: str):
+        response = await self._req(f"/v0/datasources/{datasource_id}/scheduling/state", method="GET")
+        return response["state"]
+
+    async def datasource_scheduling_pause(self, datasource_id: str):
+        return await self._req(
+            f"/v0/datasources/{datasource_id}/scheduling/state",
+            method="PUT",
+            data='{"state": "paused"}',
+        )
+
+    async def datasource_scheduling_resume(self, datasource_id: str):
+        return await self._req(
+            f"/v0/datasources/{datasource_id}/scheduling/state",
+            method="PUT",
+            data='{"state": "running"}',
+        )
+
     async def datasource_exchange(self, datasource_a: str, datasource_b: str):
         payload = {"datasource_a": datasource_a, "datasource_b": datasource_b}
         return await self._req("/v0/datasources/exchange", method="POST", data=payload)

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/datafile.py

@@ -904,30 +904,31 @@ def eval_var(s: str, skip: bool = False) -> str:
     return Template(s).safe_substitute(os.environ)
 
 
-def parse_tags(tags: str) -> Tuple[Dict[str, str], List[str]]:
+def parse_tags(tags: str) -> Tuple[str, List[str]]:
     """
     Parses a string of tags into:
-    - kv_tags: a dictionary of key-value tags: the previous tags we have for operational purposes. They
-        have the format key=value&key2=value2 (with_staging=true&with_last_date=true)
+    - kv_tags: a string of key-value tags: the previous tags we have for operational purposes. It
+        has the format key=value&key2=value2 (with_staging=true&with_last_date=true)
     - filtering_tags: a list of tags that are used for filtering.
 
     Example: "with_staging=true&with_last_date=true,billing,stats" ->
         kv_tags = {"with_staging": "true", "with_last_date": "true"}
         filtering_tags = ["billing", "stats"]
     """
-    kv_tags = {}
+    kv_tags = []
     filtering_tags = []
 
     entries = tags.split(",")
     for entry in entries:
         trimmed_entry = entry.strip()
         if "=" in trimmed_entry:
-            the_tags = {k: v[0] for k, v in urllib.parse.parse_qs(trimmed_entry).items()}
-            kv_tags.update(the_tags)
+            kv_tags.append(trimmed_entry)
         else:
             filtering_tags.append(trimmed_entry)
 
-    return kv_tags, filtering_tags
+    all_kv_tags = "&".join(kv_tags)
+
+    return all_kv_tags, filtering_tags
 
 
 def parse(
@@ -1128,14 +1129,19 @@ def parse(
         return _f
 
     def tags(*args: str, **kwargs: Any) -> None:
+        raw_tags = _unquote((" ".join(args)).strip())
+        operational_tags, filtering_tags = parse_tags(raw_tags)
+
         # Pipe nodes or Data Sources
-        if parser_state.current_node:
-            assign_node_var("tags")(*args, **kwargs)
-        else:
-            # Pipes, at pipe level
-            raw_tags = _unquote((" ".join(args)).strip())
-            _, filtering_tags = parse_tags(raw_tags)
-            doc.filtering_tags = filtering_tags
+        if parser_state.current_node and operational_tags:
+            operational_tags_args = (operational_tags,)
+            assign_node_var("tags")(*operational_tags_args, **kwargs)
+
+        if filtering_tags:
+            if doc.filtering_tags is None:
+                doc.filtering_tags = filtering_tags
+            else:
+                doc.filtering_tags += filtering_tags
 
     cmds = {
         "from": assign("from"),
@@ -1552,9 +1558,8 @@ async def process_file(
             del params["format"]
 
         if "tags" in node:
-            tags, filtering_tags = parse_tags(node["tags"])
+            tags = {k: v[0] for k, v in urllib.parse.parse_qs(node["tags"]).items()}
             params.update(tags)
-            doc.filtering_tags = filtering_tags
 
         resources: List[Dict[str, Any]] = []
 
@@ -1654,7 +1659,7 @@ async def process_file(
                 sql = re.sub("([\t \\n']+|^)" + old + "([\t \\n'\\)]+|$)", "\\1" + new + "\\2", sql)
 
             if "tags" in node:
-                tags, _ = parse_tags(node["tags"])  # Only interested in the "old" tags
+                tags = {k: v[0] for k, v in urllib.parse.parse_qs(node["tags"]).items()}
                 params.update(tags)
 
             nodes.append(
@@ -4817,19 +4822,20 @@ async def format_datasource(
         if for_deploy_diff:
             format_description(file_parts, doc)
         format_tokens(file_parts, doc)
+        format_tags(file_parts, doc)
         format_schema(file_parts, doc.nodes[0])
         format_indices(file_parts, doc.nodes[0])
         await format_engine(file_parts, doc.nodes[0], only_ttl=True if not for_deploy_diff else False, client=client)
         if for_deploy_diff:
             format_import_settings(file_parts, doc.nodes[0])
         format_shared_with(file_parts, doc)
-
     else:
         format_sources(file_parts, doc)
         format_maintainer(file_parts, doc)
         format_version(file_parts, doc)
         format_description(file_parts, doc)
         format_tokens(file_parts, doc)
+        format_tags(file_parts, doc)
         format_schema(file_parts, doc.nodes[0])
         format_indices(file_parts, doc.nodes[0])
         await format_engine(file_parts, doc.nodes[0])
@@ -4905,6 +4911,14 @@ def format_shared_with(file_parts: List[str], doc: Datafile) -> List[str]:
     return file_parts
 
 
+def format_tags(file_parts: List[str], doc: Datafile) -> List[str]:
+    if doc.filtering_tags:
+        file_parts.append(f'TAGS {", ".join(doc.filtering_tags)}')
+        file_parts.append(DATAFILE_NEW_LINE)
+        file_parts.append(DATAFILE_NEW_LINE)
+    return file_parts
+
+
 async def format_engine(
     file_parts: List[str], node: Dict[str, Any], only_ttl: bool = False, client: Optional[TinyB] = None
 ) -> List[str]:
@@ -5041,6 +5055,7 @@ async def format_pipe(
     format_version(file_parts, doc)
     format_description(file_parts, doc)
     format_tokens(file_parts, doc)
+    format_tags(file_parts, doc)
     if doc.includes and not unroll_includes:
         for k in doc.includes:
             # We filter only the include files as we currently have 2 items for each include

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/feedback_manager.py

@@ -157,6 +157,15 @@ class FeedbackManager:
     error_creating_copy_job = error_message("Failed creating copy job: {error}")
     error_pausing_copy_pipe = error_message("Failed pausing copy pipe: {error}")
     error_resuming_copy_pipe = error_message("Failed resuming copy pipe: {error}")
+    error_pausing_datasource_scheduling = error_message(
+        "Failed pausing scheduling for Data Source '{datasource}': {error}"
+    )
+    error_resuming_datasource_scheduling = error_message(
+        "Failed resuming scheduling for Data Source '{datasource}': {error}"
+    )
+    error_datasource_scheduling_state = error_message(
+        "Failed requesting scheduling state for Data Source '{datasource}': {error}"
+    )
     error_creating_pipe = error_message("Failed creating pipe {error}")
     error_creating_sink_job = error_message("Failed creating sink job: {error}")
     error_running_on_demand_sink_job = error_message("Failed running on-demand sink job: {error}")
@@ -681,6 +690,9 @@ Ready? """
     info_datasource_title = print_message("** {title}", bcolors.BOLD)
     info_datasource_row = info_message("{row}")
     info_datasource_delete_rows_job_url = info_message("** Delete rows job url {url}")
+    info_datasource_scheduling_state = info_message("** Scheduling state for Data Source '{datasource}': {state}")
+    info_datasource_scheduling_pause = info_message("** Pausing scheduling...")
+    info_datasource_scheduling_resume = info_message("** Resuming scheduling...")
     info_pipes = info_message("** Pipes:")
     info_pipe_name = info_message("** - {pipe}")
     info_using_node = print_message("** Using last node {node} as endpoint")
@@ -933,6 +945,8 @@ Ready? """
     success_datasource_unshared = success_message(
         "** The Data Source {datasource} has been correctly unshared from {workspace}"
     )
+    success_datasource_scheduling_resumed = success_message("""** Scheduling resumed for Data Source '{datasource}'""")
+    success_datasource_scheduling_paused = success_message("""** Scheduling paused for Data Source '{datasource}'""")
     success_connection_created = success_message("** Connection {id} created successfully!")
 
     # TODO: Update the message when the .env feature is implemented

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/sql_template.py

@@ -386,14 +386,14 @@ def array_type(types):  # noqa: C901
             for i, t in enumerate(list_values):
                 if _type in testers:
                     if testers[_type](str(t)):
-                        values.append(expression_wrapper(types[_type](t), f"{x}[{i}]"))
+                        values.append(expression_wrapper(types[_type](t), str(t)))
                     else:
                         raise SQLTemplateException(
                             f"Error validating {x}[{i}]({t}) to type {_type}",
                             documentation="/cli/advanced-templates.html",
                         )
                 else:
-                    values.append(expression_wrapper(types.get(_type, lambda x: x)(t), f"{x}[{i}]"))
+                    values.append(expression_wrapper(types.get(_type, lambda x: x)(t), str(t)))
             return Expression(f"[{','.join(map(str, values))}]")
         except AttributeError as e:
             logging.warning(f"AttributeError on Array: {e}")
@@ -1314,8 +1314,9 @@ def expression_wrapper(x, name, escape_arrays: bool = False):
     elif isinstance(x, Comment):
         return "-- {x} \n"
     if x is None:
+        truncated_name = name[:20] + "..." if len(name) > 20 else name
         raise SQLTemplateException(
-            f'expression "{name}" evaluated to null', documentation="/cli/advanced-templates.html"
+            f'expression "{truncated_name}" evaluated to null', documentation="/cli/advanced-templates.html"
         )
     if isinstance(x, list) and escape_arrays:
         logging.warning(f"expression_wrapper -> list :{x}:")
@@ -1992,6 +1993,14 @@ def render_sql_template(
     Traceback (most recent call last):
     ...
     tinybird.sql_template.SQLTemplateException: Template Syntax Error: expression "test" evaluated to null
+    >>> render_sql_template("SELECT {{testisasuperlongthingandwedontwanttoreturnthefullthing}}", {'token':'testing'})
+    Traceback (most recent call last):
+    ...
+    tinybird.sql_template.SQLTemplateException: Template Syntax Error: expression "testisasuperlongthin..." evaluated to null
+    >>> render_sql_template("SELECT {{ Array(embedding, 'Float32') }}", {'token':'testing', 'embedding': '1,2,3,4, null'})
+    Traceback (most recent call last):
+    ...
+    tinybird.sql_template.SQLTemplateException: Template Syntax Error: Error validating 1,2,3,4, null[4]( null) to type Float32
     >>> render_sql_template('{% if test %}SELECT 1{% else %} select 2 {% end %}')
     (' select 2 ', {}, [])
     >>> render_sql_template('{% if Int32(test, 1) %}SELECT 1{% else %} select 2 {% end %}')

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/tb_cli.py

@@ -10,6 +10,7 @@ import tinybird.tb_cli_modules.cli
 import tinybird.tb_cli_modules.common
 import tinybird.tb_cli_modules.connection
 import tinybird.tb_cli_modules.datasource
+import tinybird.tb_cli_modules.fmt
 import tinybird.tb_cli_modules.job
 import tinybird.tb_cli_modules.pipe
 import tinybird.tb_cli_modules.tag

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/tb_cli_modules/cli.py

@@ -3,7 +3,6 @@
 # - If it makes sense and only when strictly necessary, you can create utility functions in this file.
 # - But please, **do not** interleave utility functions and command definitions.
 
-import difflib
 import json
 import logging
 import os
@@ -36,21 +35,16 @@ from tinybird.datafile import (
     Datafile,
     ParseException,
     build_graph,
-    color_diff,
     create_release,
     diff_command,
     folder_pull,
     folder_push,
-    format_datasource,
-    format_pipe,
     get_project_filenames,
     get_resource_versions,
     has_internal_datafiles,
-    is_file_a_datasource,
     parse_datasource,
     parse_pipe,
     parse_token,
-    peek,
     wait_job,
 )
 from tinybird.feedback_manager import FeedbackManager
@@ -753,84 +747,6 @@ async def dependencies(
         raise CLIException(FeedbackManager.error_partial_replace_cant_be_executed(datasource=datasource))
 
 
-@cli.command()
-@click.argument("filenames", type=click.Path(exists=True), nargs=-1, required=True)
-@click.option(
-    "--line-length",
-    is_flag=False,
-    default=100,
-    help="A number indicating the maximum characters per line in the node SQL, lines will be splitted based on the SQL syntax and the number of characters passed as a parameter",
-)
-@click.option("--dry-run", is_flag=True, default=False, help="Don't ask to override the local file")
-@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation to overwrite the local file")
-@click.option(
-    "--diff",
-    is_flag=True,
-    default=False,
-    help="Formats local file, prints the diff and exits 1 if different, 0 if equal",
-)
-@click.pass_context
-@coro
-async def fmt(
-    ctx: Context, filenames: List[str], line_length: int, dry_run: bool, yes: bool, diff: bool
-) -> Optional[str]:
-    """
-    Formats a .datasource, .pipe or .incl file
-
-    This command removes comments starting with # from the file, use DESCRIPTION instead.
-
-    The format command tries to parse the datafile so syntax errors might rise.
-
-    .incl files must contain a NODE definition
-    """
-
-    result = ""
-    failed = []
-    for filename in filenames:
-        if not diff:
-            click.echo(filename)
-        extensions = Path(filename).suffixes
-        if is_file_a_datasource(filename):
-            result = await format_datasource(filename, skip_eval=True)
-        elif (".pipe" in extensions) or (".incl" in extensions):
-            result = await format_pipe(filename, line_length, skip_eval=True)
-        else:
-            click.echo("Unsupported file type. Supported files types are: .pipe, .incl and .datasource")
-            return None
-
-        if diff:
-            result = result.rstrip("\n")
-            lines_fmt = [f"{line}\n" for line in result.split("\n")]
-            with open(filename, "r") as file:
-                lines_file = file.readlines()
-            diff_result = difflib.unified_diff(
-                lines_file, lines_fmt, fromfile=f"{Path(filename).name} local", tofile="fmt datafile"
-            )
-            diff_result = color_diff(diff_result)
-            not_empty, diff_lines = peek(diff_result)
-            if not_empty:
-                sys.stdout.writelines(diff_lines)
-                failed.append(filename)
-                click.echo("")
-        else:
-            click.echo(result)
-            if dry_run:
-                return None
-
-            if yes or click.confirm(FeedbackManager.prompt_override_local_file(name=filename)):
-                with open(f"{filename}", "w") as file:
-                    file.write(result)
-
-                click.echo(FeedbackManager.success_generated_local_file(file=filename))
-
-    if len(failed):
-        click.echo(FeedbackManager.error_failed_to_format_files(number=len(failed)))
-        for f in failed:
-            click.echo(f"tb fmt {f} --yes")
-        sys.exit(1)
-    return result
-
-
 @cli.command(
     name="diff",
     short_help="Diffs local datafiles to the corresponding remote files in the workspace. For the case of .datasource files it just diffs VERSION and SCHEMA, since ENGINE, KAFKA or other metadata is considered immutable.",

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird/tb_cli_modules/datasource.py

@@ -805,3 +805,65 @@ async def datasource_copy_from_main(
     if wait:
         base_msg = "Copy from Main Workspace" if sql_from_main else f"Copy from {sql}"
         await wait_job(client, job_id, job_url, f"{base_msg} to {datasource_name}")
+
+
+@datasource.group(name="scheduling")
+@click.pass_context
+def datasource_scheduling(ctx: Context) -> None:
+    """Data Source scheduling commands."""
+
+
+@datasource_scheduling.command(name="state")
+@click.argument("datasource_name")
+@click.pass_context
+@coro
+async def datasource_scheduling_state(ctx: Context, datasource_name: str) -> None:
+    """Get the scheduling state of a Data Source."""
+    client: TinyB = ctx.obj["client"]
+    try:
+        state = await client.datasource_scheduling_state(datasource_name)
+        click.echo(FeedbackManager.info_datasource_scheduling_state(datasource=datasource_name, state=state))
+    except Exception as e:
+        raise CLIDatasourceException(
+            FeedbackManager.error_datasource_scheduling_state(datasource=datasource_name, error=e)
+        )
+
+
+@datasource_scheduling.command(name="pause")
+@click.argument("datasource_name")
+@click.pass_context
+@coro
+async def datasource_scheduling_pause(ctx: Context, datasource_name: str) -> None:
+    """Pause the scheduling of a Data Source."""
+
+    click.echo(FeedbackManager.info_datasource_scheduling_pause())
+    client: TinyB = ctx.ensure_object(dict)["client"]
+
+    try:
+        await client.datasource_scheduling_pause(datasource_name)
+        click.echo(FeedbackManager.success_datasource_scheduling_paused(datasource=datasource_name))
+
+    except Exception as e:
+        raise CLIDatasourceException(
+            FeedbackManager.error_pausing_datasource_scheduling(datasource=datasource_name, error=e)
+        )
+
+
+@datasource_scheduling.command(name="resume")
+@click.argument("datasource_name")
+@click.pass_context
+@coro
+async def datasource_scheduling_resume(ctx: Context, datasource_name: str) -> None:
+    """Resume the scheduling of a Data Source."""
+
+    click.echo(FeedbackManager.info_datasource_scheduling_resume())
+    client: TinyB = ctx.ensure_object(dict)["client"]
+
+    try:
+        await client.datasource_scheduling_resume(datasource_name)
+        click.echo(FeedbackManager.success_datasource_scheduling_resumed(datasource=datasource_name))
+
+    except Exception as e:
+        raise CLIDatasourceException(
+            FeedbackManager.error_resuming_datasource_scheduling(datasource=datasource_name, error=e)
+        )

tinybird-cli-5.8.0.dev3/tinybird/tb_cli_modules/fmt.py

@@ -0,0 +1,90 @@
+import difflib
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import click
+from click import Context
+
+from tinybird.datafile import color_diff, format_datasource, format_pipe, is_file_a_datasource, peek
+from tinybird.feedback_manager import FeedbackManager
+from tinybird.tb_cli_modules.cli import cli
+from tinybird.tb_cli_modules.common import coro
+
+
+@cli.command()
+@click.argument("filenames", type=click.Path(exists=True), nargs=-1, required=True)
+@click.option(
+    "--line-length",
+    is_flag=False,
+    default=100,
+    help="A number indicating the maximum characters per line in the node SQL, lines will be splitted based on the SQL syntax and the number of characters passed as a parameter",
+)
+@click.option("--dry-run", is_flag=True, default=False, help="Don't ask to override the local file")
+@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation to overwrite the local file")
+@click.option(
+    "--diff",
+    is_flag=True,
+    default=False,
+    help="Formats local file, prints the diff and exits 1 if different, 0 if equal",
+)
+@click.pass_context
+@coro
+async def fmt(
+    ctx: Context, filenames: List[str], line_length: int, dry_run: bool, yes: bool, diff: bool
+) -> Optional[str]:
+    """
+    Formats a .datasource, .pipe or .incl file
+
+    This command removes comments starting with # from the file, use DESCRIPTION instead.
+
+    The format command tries to parse the datafile so syntax errors might rise.
+
+    .incl files must contain a NODE definition
+    """
+
+    result = ""
+    failed = []
+    for filename in filenames:
+        if not diff:
+            click.echo(filename)
+        extensions = Path(filename).suffixes
+        if is_file_a_datasource(filename):
+            result = await format_datasource(filename, skip_eval=True)
+        elif (".pipe" in extensions) or (".incl" in extensions):
+            result = await format_pipe(filename, line_length, skip_eval=True)
+        else:
+            click.echo("Unsupported file type. Supported files types are: .pipe, .incl and .datasource")
+            return None
+
+        if diff:
+            result = result.rstrip("\n")
+            lines_fmt = [f"{line}\n" for line in result.split("\n")]
+            with open(filename, "r") as file:
+                lines_file = file.readlines()
+            diff_result = difflib.unified_diff(
+                lines_file, lines_fmt, fromfile=f"{Path(filename).name} local", tofile="fmt datafile"
+            )
+            diff_result = color_diff(diff_result)
+            not_empty, diff_lines = peek(diff_result)
+            if not_empty:
+                sys.stdout.writelines(diff_lines)
+                failed.append(filename)
+                click.echo("")
+        else:
+            click.echo(result)
+            if dry_run:
+                return None
+
+            if yes or click.confirm(FeedbackManager.prompt_override_local_file(name=filename)):
+                with open(f"{filename}", "w") as file:
+                    file.write(result)
+
+                click.echo(FeedbackManager.success_generated_local_file(file=filename))
+
+    if len(failed):
+        click.echo(FeedbackManager.error_failed_to_format_files(number=len(failed)))
+        for f in failed:
+            click.echo(f"tb fmt {f} --yes")
+        sys.exit(1)
+    return result

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird-cli
-Version: 5.8.0.dev1
+Version: 5.8.0.dev3
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird
@@ -18,6 +18,16 @@ The Tinybird command-line tool allows you to use all the Tinybird functionality
 Changelog
 ----------
 
+5.8.0.dev3
+**********
+
+- `Added` `tb datasource scheduling` commands to manage the scheduling of a Data Source
+
+5.8.0.dev2
+***********
+
+- `Added` support to `TAGS` in `tb fmt`.
+
 5.8.0.dev1
 ***********
 

{tinybird-cli-5.8.0.dev1 → tinybird-cli-5.8.0.dev3}/tinybird_cli.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tinybird/tb_cli_modules/config.py
 tinybird/tb_cli_modules/connection.py
 tinybird/tb_cli_modules/datasource.py
 tinybird/tb_cli_modules/exceptions.py
+tinybird/tb_cli_modules/fmt.py
 tinybird/tb_cli_modules/job.py
 tinybird/tb_cli_modules/pipe.py
 tinybird/tb_cli_modules/regions.py