tinybird 0.0.1.dev77__tar.gz → 0.0.1.dev79__tar.gz

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/PKG-INFO

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

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/config.py

@@ -68,14 +68,15 @@ LEGACY_HOSTS = {
 }
 
 
-async def get_config(host: str, token: Optional[str], semver: Optional[str] = None) -> Dict[str, Any]:
+async def get_config(
+    host: str, token: Optional[str], semver: Optional[str] = None, config_file: Optional[str] = None
+) -> Dict[str, Any]:
     if host:
         host = host.rstrip("/")
 
-    config_file = Path(getcwd()) / ".tinyb"
     config = {}
     try:
-        async with aiofiles.open(config_file) as file:
+        async with aiofiles.open(config_file or Path(getcwd()) / ".tinyb") as file:
             res = await file.read()
             config = json.loads(res)
     except OSError:
@@ -89,6 +90,7 @@ async def get_config(host: str, token: Optional[str], semver: Optional[str] = No
     config["semver"] = semver or config.get("semver", None)
     config["host"] = host or config.get("host", DEFAULT_API_HOST)
     config["workspaces"] = config.get("workspaces", [])
+    config["cwd"] = config.get("cwd", getcwd())
     return config
 
 

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/cli/introduction.html'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev77'
-__revision__ = '44da91f'
+__version__ = '0.0.1.dev79'
+__revision__ = 'f126631'

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/auth.py

@@ -116,7 +116,7 @@ async def auth_login(host: Optional[str], token: Optional[str]) -> None:
     Alternatively, tb will use the authentication token found in the environment
     variable TB_USER_TOKEN. This method is most suitable for "headless" use of tb
     such as in automations or in a CI environment."""
-    config = CLIConfig.get_global_config()
+    config = CLIConfig.get_project_config()
 
     if host:
         config.set_host(host)
@@ -146,7 +146,7 @@ async def auth_login(host: Optional[str], token: Optional[str]) -> None:
 @coro
 async def auth_logout() -> None:
     """Remove authentication from Tinybird."""
-    conf = CLIConfig.get_global_config()
+    conf = CLIConfig.get_project_config()
     conf.set_user_token(None)
     conf.persist_to_file()
 

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/build.py

@@ -137,7 +137,8 @@ def build_project(project: Project, tb_client: TinyB, file_changed: Optional[str
             error_msg = None
             for build_error in build_errors:
                 filename_bit = f"{build_error.get('filename', '')}"
-                error_msg = ((filename_bit + "\n\n") if filename_bit else "") + build_error.get("error")
+                error_bit = build_error.get("error") or build_error.get("message") or ""
+                error_msg = ((filename_bit + "\n\n") if filename_bit else "") + error_bit
             error = error_msg or "Unknown build error"
         else:
             error = f"Unknown build result. Error: {result.get('error')}"

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/cli.py

@@ -75,7 +75,6 @@ async def cli(
     """
     Use `OBFUSCATE_REGEX_PATTERN` and `OBFUSCATE_PATTERN_SEPARATOR` environment variables to define a regex pattern and a separator (in case of a single string with multiple regex) to obfuscate secrets in the CLI output.
     """
-    project = Project(folder=os.getcwd())
     # We need to unpatch for our tests not to break
     if show_tokens or not cloud or ctx.invoked_subcommand == "build" or build:
         __unpatch_click_output()
@@ -88,7 +87,9 @@ async def cli(
     if debug:
         logging.basicConfig(level=logging.DEBUG)
 
-    config_temp = CLIConfig.get_project_config(str(project.path))
+    config_temp = CLIConfig.get_project_config()
+    project = Project(folder=config_temp.cwd)
+
     if token:
         config_temp.set_token(token)
     if host:
@@ -106,10 +107,9 @@ async def cli(
     if not host and "TB_HOST" in os.environ:
         host = os.environ.get("TB_HOST", "")
 
-    config = await get_config(host, token)
+    config = await get_config(host, token, config_file=config_temp._path)
     client = _get_tb_client(config.get("token", None), config["host"])
 
-    config["path"] = str(project.path)
     # If they have passed a token or host as paramter and it's different that record in .tinyb, refresh the workspace id
     if token or host:
         try:

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/config.py

@@ -70,6 +70,7 @@ class CLIConfig:
         "token": "TB_TOKEN",
         "user_token": "TB_USER_TOKEN",
         "host": "TB_HOST",
+        "cwd": "TB_CWD",
     }
 
     DEFAULTS: Dict[str, str] = {"host": DEFAULT_API_HOST if not FeatureFlags.is_localhost() else DEFAULT_LOCALHOST}
@@ -77,9 +78,9 @@ class CLIConfig:
     _global: Optional["CLIConfig"] = None
     _projects: Dict[str, "CLIConfig"] = {}
 
-    def __init__(self, path: Optional[str] = None, parent: Optional["CLIConfig"] = None) -> None:
-        self._path = path
-        self._parent = parent
+    def __init__(self, path: Optional[str] = None) -> None:
+        self.cwd = os.getcwd()
+        self._path = path or self.get_tinyb_file() or os.path.join(os.getcwd(), ".tinyb")
         self._values: Dict[str, ConfigValue] = {}
         self._values["version"] = ConfigValue("version", CURRENT_VERSION, ConfigValueOrigin.DEFAULT)
         self._workspaces: List[Dict[str, Any]] = []
@@ -94,7 +95,7 @@ class CLIConfig:
 
     def to_dict(self) -> Dict[str, Any]:
         """Helper to ease"""
-        result: Dict[str, Any] = self._parent.to_dict() if self._parent else {}
+        result: Dict[str, Any] = {}
         result.update(dict((v.name, deepcopy(v.value)) for v in self._values.values()))
         return result
 
@@ -107,8 +108,6 @@ class CLIConfig:
         """
         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:
@@ -126,18 +125,16 @@ class CLIConfig:
     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:
+    def persist_to_file(self, override_with_path: Optional[str] = None) -> None:
+        if override_with_path:
+            self._path = override_with_path
+
         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)
@@ -149,6 +146,9 @@ class CLIConfig:
                 values: Dict[str, Any] = json.loads(file.read())
                 for k, v in values.items():
                     self[k] = v
+                if "cwd" in values:
+                    self.set_cwd(values["cwd"])
+
             return True
         except OSError:
             return False
@@ -211,6 +211,9 @@ class CLIConfig:
         netloc: str = url_info.netloc.decode() if isinstance(url_info.netloc, bytes) else url_info.netloc
         self["host"] = f"{scheme}://{netloc}"
 
+    def set_cwd(self, cwd: str) -> None:
+        self.cwd = os.path.join(os.path.dirname(self._path) if self._path else os.getcwd(), cwd)
+
     def get_host(self, use_defaults_if_needed: bool = False) -> Optional[str]:
         result: Optional[str] = self.get("host", None)
         if result:
@@ -288,41 +291,55 @@ class CLIConfig:
 
         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.
+    def get_tinyb_file() -> Optional[str]:
+        """Find the .tinyb file by traversing up directories from start_dir, stopping at user's home directory.
 
-        The data is cached between calls, so feel free to use it freely instead
-        of saving a reference.
+        Args:
+            start_dir: Directory to start searching from. Defaults to current working directory.
 
-        Note: the `_path` argument is mainly intended to help during testing.
+        Returns:
+            The path to the .tinyb file if found, current working directory otherwise.
         """
-        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")
-        exists_path = os.path.exists(path)
-        if not exists_path:
-            path = os.path.join(os.getcwd(), ".tinyb")
-        return CLIConfig(path, parent=None)
+        current_dir = os.getcwd()
+        path = os.path.join(current_dir, ".tinyb")
+        if os.path.isfile(path):
+            return path
+
+        home_dir = os.path.expanduser("~")
+
+        while current_dir != os.path.dirname(current_dir):  # Stop at root directory
+            # Stop if we reach home directory
+            if current_dir == home_dir:
+                tinyb_path = os.path.join(current_dir, ".tinyb")
+                return tinyb_path if os.path.isfile(tinyb_path) else None
+
+            tinyb_path = os.path.join(current_dir, ".tinyb")
+            if os.path.isfile(tinyb_path):
+                return tinyb_path
+
+            # Stop if we would go beyond home directory
+            parent_dir = os.path.dirname(current_dir)
+            if not current_dir.startswith(home_dir) or not parent_dir.startswith(home_dir):
+                return None
+
+            current_dir = parent_dir
+        return None
 
     @staticmethod
-    def get_project_config(working_dir: Optional[str] = None) -> "CLIConfig":
-        """Returns the project-specific config located at `working_dir` (defaults to `os.getcwd()`)
+    def get_project_config() -> "CLIConfig":
+        """Returns the project-specific config by finding the closest .tinyb file in the directory tree.
 
-        The data is cached between calls, given the same `working_dir`.
+        Returns:
+            A CLIConfig instance with the project configuration.
         """
-        working_dir = working_dir or os.getcwd()
-        path: str = os.path.join(working_dir, ".tinyb")
-        return CLIConfig(path, parent=CLIConfig.get_global_config())
+        tinyb_file = CLIConfig.get_tinyb_file()
+        return CLIConfig(tinyb_file)
 
     @staticmethod
     def reset() -> None:

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/create.py

@@ -1,6 +1,5 @@
 import os
 import re
-from os import getcwd
 from pathlib import Path
 from typing import Optional
 
@@ -34,20 +33,35 @@ from tinybird.tb.modules.project import Project
     help="Prompt to be used to create the project",
 )
 @click.option("--rows", type=int, default=10, help="Number of events to send")
-@click.option("--source", type=str, default="tb", help="Source of the command")
+@click.option("--folder", type=str, default=None, help="Folder to create the project in")
+@click.option("--agent", type=str, default="cursor", help="Agent to use for rules")
 @click.pass_context
 @coro
-async def create(ctx: click.Context, data: Optional[str], prompt: Optional[str], rows: int, source: str) -> None:
+async def create(
+    ctx: click.Context, data: Optional[str], prompt: Optional[str], rows: int, folder: Optional[str], agent: str
+) -> None:
     """Initialize a new project."""
-    project: Project = ctx.ensure_object(dict)["project"]
     local_client: TinyB = ctx.ensure_object(dict)["client"]
-    folder = getcwd()
-    folder_path = Path(folder)
+    project: Project = ctx.ensure_object(dict)["project"]
+    config = CLIConfig.get_project_config()
+
+    # If folder is provided, rewrite the config and project folder
+    if folder:
+        config.set_cwd(folder)
+        config.persist_to_file()
+        project.folder = folder
+
+    root_folder = os.getcwd()
+    if config._path:
+        root_folder = os.path.dirname(config._path)
+
+    folder = project.folder
+    folder_path = project.path
+
     if not folder_path.exists():
         folder_path.mkdir()
 
     try:
-        config = CLIConfig.get_project_config(str(project.path))
         tb_client = config.get_client()
         user_token: Optional[str] = None
         created = False
@@ -75,16 +89,16 @@ async def create(ctx: click.Context, data: Optional[str], prompt: Optional[str],
             click.echo(FeedbackManager.highlight(message="\n» Creating resources..."))
             result = await create_resources(local_client, tb_client, user_token, data, prompt, folder)
             click.echo(FeedbackManager.success(message="✓ Done!\n"))
-            created = True
-        if not already_has_cicd(folder):
+
+        if not already_has_cicd(root_folder):
             click.echo(FeedbackManager.highlight(message="\n» Creating CI/CD files for GitHub and GitLab..."))
-            init_git(folder)
-            await init_cicd(data_project_dir=os.path.relpath(folder))
+            init_git(root_folder)
+            await init_cicd(root_folder, data_project_dir=os.path.relpath(folder))
             click.echo(FeedbackManager.success(message="✓ Done!\n"))
-            created = True
-        if not already_has_cursor_rules(folder):
+
+        if not already_has_cursor_rules(root_folder):
             click.echo(FeedbackManager.highlight(message="\n» Creating .cursorrules..."))
-            create_rules(folder, source, "cursor")
+            create_rules(root_folder, "tb", agent)
             click.echo(FeedbackManager.success(message="✓ Done!\n"))
             created = True
         if should_generate_fixtures(result):
@@ -333,13 +347,3 @@ def get_context() -> str:
 def save_context(prompt: str, feedback: str):
     context_file = get_context_file()
     context_file.write_text(f"- {prompt}\n{feedback}")
-
-
-@cli.command("rules")
-@click.option("--agent", type=str, default="cursor", help="Agent to use for rules")
-@click.option("--source", type=str, default="tb", help="Source of the command")
-@click.pass_context
-def rules(ctx: click.Context, agent: str, source: str):
-    """Create agent rules for the project."""
-    project: Project = ctx.ensure_object(dict)["project"]
-    create_rules(str(project.path), source, agent)

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/datafile/build_pipe.py

@@ -5,18 +5,17 @@ from urllib.parse import urlencode
 
 import click
 import requests
-from croniter import croniter
 
-from tinybird.client import DoesNotExistException, TinyB
-from tinybird.tb.modules.common import requests_delete, requests_get
+from tinybird.client import TinyB
+from tinybird.tb.modules.common import requests_get
 from tinybird.tb.modules.config import CLIConfig
-from tinybird.tb.modules.datafile.common import ON_DEMAND, CopyModes, CopyParameters, PipeNodeTypes, PipeTypes
-from tinybird.tb.modules.exceptions import CLIPipeException
+from tinybird.tb.modules.datafile.common import PipeNodeTypes
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
 async def new_pipe(
     p,
+    config: CLIConfig,
     tb_client: TinyB,
     force: bool = False,
     check: bool = True,
@@ -39,13 +38,11 @@ async def new_pipe(
     tests_validate_processed_bytes: bool = False,
     override_datasource: bool = False,
     tests_check_requests_from_branch: bool = False,
-    config: Any = None,
     fork_downstream: Optional[bool] = False,
     fork: Optional[bool] = False,
 ):
     # TODO use tb_client instead of calling the urls directly.
     host = tb_client.host
-    config = CLIConfig().get_project_config()
     token = config.get_user_token()
 
     headers = {"Authorization": f"Bearer {token}"}
@@ -101,8 +98,8 @@ async def new_pipe(
 
     try:
         user_client = deepcopy(tb_client)
-        config = CLIConfig().get_project_config()
-        user_client.token = config.get_user_token()
+        config = CLIConfig.get_project_config()
+        user_client.token = config.get_user_token() or ""
         params["workspace_id"] = config.get("id", None)
         body["name"] = p["name"] + "__tb__playground"
 
@@ -182,132 +179,6 @@ async def get_token_from_main_branch(branch_tb_client: TinyB) -> Optional[str]:
     return token_from_main_branch
 
 
-async def check_materialized(pipe, host, token, cl, override_datasource=False, current_pipe=None):
-    checker_pipe = deepcopy(pipe)
-    checker_pipe["name"] = f"{checker_pipe['name']}__checker"
-    headers = {"Authorization": f"Bearer {token}"}
-
-    if current_pipe:
-        from_copy_to_materialized = current_pipe["type"] == "copy"
-        if from_copy_to_materialized:
-            await cl.pipe_remove_copy(current_pipe["id"], current_pipe["copy_node"])
-
-    materialized_node = None
-    for node in checker_pipe["nodes"]:
-        if node["params"]["type"] == "materialized":
-            materialized_node = deepcopy(node)
-            materialized_node["params"]["override_datasource"] = "true" if override_datasource else "false"
-        node["params"]["type"] = "standard"
-
-    try:
-        pipe_created = False
-        await new_pipe(
-            checker_pipe, cl, force=True, check=False, populate=False, skip_tokens=True, ignore_sql_errors=False
-        )
-        pipe_created = True
-        response = await cl.analyze_pipe_node(checker_pipe["name"], materialized_node, dry_run="true")
-        if response.get("warnings"):
-            show_materialized_view_warnings(response["warnings"])
-
-    except Exception as e:
-        raise click.ClickException(FeedbackManager.error_while_check_materialized(error=str(e)))
-    finally:
-        if pipe_created:
-            r = await requests_delete(f"{host}/v0/pipes/{checker_pipe['name']}", headers=headers)
-            if r.status_code != 204:
-                click.echo(FeedbackManager.warning_check_pipe(content=r.content))
-
-
-async def check_copy_pipe(pipe, copy_node, tb_client: TinyB):
-    target_datasource = copy_node["params"].get("target_datasource", None)
-    if not target_datasource:
-        raise CLIPipeException(FeedbackManager.error_creating_copy_pipe_target_datasource_required())
-
-    try:
-        await tb_client.get_datasource(target_datasource)
-    except DoesNotExistException:
-        raise CLIPipeException(
-            FeedbackManager.error_creating_copy_pipe_target_datasource_not_found(target_datasource=target_datasource)
-        )
-    except Exception as e:
-        raise CLIPipeException(FeedbackManager.error_exception(error=e))
-
-    schedule_cron = copy_node["params"].get(CopyParameters.COPY_SCHEDULE, None)
-    is_valid_cron = not schedule_cron or (
-        schedule_cron and (schedule_cron == ON_DEMAND or croniter.is_valid(schedule_cron))
-    )
-
-    if not is_valid_cron:
-        raise CLIPipeException(FeedbackManager.error_creating_copy_pipe_invalid_cron(schedule_cron=schedule_cron))
-
-    mode = copy_node["params"].get("mode", CopyModes.APPEND)
-    is_valid_mode = CopyModes.is_valid(mode)
-
-    if not is_valid_mode:
-        raise CLIPipeException(FeedbackManager.error_creating_copy_pipe_invalid_mode(mode=mode))
-
-    if not pipe:
-        return
-
-    pipe_name = pipe["name"]
-    pipe_type = pipe["type"]
-
-    if pipe_type == PipeTypes.ENDPOINT:
-        await tb_client.pipe_remove_endpoint(pipe_name, pipe["endpoint"])
-
-    if pipe_type == PipeTypes.DATA_SINK:
-        await tb_client.pipe_remove_sink(pipe_name, pipe["sink_node"])
-
-    if pipe_type == PipeTypes.STREAM:
-        await tb_client.pipe_remove_stream(pipe_name, pipe["stream_node"])
-
-
-async def check_sink_pipe(pipe, sink_node, tb_client: TinyB):
-    if not sink_node["export_params"]:
-        return
-
-    if not pipe:
-        return
-
-    pipe_name = pipe["name"]
-    pipe_type = pipe["type"]
-
-    schedule_cron = sink_node["export_params"].get("schedule_cron", "")
-    is_valid_cron = not schedule_cron or (schedule_cron and croniter.is_valid(schedule_cron))
-
-    if not is_valid_cron:
-        raise CLIPipeException(FeedbackManager.error_creating_sink_pipe_invalid_cron(schedule_cron=schedule_cron))
-
-    if pipe_type == PipeTypes.ENDPOINT:
-        await tb_client.pipe_remove_endpoint(pipe_name, pipe["endpoint"])
-
-    if pipe_type == PipeTypes.COPY:
-        await tb_client.pipe_remove_copy(pipe_name, pipe["copy_node"])
-
-    if pipe_type == PipeTypes.STREAM:
-        await tb_client.pipe_remove_stream(pipe_name, pipe["stream_node"])
-
-
-async def check_stream_pipe(pipe, stream_node, tb_client: TinyB):
-    if not stream_node["params"]:
-        return
-
-    if not pipe:
-        return
-
-    pipe_name = pipe["name"]
-    pipe_type = pipe["type"]
-
-    if pipe_type == PipeTypes.ENDPOINT:
-        await tb_client.pipe_remove_endpoint(pipe_name, pipe["endpoint"])
-
-    if pipe_type == PipeTypes.COPY:
-        await tb_client.pipe_remove_copy(pipe_name, pipe["copy_node"])
-
-    if pipe_type == PipeTypes.DATA_SINK:
-        await tb_client.pipe_remove_sink(pipe_name, pipe["sink_node"])
-
-
 def show_materialized_view_warnings(warnings):
     """
     >>> show_materialized_view_warnings([{'code': 'SIM', 'weight': 1}])

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/datafile/playground.py

@@ -15,6 +15,7 @@ from tinybird.client import TinyB
 from tinybird.sql import parse_table_structure, schema_to_sql_columns
 from tinybird.sql_template import get_used_tables_in_template, render_sql_template
 from tinybird.tb.modules.common import get_ca_pem_content
+from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.datafile.build_datasource import is_datasource
 from tinybird.tb.modules.datafile.build_pipe import (
     get_target_materialized_data_source_name,
@@ -48,6 +49,7 @@ from tinybird.tb.modules.project import Project
 
 async def folder_playground(
     project: Project,
+    config: CLIConfig,
     tb_client: TinyB,
     filenames: Optional[List[str]] = None,
     is_internal: bool = False,
@@ -163,6 +165,7 @@ async def folder_playground(
                     try:
                         await exec_file(
                             to_run[name],
+                            config,
                             tb_client,
                             force,
                             check,
@@ -390,6 +393,7 @@ async def name_matches_existing_resource(resource: str, name: str, tb_client: Ti
 
 async def exec_file(
     r: Dict[str, Any],
+    config: CLIConfig,
     tb_client: TinyB,
     force: bool,
     check: bool,
@@ -426,6 +430,7 @@ async def exec_file(
     if r["resource"] == "pipes":
         await new_pipe(
             r,
+            config,
             tb_client,
             force,
             check,

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/deployment.py

@@ -343,7 +343,15 @@ def create_deployment(
 
         feedback = result.get("deployment", {}).get("feedback", [])
         for f in feedback:
-            click.echo(FeedbackManager.warning(message=f"△ {f.get('level')}: {f.get('resource')}: {f.get('message')}"))
+            if f.get("level", "").upper() == "ERROR":
+                feedback_func = FeedbackManager.error
+                feedback_icon = ""
+            else:
+                feedback_func = FeedbackManager.warning
+                feedback_icon = "△ "
+            resource = f.get("resource")
+            resource_bit = f"{resource}: " if resource else ""
+            click.echo(feedback_func(message=f"{feedback_icon}{f.get('level')}: {resource_bit}{f.get('message')}"))
 
         deploy_errors = result.get("deployment", {}).get("errors")
         for deploy_error in deploy_errors:

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/local_common.py

@@ -27,7 +27,7 @@ async def get_tinybird_local_config(config_obj: Dict[str, Any], build: bool = Fa
     It uses the tokens from tinybird local
     """
     path = config_obj.get("path")
-    config = CLIConfig.get_project_config(path)
+    config = CLIConfig.get_project_config()
 
     try:
         # ruff: noqa: ASYNC210

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/login.py

@@ -1,4 +1,5 @@
 import http.server
+import os
 import socketserver
 import threading
 import time
@@ -159,7 +160,8 @@ async def login(host: str, auth_host: str, workspace: str):
             if k in ws:
                 cli_config[k] = ws[k]
 
-        cli_config.persist_to_file()
+        path = os.path.join(os.getcwd(), ".tinyb")
+        cli_config.persist_to_file(override_with_path=path)
         click.echo(FeedbackManager.gray(message="\nWorkspace: ") + FeedbackManager.info(message=ws["name"]))
         click.echo(FeedbackManager.gray(message="User: ") + FeedbackManager.info(message=ws["user_email"]))
         click.echo(FeedbackManager.gray(message="Host: ") + FeedbackManager.info(message=host))

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/playground.py

@@ -62,6 +62,7 @@ def playground(
     """Build the project in Tinybird Local."""
     project: Project = ctx.ensure_object(dict)["project"]
     tb_client: TinyB = ctx.ensure_object(dict)["client"]
+    config: CLIConfig = ctx.ensure_object(dict)["config"]
     context.disable_template_security_validation.set(True)
 
     async def process(filenames: List[str], watch: bool = False):
@@ -69,11 +70,11 @@ def playground(
         if len(datafiles) > 0:
             check_filenames(filenames=datafiles)
             await folder_playground(
-                project, tb_client, filenames=datafiles, is_internal=False, current_ws=None, local_ws=None
+                project, config, tb_client, filenames=datafiles, is_internal=False, current_ws=None, local_ws=None
             )
         if len(filenames) > 0 and watch:
             filename = filenames[0]
-            await build_and_print_resource(tb_client, filename)
+            await build_and_print_resource(config, tb_client, filename)
 
     datafiles = project.get_project_files()
     filenames = datafiles
@@ -112,11 +113,10 @@ def playground(
     shell.run()
 
 
-async def build_and_print_resource(tb_client: TinyB, filename: str):
+async def build_and_print_resource(config: CLIConfig, tb_client: TinyB, filename: str):
     resource_path = Path(filename)
     name = resource_path.stem
     playground_name = name if filename.endswith(".pipe") else None
-    config = CLIConfig().get_project_config()
     user_client = deepcopy(tb_client)
     user_client.token = config.get_user_token() or ""
     cli_params = {}

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/project.py

@@ -1,10 +1,8 @@
 import glob
-import os
 import re
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.datafile.common import Datafile
 from tinybird.tb.modules.datafile.parse_datasource import parse_datasource
 from tinybird.tb.modules.datafile.parse_pipe import parse_pipe
@@ -13,12 +11,12 @@ from tinybird.tb.modules.datafile.parse_pipe import parse_pipe
 class Project:
     extensions = ("datasource", "pipe")
 
-    def __init__(self, folder: Optional[str] = None):
-        self.folder = folder or os.getcwd()
-        self.path = Path(self.folder)
+    def __init__(self, folder: str):
+        self.folder = folder
 
-    def get_config(self) -> CLIConfig:
-        return CLIConfig.get_project_config(self.folder)
+    @property
+    def path(self) -> Path:
+        return Path(self.folder)
 
     @property
     def vendor_path(self) -> str:

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/shell.py

@@ -340,12 +340,12 @@ class Shell:
 
 def print_table_formatted(res: dict, name: str):
     data = []
-    limit = 5
-    for d in res["data"][:5]:
+    limit = 20
+    for d in res["data"][:limit]:
         data.append(d.values())
     meta = res["meta"]
-    row_count = res.get("rows", 0)
     stats = res.get("statistics", {})
+    row_count = stats.get("rows_read", 0)
     elapsed = stats.get("elapsed", 0)
     cols = len(meta)
     try:

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird/tb/modules/test.py

@@ -75,6 +75,7 @@ async def test_create(ctx: click.Context, name_or_filename: str, prompt: str) ->
     """
     project: Project = ctx.ensure_object(dict)["project"]
     client: TinyB = ctx.ensure_object(dict)["client"]
+    config: CLIConfig = ctx.ensure_object(dict)["config"]
     root_path = Path(project.folder)
     folder = project.folder
     try:
@@ -106,7 +107,6 @@ async def test_create(ctx: click.Context, name_or_filename: str, prompt: str) ->
             content=pipe_content,
             parameters=parameters or "No parameters",
         )
-        config = CLIConfig.get_project_config(folder)
         user_token = config.get_user_token()
         if not user_token:
             raise CLIException(FeedbackManager.error(message="No user token found"))

{tinybird-0.0.1.dev77 → tinybird-0.0.1.dev79}/tinybird.egg-info/PKG-INFO

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