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

tinybird/tb/modules/config.py

@@ -0,0 +1,352 @@
+import json
+import os
+from copy import deepcopy
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
+from urllib.parse import urlparse
+
+from packaging import version
+
+import tinybird.client as tbc
+from tinybird.config import CURRENT_VERSION, DEFAULT_API_HOST, DEFAULT_LOCALHOST
+
+APP_CONFIG_NAME = "tinybird"
+
+
+class FeatureFlags:
+    @classmethod
+    def ignore_sql_errors(cls) -> bool:  # Context: #1155
+        return "TB_IGNORE_SQL_ERRORS" in os.environ
+
+    @classmethod
+    def is_localhost(cls) -> bool:
+        return "SET_LOCALHOST" in os.environ
+
+    @classmethod
+    def ignore_ssl_errors(cls) -> bool:
+        return os.environ.get("TB_DISABLE_SSL_CHECKS", "0") == "1"
+
+    @classmethod
+    def send_telemetry(cls) -> bool:
+        if os.environ.get("TB_CLI_TELEMETRY_OPTOUT", "0") == "1":
+            return False
+        if "x.y.z" in CURRENT_VERSION and os.environ.get("TB_CLI_TELEMETRY_SEND_IN_LOCAL", "0") == "0":
+            return False
+        return True
+
+
+def compare_versions(a: str, b: str) -> int:
+    va = version.parse(a)
+    vb = version.parse(b)
+    return -1 if va < vb else (1 if va > vb else 0)
+
+
+class ConfigValueOrigin(Enum):
+    # Sources for config values (environment variables, .tinyb file or default value)
+
+    ENVIRONMENT: str = "env"
+    CONFIG: str = "conf"
+    DEFAULT: str = "default"
+    NONE: str = ""
+
+
+@dataclass
+class ConfigValue:
+    name: str
+    value: Any
+    origin: ConfigValueOrigin
+
+    def as_tuple(self) -> Tuple[str, str]:
+        return (self.name, self.value)
+
+
+def write_json_file(data: Dict[str, Any], path: str) -> None:
+    with open(path, "w") as file:
+        file.write(json.dumps(data, indent=4, sort_keys=True))
+
+
+class CLIConfig:
+    # Mapping between environment variables and config values
+    ENV_KEYS: Dict[str, str] = {
+        "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}
+
+    _global: Optional["CLIConfig"] = None
+    _projects: Dict[str, "CLIConfig"] = {}
+
+    def __init__(self, path: Optional[str], parent: Optional["CLIConfig"] = None) -> None:
+        self._path = path
+        self._parent = parent
+        self._values: Dict[str, ConfigValue] = {}
+        self._values["version"] = ConfigValue("version", CURRENT_VERSION, ConfigValueOrigin.DEFAULT)
+        self._workspaces: List[Dict[str, Any]] = []
+
+        if self._path:
+            self.override_with_file(self._path)
+        self.override_with_environment()
+        self.override_with_defaults()
+
+    def __str__(self) -> str:
+        return str(self.to_dict())
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Helper to ease"""
+        result: Dict[str, Any] = self._parent.to_dict() if self._parent else {}
+        result.update(dict((v.name, deepcopy(v.value)) for v in self._values.values()))
+        return result
+
+    def __getitem__(self, key) -> Any:
+        """Gets a config key value in this order:
+        - Environment
+        - Internal dict (by host)
+        - Parent dict (if has a parent)
+        - Default values
+        """
+        if key in self._values:
+            return self._values[key].value
+        if self._parent:
+            return self._parent[key]
+        raise KeyError(key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self._values[key] = ConfigValue(key, value, ConfigValueOrigin.CONFIG)
+
+    def __contains__(self, key: str) -> bool:
+        return self.get_value_origin(key) != ConfigValueOrigin.NONE
+
+    def get(self, key: str, default: Any = None) -> Any:
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def get_value_origin(self, key: str) -> ConfigValueOrigin:
+        if key in self._values:
+            return self._values[key].origin
+        if self._parent:
+            return self._parent.get_value_origin(key)
+        else:
+            return ConfigValueOrigin.NONE
+
+    def persist_to_file(self, override_with_values: Optional["CLIConfig"] = None) -> None:
+        if not self._path:
+            raise ValueError("Cannot persist configuration: `path` is None")
+
+        if override_with_values:
+            self.update(override_with_values)
+
+        os.makedirs(os.path.dirname(self._path), exist_ok=True)
+        values = dict(v.as_tuple() for v in self._values.values())
+        write_json_file(values, self._path)
+
+    def override_with_file(self, path: str) -> bool:
+        """Loads the contents of the passed file."""
+        try:
+            with open(path) as file:
+                values: Dict[str, Any] = json.loads(file.read())
+                for k, v in values.items():
+                    self[k] = v
+            return True
+        except IOError:
+            return False
+
+    def override_with_environment(self) -> None:
+        """Loads environment variables."""
+        for config_key, env_key in CLIConfig.ENV_KEYS.items():
+            env_value = os.environ.get(env_key, None)
+            if env_value:
+                self._values[config_key] = ConfigValue(config_key, env_value, ConfigValueOrigin.ENVIRONMENT)
+
+    def override_with_defaults(self) -> None:
+        """Loads default values."""
+        for key, default_value in CLIConfig.DEFAULTS.items():
+            if key not in self._values:
+                self._values[key] = ConfigValue(key, default_value, ConfigValueOrigin.DEFAULT)
+
+    def set_token(self, token: Optional[str]) -> None:
+        self["token"] = token
+
+    def get_token(self) -> Optional[str]:
+        try:
+            return self["token"]
+        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.
+
+        Here we ask for the host explicitly to avoid mistakenly setting the token
+        for the wrong host.
+        """
+        if not token and not host:
+            return
+
+        assert isinstance(host, str)
+
+        tokens: Dict[str, Optional[str]] = self.get("tokens", {})
+        tokens[host] = token
+        self["tokens"] = tokens
+
+    def get_token_for_host(self, host: str) -> Optional[str]:
+        try:
+            return self["tokens"][host]
+        except KeyError:
+            return None
+
+    def set_user_token(self, token: Optional[str]) -> None:
+        self["user_token"] = token
+
+    def get_user_token(self) -> Optional[str]:
+        try:
+            return self["user_token"]
+        except KeyError:
+            return None
+
+    def set_host(self, host: Optional[str]) -> None:
+        url_info = urlparse(host)
+        scheme: str = url_info.scheme.decode() if isinstance(url_info.scheme, bytes) else url_info.scheme
+        netloc: str = url_info.netloc.decode() if isinstance(url_info.netloc, bytes) else url_info.netloc
+        self["host"] = f"{scheme}://{netloc}"
+
+    def get_host(self, use_defaults_if_needed: bool = False) -> Optional[str]:
+        result: Optional[str] = self.get("host", None)
+        if result:
+            return result
+        if use_defaults_if_needed:
+            return CLIConfig.DEFAULTS["host"]
+        return None
+
+    def get_client(self, token: Optional[str] = None, host: Optional[str] = None) -> tbc.TinyB:
+        """Returns a new TinyB client configured with:
+
+        - token:
+          - passed token
+          - OR the user token
+          - OR the current admin token
+
+        - host:
+          - passed host
+          - OR the current host
+        """
+        host = host or self.get_host()
+        assert isinstance(host, str)
+        token = token or self.get_token() or self.get_token_for_host(host) or ""
+        assert isinstance(token, str)
+
+        return tbc.TinyB(
+            token,
+            host,
+            version=CURRENT_VERSION,
+            disable_ssl_checks=FeatureFlags.ignore_ssl_errors(),
+            send_telemetry=FeatureFlags.send_telemetry(),
+        )
+
+    def get_user_client(self, host: Optional[str] = None) -> tbc.TinyB:
+        return self.get_client(self.get_user_token(), host)
+
+    def set_workspace_token(self, workspace_id: str, token: str) -> None:
+        pass
+
+    async def get_workspace_token(
+        self, workspace_id: Optional[str] = None, host: Optional[str] = None
+    ) -> Optional[str]:
+        """Returns the token for the specific workspace on a host.
+        - If no workspace passed, it uses the current active workspace.
+        - If no host is passed, it uses the current one.
+        """
+
+        # First, try to get any saved token for the host
+        if host:
+            try:
+                return self["tokens"][host]
+            except KeyError:
+                pass
+
+        # If we don't have an user_token, can't continue
+        if not self.get_user_token():
+            return None
+
+        if not workspace_id:
+            workspace_id = self.get("id", None)
+            if not workspace_id:
+                return None
+
+        client: tbc.TinyB = self.get_client(token=self.get_user_token(), host=host)
+
+        info: Dict[str, Any] = await client.user_workspaces_and_branches()
+        workspaces: List[Dict[str, Any]] = info["workspaces"]
+
+        result: Optional[str] = next(
+            (w["token"] for w in workspaces if workspace_id in (w.get("id"), w.get("name"))), None
+        )
+        if host:
+            self.set_token_for_host(result, host)
+
+        return result
+
+    def spawn(self) -> "CLIConfig":
+        return CLIConfig(path=None, parent=self)
+
+    def update(self, other: Union["CLIConfig", Dict[str, Any]]):
+        values = other if isinstance(other, dict) else other._values
+        for k, v in values.items():
+            self[k] = v
+
+    @staticmethod
+    def get_global_config(_path: Optional[str] = None) -> "CLIConfig":
+        """Returns the user-specific config.
+
+        The data is cached between calls, so feel free to use it freely instead
+        of saving a reference.
+
+        Note: the `_path` argument is mainly intended to help during testing.
+        """
+        if not CLIConfig._global:
+            path: Optional[str] = _path or os.environ.get("XDG_CONFIG_HOME", None)
+            if not path:
+                path = os.path.join(os.environ.get("HOME", "~"), ".config")
+            path = os.path.join(path, APP_CONFIG_NAME, ".tinyb")
+            CLIConfig._global = CLIConfig(path, parent=None)
+        return CLIConfig._global
+
+    @staticmethod
+    def get_project_config(working_dir: Optional[str] = None) -> "CLIConfig":
+        """Returns the project-specific config located at `working_dir` (defaults to `os.getcwd()`)
+
+        The data is cached between calls, given the same `working_dir`.
+        """
+        working_dir = working_dir or os.getcwd()
+        result = CLIConfig._projects.get(working_dir)
+        if not result:
+            path: str = os.path.join(working_dir, ".tinyb")
+            result = CLIConfig(path, parent=CLIConfig.get_global_config())
+            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
+        CLIConfig._projects.clear()

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

@@ -14,8 +14,8 @@ from click import Context
 
 from tinybird.client import DoesNotExistException, 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 (
     ConnectionReplacements,
     DataConnectorType,
     _get_setting_value,
@@ -33,8 +33,8 @@ from tinybird.tb_cli_modules.common import (
     validate_kafka_secret,
     validate_string_connector_param,
 )
-from tinybird.tb_cli_modules.exceptions import CLIConnectionException
-from tinybird.tb_cli_modules.telemetry import is_ci_environment
+from tinybird.tb.modules.exceptions import CLIConnectionException
+from tinybird.tb.modules.telemetry import is_ci_environment
 
 DATA_CONNECTOR_SETTINGS: Dict[DataConnectorType, List[str]] = {
     DataConnectorType.KAFKA: [

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

@@ -7,14 +7,15 @@ import click
 from click import Context
 
 from tinybird.client import TinyB
-from tinybird.datafile import folder_build
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import _generate_datafile, coro, generate_datafile, push_data
-from tinybird.tb_cli_modules.config import CLIConfig
-from tinybird.tb_cli_modules.exceptions import CLIDatasourceException
-from tinybird.tb_cli_modules.llm import LLM
-from tinybird.tb_cli_modules.local import (
+from tinybird.tb.modules.cicd import init_cicd
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import _generate_datafile, coro, generate_datafile, push_data
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.datafile import folder_build
+from tinybird.tb.modules.exceptions import CLIDatasourceException
+from tinybird.tb.modules.llm import LLM
+from tinybird.tb.modules.local import (
     get_tinybird_local_client,
 )
 
@@ -63,6 +64,9 @@ async def create(
             datasources,
             pipes,
         )
+
+        await init_cicd(data_project_dir=os.path.relpath(folder))
+
         if data:
             ds_name = os.path.basename(data.split(".")[0])
             await append_datasource(ctx, tb_client, ds_name, data, None, None, False, 1)

tinybird/{datafile.py → tb/modules/datafile.py}

@@ -58,7 +58,12 @@ from humanfriendly.tables import format_pretty_table
 from mypy_extensions import KwArg, VarArg
 from toposort import toposort
 
+from tinybird.ch_utils.engine import ENABLED_ENGINES
+from tinybird.client import AuthException, AuthNoTokenException, CanNotBeDeletedException, DoesNotExistException, TinyB
 from tinybird.config import PROJECT_PATHS
+from tinybird.feedback_manager import FeedbackManager
+from tinybird.sql import parse_indexes_structure, parse_table_structure, schema_to_sql_columns
+from tinybird.sql_template import get_template_and_variables, get_used_tables_in_template, render_sql_template
 from tinybird.sql_template_fmt import DEFAULT_FMT_LINE_LENGTH, format_sql_template
 from tinybird.syncasync import sync_to_async
 from tinybird.tb_cli_modules.common import (
@@ -70,13 +75,7 @@ from tinybird.tb_cli_modules.common import (
 )
 from tinybird.tb_cli_modules.config import CLIConfig
 from tinybird.tb_cli_modules.exceptions import CLIGitReleaseException, CLIPipeException
-
-from .ch_utils.engine import ENABLED_ENGINES
-from .client import AuthException, AuthNoTokenException, CanNotBeDeletedException, DoesNotExistException, TinyB
-from .feedback_manager import FeedbackManager
-from .sql import parse_indexes_structure, parse_table_structure, schema_to_sql_columns
-from .sql_template import get_template_and_variables, get_used_tables_in_template, render_sql_template
-from .tornado_template import UnClosedIfError
+from tinybird.tornado_template import UnClosedIfError
 
 os.environ["GIT_PYTHON_REFRESH"] = "quiet"
 from git import HEAD, Diff, GitCommandError, InvalidGitRepositoryError, Repo

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

@@ -15,16 +15,15 @@ from click import Context
 
 from tinybird.client import AuthNoTokenException, CanNotBeDeletedException, DoesNotExistException, TinyB
 from tinybird.config import get_display_host
-from tinybird.tb_cli_modules.config import CLIConfig
+from tinybird.tb.modules.config import CLIConfig
 
 if TYPE_CHECKING:
     from tinybird.connectors import Connector
 
-from tinybird.datafile import get_name_version, wait_job
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.branch import warn_if_in_live
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import (
+from tinybird.tb.modules.branch import warn_if_in_live
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import (
     _analyze,
     _generate_datafile,
     ask_for_user_token,
@@ -40,8 +39,10 @@ from tinybird.tb_cli_modules.common import (
     validate_kafka_auto_offset_reset,
     validate_kafka_group,
     validate_kafka_topic,
+    wait_job,
 )
-from tinybird.tb_cli_modules.exceptions import CLIDatasourceException
+from tinybird.tb.modules.datafile import get_name_version
+from tinybird.tb.modules.exceptions import CLIDatasourceException
 
 
 @cli.group()

tinybird/tb/modules/exceptions.py

@@ -0,0 +1,91 @@
+from typing import Any, Dict, Optional
+
+import click
+
+from tinybird.tb.modules.telemetry import add_telemetry_event
+
+
+class CLIException(click.exceptions.ClickException):
+    """Default exception for all exceptions raised in the CLI.
+
+    Allows to specift a custom telemetry event to be sent before
+    raising the exception (if not specified, it sends a generic
+    `error` beacon with the error message)
+    """
+
+    def __init__(self, message: str, telemetry_event: Optional[str] = None, **kw_telemetry_event_data: Any) -> None:
+        telemetry_event = telemetry_event or "error"
+        data: Dict[str, Any] = {"error": message}
+        data.update(kw_telemetry_event_data)
+        add_telemetry_event(telemetry_event, **data)
+        super().__init__(message)
+
+
+class CLIAuthException(CLIException):
+    """Exceptions generated by the auth commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "auth_error", **kw_telemetry_event_data)
+
+
+class CLIReleaseException(CLIException):
+    """Exceptions generated by the release commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "release_error", **kw_telemetry_event_data)
+
+
+class CLIBranchException(CLIException):
+    """Exceptions generated by the branch commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "branch_error", **kw_telemetry_event_data)
+
+
+class CLIGitReleaseException(CLIException):
+    """Exceptions generated by the git release related commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "git_release_error", **kw_telemetry_event_data)
+
+
+class CLIConnectionException(CLIException):
+    """Exceptions generated by the connection commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "connection_error", **kw_telemetry_event_data)
+
+
+class CLIDatasourceException(CLIException):
+    """Exceptions generated by the datasource commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "datasource_error", **kw_telemetry_event_data)
+
+
+class CLIPipeException(CLIException):
+    """Exceptions generated by the pipe commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "pipe_error", **kw_telemetry_event_data)
+
+
+class CLIWorkspaceMembersException(CLIException):
+    """Exceptions generated by the workspace members commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "workspace_members_error", **kw_telemetry_event_data)
+
+
+class CLIWorkspaceException(CLIException):
+    """Exceptions generated by the workspace commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "workspace_error", **kw_telemetry_event_data)
+
+
+class CLITokenException(CLIException):
+    """Exceptions generated by the token commands"""
+
+    def __init__(self, message: str, **kw_telemetry_event_data: Any) -> None:
+        super().__init__(message, "token_error", **kw_telemetry_event_data)

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

@@ -7,10 +7,10 @@ import aiofiles
 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
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import coro
+from tinybird.tb.modules.datafile import color_diff, format_datasource, format_pipe, is_file_a_datasource, peek
 
 
 @cli.command()

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

@@ -8,9 +8,9 @@ from click import Context
 
 from tinybird.client import DoesNotExistException, TinyB
 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_cli_modules.exceptions import CLIException
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import coro, echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.exceptions import CLIException
 
 
 @cli.group()

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

@@ -6,7 +6,7 @@ from openai import OpenAI
 from pydantic import BaseModel
 
 from tinybird.client import TinyB
-from tinybird.tb_cli_modules.prompts import create_project_prompt, sample_data_sql_prompt
+from tinybird.tb.modules.prompts import create_project_prompt, sample_data_sql_prompt
 
 
 class DataFile(BaseModel):

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

@@ -6,12 +6,12 @@ import requests
 
 import docker
 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 (
     coro,
 )
-from tinybird.tb_cli_modules.config import CLIConfig
-from tinybird.tb_cli_modules.exceptions import CLIException
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.exceptions import CLIException
 
 # TODO: Use the official Tinybird image once it's available 'tinybirdco/tinybird-local:latest'
 TB_IMAGE_NAME = "registry.gitlab.com/tinybird/analytics/tinybird-local-jammy-3.11:latest"
@@ -114,7 +114,11 @@ def remove_tinybird_local(docker_client):
 def get_tinybird_local_client():
     """Get a Tinybird client connected to the local environment."""
     config = CLIConfig.get_project_config()
-    tokens = requests.get(f"{TB_LOCAL_HOST}/tokens").json()
+    try:
+        tokens = requests.get(f"{TB_LOCAL_HOST}/tokens").json()
+    except Exception:
+        raise CLIException("Tinybird local environment is not running. Please start it with `tb local start`.")
+
     token = tokens["workspace_admin_token"]
     config.set_token(token)
     config.set_host(TB_LOCAL_HOST)

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

@@ -4,11 +4,11 @@ from pathlib import Path
 import click
 
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import CLIException, coro
-from tinybird.tb_cli_modules.config import CLIConfig
-from tinybird.tb_cli_modules.llm import LLM
-from tinybird.tb_cli_modules.local import get_tinybird_local_client
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import CLIException, coro
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.llm import LLM
+from tinybird.tb.modules.local import get_tinybird_local_client
 
 
 @cli.command()

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

@@ -16,12 +16,12 @@ from click import Context
 import tinybird.context as context
 from tinybird.client import AuthNoTokenException, DoesNotExistException, TinyB
 from tinybird.config import DEFAULT_API_HOST, FeatureFlags
-from tinybird.datafile import PipeNodeTypes, PipeTypes, folder_push, get_name_version, process_file, wait_job
 from tinybird.feedback_manager import FeedbackManager
-from tinybird.tb_cli_modules.branch import warn_if_in_live
-from tinybird.tb_cli_modules.cli import cli
-from tinybird.tb_cli_modules.common import coro, create_tb_client, echo_safe_humanfriendly_tables_format_smart_table
-from tinybird.tb_cli_modules.exceptions import CLIPipeException
+from tinybird.tb.modules.branch import warn_if_in_live
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import coro, create_tb_client, echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.datafile import PipeNodeTypes, PipeTypes, folder_push, get_name_version, process_file, wait_job
+from tinybird.tb.modules.exceptions import CLIPipeException
 
 
 @cli.group()

tinybird/tb/modules/regions.py

@@ -0,0 +1,9 @@
+from typing import Optional, TypedDict
+
+
+class Region(TypedDict):
+    name: str
+    provider: str
+    api_host: str
+    host: str
+    default_password: Optional[str]