tinybird 0.0.1.dev5__py3-none-any.whl → 0.0.1.dev6__py3-none-any.whl

tinybird/{tb_cli_modules → tb/modules}/tag.py

@@ -4,8 +4,8 @@ import click
 from click import Context
 
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import coro, echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import coro, echo_safe_humanfriendly_tables_format_smart_table
 
 
 @cli.group()

tinybird/tb/modules/telemetry.py

@@ -0,0 +1,310 @@
+import functools
+import json
+import os
+import platform
+import re
+import sys
+import threading
+import uuid
+from copy import deepcopy
+from datetime import datetime
+from typing import Any, Callable, Dict, List, Optional, Tuple
+from urllib.parse import urlencode
+
+import requests
+
+from tinybird.config import CURRENT_VERSION
+
+TELEMETRY_TIMEOUT: int = 1
+TELEMETRY_DATASOURCE: str = "tb_cli_telemetry"
+
+
+def get_ci_product_name() -> Optional[str]:
+    if _is_env_true("TB_DISABLE_CI_DETECTION"):
+        return None
+
+    CI_CHECKS: List[Tuple[str, Callable[[], bool]]] = [
+        ("Azure pipelines", lambda: _is_env_true("TF_BUILD")),
+        ("GitHub Actions", lambda: _is_env_true("GITHUB_ACTIONS")),
+        ("Appveyor", lambda: _is_env_true("APPVEYOR")),
+        ("Travis CI", lambda: _is_env_true("TRAVIS")),
+        ("Circle CI", lambda: _is_env_true("CIRCLECI")),
+        ("Amazon Web Services CodeBuild", lambda: _is_env_present(["CODEBUILD_BUILD_ID", "AWS_REGION"])),
+        ("Jenkins", lambda: _is_env_present(["BUILD_ID", "BUILD_URL"])),
+        ("Google Cloud Build", lambda: _is_env_present(["BUILD_ID", "PROJECT_ID"])),
+        ("TeamCity", lambda: _is_env_present(["TEAMCITY_VERSION"])),
+        ("JetBrains Space", lambda: _is_env_present(["JB_SPACE_API_URL"])),
+        ("Generic CI", lambda: _is_env_true("CI")),
+    ]
+
+    return next((check[0] for check in CI_CHECKS if check[1]()), None)
+
+
+def is_ci_environment() -> bool:
+    ci_product: Optional[str] = get_ci_product_name()
+    return ci_product is not None
+
+
+def silence_errors(f: Callable) -> Callable:
+    """Decorator to silence all errors in the decorated
+    function.
+    """
+
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs) -> Any:
+        try:
+            return f(*args, **kwargs)
+        except Exception:
+            return None
+
+    return wrapper
+
+
+def _is_env_true(env_var: str) -> bool:
+    """Checks if `env_var` is `true` or `1`."""
+    return os.getenv(env_var, "").lower() in ("true", "1")
+
+
+def _is_env_present(envs: List[str]) -> bool:
+    """Checks if all of the variables passed in `envs`
+    are defined (ie: not empty)
+    """
+    return all(os.getenv(env_var, None) is not None for env_var in envs)
+
+
+def _hide_tokens(text: str) -> str:
+    """Cuts any token in a way that they get unusable if leaked,
+    but we still can use them for debugging if needed.
+    """
+    return re.sub(r"p\.ey[A-Za-z0-9-_\.]+", lambda s: f"{s[0][:10]}...{s[0][-10:]}", text)
+
+
+class TelemetryHelper:
+    def __init__(self, tb_host: Optional[str] = None, max_enqueued_events: int = 5) -> None:
+        self.tb_host = tb_host or os.getenv("TB_CLI_TELEMETRY_HOST", "https://api.tinybird.co")
+        self.max_enqueued_events: int = max_enqueued_events
+
+        self.enabled: bool = True
+        self.events: List[Dict[str, Any]] = []
+        self.telemetry_token: Optional[str] = None
+
+        run_id = str(uuid.uuid4())
+
+        self._defaults: Dict[str, Any] = {
+            # Per-event values
+            "event": "<the event>",
+            "event_data": "<the event data>",
+            "timestamp": "<the timestamp>",
+            # Static values
+            "run_id": run_id,
+        }
+
+        self._threads: List[threading.Thread] = []
+        self.log(f"Telemetry initialized with run_id: {run_id}")
+
+    @silence_errors
+    def add_event(self, event: str, event_data: Dict[str, Any]) -> None:
+        if not self.enabled:
+            self.log("Helper is disabled")
+            return
+
+        if "x.y.z" in CURRENT_VERSION and not _is_env_true("TB_CLI_TELEMETRY_SEND_IN_LOCAL"):
+            self.log("Not sending events in local development mode")
+            return
+
+        # Let's save deep copies to not interfere with original objects
+        event_dict: Dict[str, Any] = deepcopy(self._defaults)
+        event_dict["event"] = event
+        event_dict["event_data"] = json.dumps(event_data)
+        event_dict["timestamp"] = datetime.utcnow().isoformat()
+
+        self.events.append(event_dict)
+        if len(self.events) >= self.max_enqueued_events:
+            self.flush()
+
+    @silence_errors
+    def flush(self, wait: bool = False) -> None:
+        if self.enabled and len(self.events) > 0:
+            # Take the ownership for the pending events.
+            #
+            # We need this because the proper flush() is done in
+            # a thread to avoid blocking  the user and we could send
+            # the same event twice if we maintain the same list after
+            # during the sending.
+
+            events: List[Dict[str, Any]] = self.events
+            self.events = []
+
+            self.log(f"Flusing {len(events)} events in a new thread...")
+            thread: threading.Thread = threading.Thread(target=self._flush, args=[events])
+            self._threads.append(thread)
+            thread.start()
+
+        if wait:
+            for t in self._threads:
+                t.join()
+                if t.is_alive():
+                    self.log(f"Couldn't wait for the end of the thread {t.name}")
+            self._threads.clear()
+
+    @silence_errors
+    def _flush(self, events: List[Dict[str, Any]]) -> None:
+        """Actual flush. This is where we use HFI to ingest events."""
+
+        timeout: int
+        try:
+            timeout = int(os.getenv("TB_CLI_TELEMETRY_TIMEOUT", TELEMETRY_TIMEOUT))
+            timeout = max(TELEMETRY_TIMEOUT, timeout)
+        except ValueError:
+            timeout = TELEMETRY_TIMEOUT
+
+        if not self.telemetry_token:
+            self.telemetry_token = os.getenv("TB_CLI_TELEMETRY_TOKEN")
+            if self.telemetry_token:
+                self.log("Got telemetry token from environment TB_CLI_TELEMETRY_TOKEN")
+
+        with requests.Session() as session:
+            if not self.telemetry_token:
+                url: str = f"{self.tb_host}/v0/regions"
+                self.log(f"Requesting token from {url}...")
+                try:
+                    r = session.get(url, timeout=timeout)
+                    regions: List[Dict[str, Any]] = json.loads(r.content.decode())["regions"]
+                    self.telemetry_token = next(
+                        (r.get("telemetry_token", None) for r in regions if r["api_host"] == self.tb_host), None
+                    )
+                    if self.telemetry_token:
+                        self.log(f"Got telemetry token from {url}")
+                except requests.exceptions.Timeout:
+                    self.log(f"Disabling due to timeout after {timeout} seconds")
+                    self.enabled = False
+                    return
+                except Exception as ex:
+                    self.log(str(ex))
+
+            if not self.telemetry_token:
+                self.log("Disabling due to lack of token")
+                self.enabled = False
+                return
+
+            self.log(f"token={self.telemetry_token}")
+
+            data: str = _hide_tokens("\n".join(json.dumps(e) for e in events))
+
+            # Note we don't use `wait` as this telemetry isn't a critical
+            # operation to support and we don't want to generate overhead
+            params: Dict[str, Any] = {"name": TELEMETRY_DATASOURCE, "token": self.telemetry_token}
+            url = f"{self.tb_host}/v0/events?{urlencode(params)}"
+
+            try:
+                self.log(f"Sending data to {url}...")
+                r = session.post(url, data=data, timeout=timeout)
+            except requests.exceptions.Timeout:
+                self.log(f"Disabling due to timeout after {timeout} seconds")
+                self.enabled = False
+                return
+
+            self.log(f"Received status {r.status_code}: {r.text}")
+
+            if r.status_code == 200 or r.status_code == 202:
+                self.log(f"Successfully sent {len(events)} events to {self.tb_host}")
+                self.events.clear()
+                return
+
+            if r.status_code in (403, 404):
+                self.log(f"Disabling due to {r.status_code} errors")
+                self.enabled = False
+                return
+
+            if r.status_code >= 500:
+                self.log(f"Disabling telemetry and discarding {len(events)} events")
+                self.enabled = False
+
+    @silence_errors
+    def log(self, msg: str) -> None:
+        """Internal logging function to help with development and debugging."""
+        if not _is_env_true("TB_CLI_TELEMETRY_DEBUG"):
+            return
+        print(f"> Telemetry: {msg}")  # noqa: T201
+
+
+_helper_instance: Optional[TelemetryHelper] = None
+
+
+@silence_errors
+def init_telemetry() -> None:
+    """Setups the telemetry helper with the config present in `config`.
+    If no config is provided, it tries to get it from the passed Click context.
+
+    We need to call this method any time we suspect the config changes any value.
+    """
+
+    telemetry = _get_helper()
+    if telemetry:
+        telemetry.log("Initialized")
+
+
+@silence_errors
+def add_telemetry_event(event: str, **kw_event_data: Any) -> None:
+    """Adds a new telemetry event."""
+
+    telemetry = _get_helper()
+    if not telemetry:
+        return
+
+    try:
+        telemetry.add_event(event, dict(**kw_event_data))
+    except Exception as ex:
+        telemetry.log(str(ex))
+
+
+@silence_errors
+def add_telemetry_sysinfo_event() -> None:
+    """Collects system info and sends a `system_info` event
+    with the data.
+    """
+
+    ci_product: Optional[str] = get_ci_product_name()
+
+    add_telemetry_event(
+        "system_info",
+        platform=platform.platform(),
+        system=platform.system(),
+        arch=platform.machine(),
+        processor=platform.processor(),
+        python_runtime=platform.python_implementation(),
+        python_version=platform.python_version(),
+        is_ci=ci_product is not None,
+        ci_product=ci_product,
+        cli_version=CURRENT_VERSION,
+        cli_args=sys.argv[1:] if len(sys.argv) > 1 else [],
+    )
+
+
+@silence_errors
+def flush_telemetry(wait: bool = False) -> None:
+    """Flushes all pending telemetry events."""
+
+    telemetry = _get_helper()
+    if not telemetry:
+        return
+
+    try:
+        telemetry.flush(wait=wait)
+    except Exception as ex:
+        telemetry.log(str(ex))
+
+
+@silence_errors
+def _get_helper() -> Optional[TelemetryHelper]:
+    """Returns the shared TelemetryHelper instance."""
+
+    if _is_env_true("TB_CLI_TELEMETRY_OPTOUT"):
+        return None
+
+    global _helper_instance
+
+    if not _helper_instance:
+        _helper_instance = TelemetryHelper()
+
+    return _helper_instance

tinybird/{tb_cli_modules → tb/modules}/test.py

@@ -10,11 +10,11 @@ import click
 
 from tinybird.client import AuthNoTokenException
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import coro, create_tb_client, gather_with_concurrency
-from tinybird.tb_cli_modules.config import CLIConfig
-from tinybird.tb_cli_modules.exceptions import CLIException
-from tinybird.tb_cli_modules.tinyunit.tinyunit import (
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import coro, create_tb_client, gather_with_concurrency
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.exceptions import CLIException
+from tinybird.tb.modules.tinyunit.tinyunit import (
     TestSummaryResults,
     generate_file,
     parse_file,

tinybird/{tb_cli_modules → tb/modules}/tinyunit/tinyunit.py

@@ -9,7 +9,7 @@ from typing_extensions import override
 
 from tinybird.client import TinyB
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.common import CLIException
+from tinybird.tb.modules.common import CLIException
 
 
 @dataclass

tinybird/{tb_cli_modules → tb/modules}/token.py

@@ -8,13 +8,13 @@ from humanfriendly import parse_timespan
 
 from tinybird.client import AuthNoTokenException, TinyB
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import (
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import (
     DoesNotExistException,
     coro,
     echo_safe_humanfriendly_tables_format_smart_table,
 )
-from tinybird.tb_cli_modules.exceptions import CLITokenException
+from tinybird.tb.modules.exceptions import CLITokenException
 
 
 @cli.group()

tinybird/{tb_cli_modules → tb/modules}/workspace.py

@@ -10,10 +10,9 @@ from click import Context
 
 from tinybird.client import CanNotBeDeletedException, DoesNotExistException, TinyB
 from tinybird.config import get_display_host
-from tinybird.datafile import PipeTypes
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import (
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import (
     _get_workspace_plan_name,
     ask_for_user_token,
     check_user_token,
@@ -26,8 +25,9 @@ from tinybird.tb_cli_modules.common import (
     print_current_workspace,
     switch_workspace,
 )
-from tinybird.tb_cli_modules.config import CLIConfig
-from tinybird.tb_cli_modules.exceptions import CLIWorkspaceException
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.datafile import PipeTypes
+from tinybird.tb.modules.exceptions import CLIWorkspaceException
 
 
 @cli.group()

tinybird/{tb_cli_modules → tb/modules}/workspace_members.py

@@ -13,16 +13,16 @@ from click import Context
 from tinybird.client import TinyB
 from tinybird.config import get_display_host
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.common import (
+from tinybird.tb.modules.common import (
     ask_for_user_token,
     check_user_token,
     coro,
     echo_safe_humanfriendly_tables_format_smart_table,
     get_current_workspace,
 )
-from tinybird.tb_cli_modules.config import CLIConfig
-from tinybird.tb_cli_modules.exceptions import CLIWorkspaceMembersException
-from tinybird.tb_cli_modules.workspace import workspace
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.exceptions import CLIWorkspaceMembersException
+from tinybird.tb.modules.workspace import workspace
 
 ROLES = ["viewer", "guest", "admin"]
 

tinybird/tb_cli_modules/common.py

@@ -53,7 +53,6 @@ from tinybird.config import (
     get_display_host,
     write_config,
 )
-from tinybird.tb_cli_modules.table import format_table
 
 if TYPE_CHECKING:
     from tinybird.connectors import Connector
@@ -135,23 +134,6 @@ def echo_safe_humanfriendly_tables_format_smart_table(data: Iterable[Any], colum
             raise exc
 
 
-def echo_safe_format_table(data: Iterable[Any], columns) -> None:
-    """
-    There is a bug in the humanfriendly library: it breaks to render the small table for small terminals
-    (`format_robust_table`) if we call format_smart_table with an empty dataset. This catches the error and prints
-    what we would call an empty "robust_table".
-    """
-    try:
-        click.echo(format_table(data, columns))
-    except ValueError as exc:
-        if str(exc) == "max() arg is an empty sequence":
-            click.echo("------------")
-            click.echo("Empty")
-            click.echo("------------")
-        else:
-            raise exc
-
-
 def normalize_datasource_name(s: str) -> str:
     s = re.sub(r"[^0-9a-zA-Z_]", "_", s)
     if s[0] in "0123456789":
@@ -171,7 +153,7 @@ def generate_datafile(
     if not f.exists() or force:
         with open(f"{f}", "w") as ds_file:
             ds_file.write(datafile)
-        click.echo(FeedbackManager.info_file_created(file=f))
+        click.echo(FeedbackManager.success_generated_file(file=f, stem=datasource_name, filename=filename))
 
         if data and (base / "fixtures").exists():
             # Generating a fixture for Parquet files is not so trivial, since Parquet format
@@ -184,6 +166,7 @@ def generate_datafile(
                 newline = b"\n"  # TODO: guess
                 with open(f, "wb") as fixture_file:
                     fixture_file.write(data[: data.rfind(newline)])
+                click.echo(FeedbackManager.success_generated_fixture(fixture=f))
     else:
         click.echo(FeedbackManager.error_file_already_exists(file=f))
 
@@ -1060,7 +1043,6 @@ def get_format_from_filename_or_url(filename_or_url: str) -> str:
 
 async def push_data(
     ctx: Context,
-    client: TinyB,
     datasource_name: str,
     url,
     connector: Optional[str],
@@ -1073,6 +1055,7 @@ async def push_data(
 ):
     if url and type(url) is tuple:
         url = url[0]
+    client: TinyB = ctx.obj["client"]
 
     if connector and sql:
         load_connector_config(ctx, connector, False, check_uninstalled=False)
@@ -1108,7 +1091,7 @@ async def push_data(
     cb.First = True  # type: ignore[attr-defined]
     cb.prev_done = 0  # type: ignore[attr-defined]
 
-    click.echo(FeedbackManager.gray(message=f"\nImporting data to {datasource_name} Data Source..."))
+    click.echo(FeedbackManager.info_starting_import_process())
 
     if isinstance(url, list):
         urls = url
@@ -1179,16 +1162,17 @@ async def push_data(
     except Exception as e:
         raise CLIException(FeedbackManager.error_exception(error=e))
     else:
+        click.echo(FeedbackManager.success_progress_blocks())
         if mode == "append" and parser and parser != "clickhouse":
             click.echo(FeedbackManager.success_appended_rows(appended_rows=appended_rows))
 
+        click.echo(FeedbackManager.success_total_rows(datasource=datasource_name, total_rows=total_rows))
+
         if mode == "replace":
             click.echo(FeedbackManager.success_replaced_datasource(datasource=datasource_name))
         else:
-            click.echo(FeedbackManager.highlight(message="» 2.57m rows x 9 cols in 852.04ms"))
-
-        click.echo(FeedbackManager.success_progress_blocks())
-
+            click.echo(FeedbackManager.success_appended_datasource(datasource=datasource_name))
+        click.echo(FeedbackManager.info_data_pushed(datasource=datasource_name))
     finally:
         try:
             for url in urls:

tinybird/tb_cli_modules/config.py

@@ -338,14 +338,6 @@ class CLIConfig:
             CLIConfig._projects[working_dir] = result
         return result
 
-    @staticmethod
-    def get_llm_config(working_dir: Optional[str] = None) -> Dict[str, Any]:
-        return (
-            CLIConfig.get_project_config(working_dir)
-            .get("llms", {})
-            .get("openai", {"model": "gpt-4o-mini", "api_key": None})
-        )
-
     @staticmethod
     def reset() -> None:
         CLIConfig._global = None

{tinybird-0.0.1.dev5.dist-info → tinybird-0.0.1.dev6.dist-info}/METADATA

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

tinybird-0.0.1.dev6.dist-info/RECORD

@@ -0,0 +1,58 @@
+tinybird/__cli__.py,sha256=pgYsVLcqL16wtSn6KtKweNZYoYJdEksTgSvQAW7hH64,250
+tinybird/check_pypi.py,sha256=RIhZcTg9dk5SFuvV3yVtFgBael_5_VYl4GzOZJojCfU,971
+tinybird/client.py,sha256=nd97gD2-8Ap8yDonBcVwk9eXDAL43hmIYdo-Pse43RE,50738
+tinybird/config.py,sha256=Z-BX9FrjgsLw1YwcCdF0IztLB97Zpc70VVPplO_pDSY,6089
+tinybird/connectors.py,sha256=lkpVSUmSuViEZBa4QjTK7YmPHUop0a5UFoTrSmlVq6k,15244
+tinybird/context.py,sha256=kutUQ0kCwparowI74_YLXx6wtTzGLRouJ6oGHVBPzBo,1291
+tinybird/datatypes.py,sha256=IHyhZ86ib54Vnd1pbod9y2aS8DDvDKZm1HJGlThdbuQ,10460
+tinybird/feedback_manager.py,sha256=qX8yrjoHUL4kjb_IKzLZPPfg4m54XWUZkdVOrv1ktpo,67814
+tinybird/git_settings.py,sha256=XUL9ZUj59-ZVQJDYmMEq4UpnuuOuQOHGlNcX3JgQHjQ,3954
+tinybird/sql.py,sha256=gfRKjdqEygcE1WOTeQ1QV2Jal8Jzl4RSX8fftu1KSEs,45825
+tinybird/sql_template.py,sha256=IqYRfUxDYBCoOYjqqvn--_8QXLv9FSRnJ0bInx7q1Xs,93051
+tinybird/sql_template_fmt.py,sha256=1z-PuqSZXtzso8Z_mPqUc-NxIxUrNUcVIPezNieZk-M,10196
+tinybird/sql_toolset.py,sha256=xS_yD5N_TZT5d4uPcXdeIYX4GQPz7-7wHywMGdfgqcM,13794
+tinybird/syncasync.py,sha256=fAvq0qkRgqXqXMKwbY2iJNYqLT_r6mDsh1MRpGKrdRU,27763
+tinybird/tornado_template.py,sha256=o2HguxrL1Evnt8o3IvrsI8Zm6JtRQ3zhLJKf1XyR3SQ,41965
+tinybird/ch_utils/constants.py,sha256=aYvg2C_WxYWsnqPdZB1ZFoIr8ZY-XjUXYyHKE9Ansj0,3890
+tinybird/ch_utils/engine.py,sha256=OXkBhlzGjZotjD0vaT-rFIbSGV4tpiHxE8qO_ip0SyQ,40454
+tinybird/tb/cli.py,sha256=6Lu3wsCNepAxjJCWy4c6RhVPArBtm8TlUcSxX--TsBo,783
+tinybird/tb/modules/auth.py,sha256=hynZ-Temot8YBsySUWKSFzZlYadtFPxG3o6lCSu1n6E,9018
+tinybird/tb/modules/branch.py,sha256=X3Ks8SnIeZLgU6wU6tY0-PfLmIJdGho6wlkmC4o4nOg,39119
+tinybird/tb/modules/build.py,sha256=CAZq1BxbGM-uaoGanVEtZT3YwzWN_jJ6Fzgrw8Nwi3g,7798
+tinybird/tb/modules/cicd.py,sha256=mIMU1gNGpN3f5K3rBYN9rFoOT3RogDxIs_zB3LY-iO4,7463
+tinybird/tb/modules/cli.py,sha256=Kz55MfNv01lcYow2TNRJuGZvUZ_2Sa-jfNqeYVmhuJU,61968
+tinybird/tb/modules/common.py,sha256=KBuSgVKqyUE4OVgMqD7BXro346IxcSNkKCf_I1_D9fw,79086
+tinybird/tb/modules/config.py,sha256=ppWvACHrSLkb5hOoQLYNby2w8jR76-8Kx2NBCst7ntQ,11760
+tinybird/tb/modules/connection.py,sha256=ZSqBGoRiJedjHKEyB_fr1ybucOHtaad8d7uqGa2Q92M,28668
+tinybird/tb/modules/create.py,sha256=E5hs03kDdJj7n0_6H3loUOcfNv71Jbks0EBu9Kdre4Q,6898
+tinybird/tb/modules/datafile.py,sha256=16MTuwXqsruhf_UoniDQSHetMIGeFbiUtZcLDJcqoAk,253563
+tinybird/tb/modules/datasource.py,sha256=Wkxj6QBtTKCgl43JFwMWafEHYnnQjGZZHoL2SbuC3KQ,35811
+tinybird/tb/modules/exceptions.py,sha256=4A2sSjCEqKUMqpP3WI00zouCWW4uLaghXXLZBSw04mY,3363
+tinybird/tb/modules/fmt.py,sha256=ZoYLUkyExudbUr-Phy-I2riPBdQd1NXwA1y-XbSEFB8,3385
+tinybird/tb/modules/job.py,sha256=eoBVyA24lYIPonU88Jn7FF9hBKz1kScy9_w_oWreuc4,2952
+tinybird/tb/modules/llm.py,sha256=D6ShlqCorZpRLjE5srI7Ws4VUTH6kSotTi88CvUwoGw,2446
+tinybird/tb/modules/local.py,sha256=nCaN05ntqIGFbBqyhRwpwdLpcYwsx6Vvp0atU_KKaTo,5893
+tinybird/tb/modules/mock.py,sha256=dYxm8_1zXGZnf4X8OYmG9hK1I-csHakD64Hag8mAn4Q,2069
+tinybird/tb/modules/pipe.py,sha256=LIiEK3zUmLcu24zgHy8qWvDD4yQjwnb--AZ1vbs0554,30984
+tinybird/tb/modules/prompts.py,sha256=12Abh1kZItxMa7r3WbTi_TgTYtlV30HcaG_JiodafIA,7255
+tinybird/tb/modules/regions.py,sha256=QjsL5H6Kg-qr0aYVLrvb1STeJ5Sx_sjvbOYO0LrEGMk,166
+tinybird/tb/modules/table.py,sha256=hG-PRDVuFp2uph41WpoLRV1yjp3RI2fi_iGGiI0rdxU,7695
+tinybird/tb/modules/tag.py,sha256=1qQWyk1p3Btv3LzM8VbJG-k7x2-pFuAlYCg3QL6QewI,3480
+tinybird/tb/modules/telemetry.py,sha256=iEGnMuCuNhvF6ln__j6X9MSTwL_0Hm-GgFHHHvhfknk,10466
+tinybird/tb/modules/test.py,sha256=psINFpSYT1eGgy32-_4q6CJ7LOcdwBpAfasMA0_tNOU,4330
+tinybird/tb/modules/token.py,sha256=r0oeG1RpOOzHtqbUaHBiOmhE55HfNIvReAAWyKl9fJg,12695
+tinybird/tb/modules/workspace.py,sha256=alZFDKy_qaZk5TIe6gduBeNgpp4h5jp6RDj1SwP5ylg,10909
+tinybird/tb/modules/workspace_members.py,sha256=08W0onEYkKLEC5TkAI07cxN9XSquEm7HnL7OkHAVDjo,8715
+tinybird/tb/modules/tinyunit/tinyunit.py,sha256=IkjRCvb8HnNEE84rtl0I1b9gQVpE_zCE8MvFFet51sg,11716
+tinybird/tb/modules/tinyunit/tinyunit_lib.py,sha256=hGh1ZaXC1af7rKnX7222urkj0QJMhMWclqMy59dOqwE,1922
+tinybird/tb_cli_modules/cicd.py,sha256=0lMkb6CVOFZl5HOwgY8mK4T4mgI7O8335UngLXtCc-c,13851
+tinybird/tb_cli_modules/common.py,sha256=JJwkLUcTbTonf1NWe4tUeenQGMr82d2152hnSs6k6Zc,78706
+tinybird/tb_cli_modules/config.py,sha256=6NTgIdwf0X132A1j6G_YrdPep87ymZ9b5pABabKLzh4,11484
+tinybird/tb_cli_modules/exceptions.py,sha256=pmucP4kTF4irIt7dXiG-FcnI-o3mvDusPmch1L8RCWk,3367
+tinybird/tb_cli_modules/regions.py,sha256=QjsL5H6Kg-qr0aYVLrvb1STeJ5Sx_sjvbOYO0LrEGMk,166
+tinybird/tb_cli_modules/telemetry.py,sha256=iEGnMuCuNhvF6ln__j6X9MSTwL_0Hm-GgFHHHvhfknk,10466
+tinybird-0.0.1.dev6.dist-info/METADATA,sha256=wgXkBp0lUmzhrrDmTwxzy0FKVfmEIGfZ6no4CQF3uQc,2404
+tinybird-0.0.1.dev6.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+tinybird-0.0.1.dev6.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
+tinybird-0.0.1.dev6.dist-info/top_level.txt,sha256=pgw6AzERHBcW3YTi2PW4arjxLkulk2msOz_SomfOEuc,45
+tinybird-0.0.1.dev6.dist-info/RECORD,,

tinybird-0.0.1.dev6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tb = tinybird.tb.cli:cli

tinybird/tb_cli.py

@@ -1,28 +0,0 @@
-import asyncio
-import sys
-
-if sys.platform == "win32":
-    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-
-import tinybird.tb_cli_modules.auth
-import tinybird.tb_cli_modules.branch
-import tinybird.tb_cli_modules.build
-import tinybird.tb_cli_modules.cli
-import tinybird.tb_cli_modules.common
-import tinybird.tb_cli_modules.connection
-import tinybird.tb_cli_modules.create
-import tinybird.tb_cli_modules.datasource
-import tinybird.tb_cli_modules.fmt
-import tinybird.tb_cli_modules.job
-import tinybird.tb_cli_modules.mock
-import tinybird.tb_cli_modules.pipe
-import tinybird.tb_cli_modules.tag
-import tinybird.tb_cli_modules.test
-import tinybird.tb_cli_modules.token
-import tinybird.tb_cli_modules.workspace
-import tinybird.tb_cli_modules.workspace_members
-
-cli = tinybird.tb_cli_modules.cli.cli
-
-if __name__ == "__main__":
-    cli()