tinybird 0.0.1.dev34__py3-none-any.whl → 0.0.1.dev36__py3-none-any.whl

tinybird/tb/modules/endpoint.py

@@ -0,0 +1,187 @@
+# This is a command file for our CLI. Please keep it clean.
+#
+# - 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 json
+import re
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlencode
+
+import click
+import humanfriendly
+import requests
+from click import Context
+
+from tinybird.client import AuthNoTokenException, DoesNotExistException, TinyB
+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.datafile.common import get_name_version
+from tinybird.tb.modules.exceptions import CLIPipeException
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+@cli.group(hidden=True)
+@click.pass_context
+def endpoint(ctx):
+    """Endpoint commands"""
+
+
+@endpoint.command(name="ls")
+@click.option("--match", default=None, help="Retrieve any resourcing matching the pattern. eg --match _test")
+@click.option(
+    "--format",
+    "format_",
+    type=click.Choice(["json"], case_sensitive=False),
+    default=None,
+    help="Force a type of the output",
+)
+@click.pass_context
+@coro
+async def endpoint_ls(ctx: Context, match: str, format_: str):
+    """List endpoints"""
+
+    client: TinyB = ctx.ensure_object(dict)["client"]
+    pipes = await client.pipes(dependencies=False, node_attrs="name", attrs="name,updated_at,endpoint,url")
+    endpoints = [p for p in pipes if p.get("endpoint")]
+    endpoints = sorted(endpoints, key=lambda p: p["updated_at"])
+    tokens = await client.tokens()
+    columns = ["name", "updated at", "nodes", "url"]
+    table_human_readable = []
+    table_machine_readable = []
+    pattern = re.compile(match) if match else None
+    for t in endpoints:
+        tk = get_name_version(t["name"])
+        if pattern and not pattern.search(tk["name"]):
+            continue
+        token = get_endpoint_token(tokens, tk["name"])
+        endpoint_url = build_endpoint_url(client, tk["name"], token)
+        table_human_readable.append((tk["name"], t["updated_at"][:-7], len(t["nodes"]), endpoint_url))
+        table_machine_readable.append(
+            {
+                "name": tk["name"],
+                "updated at": t["updated_at"][:-7],
+                "nodes": len(t["nodes"]),
+                "url": endpoint_url,
+            }
+        )
+
+    if not format_:
+        click.echo(FeedbackManager.info_pipes())
+        echo_safe_humanfriendly_tables_format_smart_table(table_human_readable, column_names=columns)
+        click.echo("\n")
+    elif format_ == "json":
+        click.echo(json.dumps({"pipes": table_machine_readable}, indent=2))
+    else:
+        raise CLIPipeException(FeedbackManager.error_pipe_ls_type())
+
+
+@endpoint.command(name="token")
+@click.argument("pipe_name")
+@click.pass_context
+@coro
+async def endpoint_token(ctx: click.Context, pipe_name: str):
+    """Retrieve a token to read an endpoint"""
+    client: TinyB = ctx.ensure_object(dict)["client"]
+
+    try:
+        await client.pipe_file(pipe_name)
+    except DoesNotExistException:
+        raise CLIPipeException(FeedbackManager.error_pipe_does_not_exist(pipe=pipe_name))
+
+    tokens = await client.tokens()
+    token = get_endpoint_token(tokens, pipe_name)
+    if token:
+        click.echo(token)
+    else:
+        click.echo(FeedbackManager.warning_token_pipe(pipe=pipe_name))
+
+
+@endpoint.command(
+    name="data",
+    context_settings=dict(
+        allow_extra_args=True,
+        ignore_unknown_options=True,
+    ),
+)
+@click.argument("pipe")
+@click.option("--query", default=None, help="Run SQL over endpoint results")
+@click.option(
+    "--format", "format_", type=click.Choice(["json", "csv"], case_sensitive=False), help="Return format (CSV, JSON)"
+)
+@click.pass_context
+@coro
+async def endpoint_data(ctx: Context, pipe: str, query: str, format_: str):
+    """Print data returned by an endpoint
+
+    Syntax: tb endpoint data <pipe_name> --param_name value --param2_name value2 ...
+    """
+
+    client: TinyB = ctx.ensure_object(dict)["client"]
+    params = {ctx.args[i][2:]: ctx.args[i + 1] for i in range(0, len(ctx.args), 2)}
+    req_format = "json" if not format_ else format_.lower()
+    try:
+        res = await client.pipe_data(pipe, format=req_format, sql=query, params=params)
+    except AuthNoTokenException:
+        raise
+    except Exception as e:
+        raise CLIPipeException(FeedbackManager.error_exception(error=str(e)))
+
+    if not format_:
+        stats = res["statistics"]
+        seconds = stats["elapsed"]
+        rows_read = humanfriendly.format_number(stats["rows_read"])
+        bytes_read = humanfriendly.format_size(stats["bytes_read"])
+
+        click.echo(FeedbackManager.success_print_pipe(pipe=pipe))
+        click.echo(FeedbackManager.info_query_stats(seconds=seconds, rows=rows_read, bytes=bytes_read))
+
+        if not res["data"]:
+            click.echo(FeedbackManager.info_no_rows())
+        else:
+            echo_safe_humanfriendly_tables_format_smart_table(
+                data=[d.values() for d in res["data"]], column_names=res["data"][0].keys()
+            )
+        click.echo("\n")
+    elif req_format == "json":
+        click.echo(json.dumps(res))
+    else:
+        click.echo(res)
+
+
+@endpoint.command(name="url")
+@click.argument("pipe")
+@click.pass_context
+@coro
+async def endpoint_url(ctx: Context, pipe: str):
+    """Print the URL of an endpoint"""
+    client: TinyB = ctx.ensure_object(dict)["client"]
+    tokens = await client.tokens()
+    token = get_endpoint_token(tokens, pipe)
+    click.echo(build_endpoint_url(client, pipe, token))
+
+
+def build_endpoint_url(tb_client: TinyB, pipe_name: str, token: Optional[str]) -> str:
+    try:
+        token = token or tb_client.token
+        example_params = {
+            "format": "json",
+            "pipe": pipe_name,
+            "q": "",
+            "token": token,
+        }
+        response = requests.get(f"{tb_client.host}/examples/query.http?{urlencode(example_params)}")
+        return response.text.replace("http://localhost:8001", tb_client.host)
+    except Exception:
+        return None
+
+
+def get_endpoint_token(tokens: List[Dict[str, Any]], pipe_name: str) -> Optional[str]:
+    token = None
+    for t in tokens:
+        for scope in t["scopes"]:
+            if scope["type"] == "PIPES:READ" and scope["resource"] == pipe_name:
+                token = t["token"]
+                break
+
+    return token

tinybird/tb/modules/llm.py

@@ -1,19 +1,16 @@
-from copy import deepcopy
-from typing import Optional
-
-from tinybird.client import TinyB
+import requests
 
 
 class LLM:
     def __init__(
         self,
+        host: str,
         user_token: str,
-        client: TinyB,
     ):
-        self.user_client = deepcopy(client)
-        self.user_client.token = user_token
+        self.host = host
+        self.user_token = user_token
 
-    async def ask(self, system_prompt: str, prompt: Optional[str] = None) -> str:
+    def ask(self, system_prompt: str, prompt: str) -> str:
         """
         Calls the model with the given prompt and returns the response.
 
@@ -25,14 +22,11 @@ class LLM:
             str: The response from the language model.
         """
 
-        data = {"system": system_prompt}
-
-        if prompt:
-            data["prompt"] = prompt
+        data = {"system": system_prompt, "prompt": prompt}
 
-        response = await self.user_client._req(
-            "/v0/llm",
-            method="POST",
+        response = requests.post(
+            f"{self.host}/v0/llm",
+            headers={"Authorization": f"Bearer {self.user_token}"},
             data=data,
         )
-        return response.get("result", "")
+        return response.json().get("result", "")

tinybird/tb/modules/llm_utils.py

@@ -22,3 +22,90 @@ def parse_xml(text: str, tag: str) -> List[str]:
     Parses the text for the specified XML tag and returns a list of the contents of each tag.
     """
     return re.findall(f"<{tag}.*?>(.*?)</{tag}>", text, re.DOTALL)
+
+
+def generate(llm_call, task: str, context: str = "") -> tuple[str, str]:
+    """Generate and improve a solution based on feedback."""
+    task = f"<task>\n{task}\n</task>"
+    full_prompt = (
+        f"{generator_prompt}\n<context>\n{context}\n</context>\n{task}" if context else f"{generator_prompt}\n{task}"
+    )
+    response = llm_call(full_prompt)
+    thoughts = extract_xml(response, "thoughts")
+    result = extract_xml(response, "response")
+
+    return thoughts, result
+
+
+def evaluate(llm_call, content: str, task: str) -> tuple[str, str]:
+    """Evaluate if a solution meets requirements."""
+    full_prompt = f"{evaluator_prompt}\n<original_task>\n{task}\n</original_task>\n<content_to_evaluate>\n{content}\n</content_to_evaluate>"
+    response = llm_call(full_prompt)
+    evaluation = extract_xml(response, "evaluation")
+    feedback = extract_xml(response, "feedback")
+
+    return evaluation, feedback
+
+
+def loop(llm_call, task: str) -> str:
+    """Keep generating and evaluating until requirements are met."""
+    memory = []
+    chain_of_thought = []
+
+    thoughts, result = generate(llm_call, task)
+    memory.append(result)
+    chain_of_thought.append({"thoughts": thoughts, "result": result})
+
+    attempts = 0
+    while True:
+        if attempts > 5:
+            raise Exception("Failed to generate a valid solution")
+
+        evaluation, feedback = evaluate(llm_call, result, task)
+        if evaluation == "PASS":
+            return result
+
+        context = "\n".join(
+            [
+                "Previous attempts:",
+                *[f"- {m}" for m in memory],
+                f"\nFeedback: {feedback}",
+            ]
+        )
+
+        thoughts, result = generate(llm_call, task, context)
+        memory.append(result)
+        chain_of_thought.append({"thoughts": thoughts, "result": result})
+
+        attempts += 1
+
+
+evaluator_prompt = """
+Evaluate this following code implementation for code correctness taking into account the user prompt and the instructions provided.
+
+You should be evaluating only and not attemping to solve the task.
+Only output "PASS" if all criteria are met and the code won't fail at runtime.
+Output your evaluation concisely in the following format:
+
+<evaluation>PASS or FAIL</evaluation>
+<feedback>
+[What is wrong with the code and how to fix it]
+</feedback>
+"""
+
+generator_prompt = """
+Your goal is to complete the task based on <task> tag. If there are feedback 
+from your previous generations, you should reflect on them to improve your solution
+
+Output your answer concisely in the following format: 
+
+<thoughts>
+[Your understanding of the task and feedback and how you plan to improve]
+</thoughts>
+
+<response>
+[Your code implementation here]
+</response>
+
+The code implementation should not be wrapped in any markdown format.
+"""

tinybird/tb/modules/local.py

@@ -30,7 +30,10 @@ def start_tinybird_local(
 
     if (
         pull_show_prompt
-        and click.prompt(FeedbackManager.warning(message="△ New version detected, download? [y/N]")).lower() == "y"
+        and click.prompt(
+            FeedbackManager.warning(message="△ New version detected, download? [y/N]"), default="n"
+        ).lower()
+        == "y"
     ):
         click.echo(FeedbackManager.info(message="* Downloading latest version of Tinybird Local..."))
         pull_required = True

tinybird/tb/modules/local_common.py

@@ -17,11 +17,11 @@ TB_LOCAL_HOST = f"http://localhost:{TB_LOCAL_PORT}"
 
 async def get_tinybird_local_client(path: Optional[str] = None) -> TinyB:
     """Get a Tinybird client connected to the local environment."""
-    config = await get_client_config_for_build(path)
+    config = await get_tinybird_local_config(path)
     return config.get_client(host=TB_LOCAL_HOST)
 
 
-async def get_client_config_for_build(path: Optional[str] = None) -> CLIConfig:
+async def get_tinybird_local_config(path: Optional[str] = None) -> CLIConfig:
     """Craft a client config with a workspace name based on the path of the project files
 
     It uses the tokens from tinybird local

tinybird/tb/modules/mock.py

@@ -24,7 +24,7 @@ from tinybird.tb.modules.local_common import get_tinybird_local_client
     default="Use the datasource schema to generate sample data",
     help="Extra context to use for data generation",
 )
-@click.option("--folder", type=str, default=".", help="Folder where datafiles will be placed")
+@click.option("--folder", type=str, default=os.getcwd(), help="Folder where datafiles will be placed")
 @coro
 async def mock(datasource: str, rows: int, prompt: str, folder: str) -> None:
     """Load sample data into a Data Source.
@@ -67,11 +67,10 @@ async def mock(datasource: str, rows: int, prompt: str, folder: str) -> None:
         except Exception:
             click.echo(FeedbackManager.error(message="This action requires authentication. Run 'tb login' first."))
             return
-        user_client.token = user_token
-        llm = LLM(user_token=user_token, client=user_client)
+        llm = LLM(user_token=user_token, host=user_client.host)
         tb_client = await get_tinybird_local_client(os.path.abspath(folder))
         prompt = f"<datasource_schema>{datasource_content}</datasource_schema>\n<user_input>{prompt}</user_input>"
-        response = await llm.ask(system_prompt=mock_prompt(rows), prompt=prompt)
+        response = llm.ask(system_prompt=mock_prompt(rows), prompt=prompt)
         sql = extract_xml(response, "sql")
         if os.environ.get("TB_DEBUG", "") != "":
             logging.debug(sql)

tinybird/tb/modules/pipe.py

@@ -4,9 +4,7 @@
 # - But please, **do not** interleave utility functions and command definitions.
 
 import json
-import os
 import re
-from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
 import click
@@ -14,7 +12,6 @@ import humanfriendly
 from click import Context
 
 from tinybird.client import AuthNoTokenException, DoesNotExistException, TinyB
-from tinybird.config import DEFAULT_API_HOST
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import (
     coro,
@@ -22,8 +19,7 @@ from tinybird.tb.modules.common import (
     echo_safe_humanfriendly_tables_format_smart_table,
     wait_job,
 )
-from tinybird.tb.modules.datafile.build import process_file
-from tinybird.tb.modules.datafile.common import PipeNodeTypes, PipeTypes, get_name_version
+from tinybird.tb.modules.datafile.common import PipeTypes, get_name_version
 from tinybird.tb.modules.exceptions import CLIPipeException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -46,37 +42,6 @@ def pipe_sink(ctx: Context) -> None:
     """Sink Pipe commands"""
 
 
-@pipe.command(
-    name="generate",
-    short_help="Generates a pipe file based on a sql query. Example: tb pipe generate my_pipe 'select * from existing_datasource'",
-)
-@click.argument("name")
-@click.argument("query")
-@click.option("--force", is_flag=True, default=False, help="Override existing files")
-@click.pass_context
-def generate_pipe(ctx: click.Context, name: str, query: str, force: bool):
-    pipefile = f"""
-NODE endpoint
-DESCRIPTION >
-    Generated from the command line
-SQL >
-    {query}
-
-    """
-    base = Path("endpoints")
-    if not base.exists():
-        base = Path()
-    f = base / (f"{name}.pipe")
-    if not f.exists() or force:
-        with open(f"{f}", "w") as file:
-            file.write(pipefile)
-        click.echo(FeedbackManager.success_generated_pipe(file=f))
-    else:
-        raise CLIPipeException(
-            FeedbackManager.error_exception(error=f"File {f} already exists, use --force to override")
-        )
-
-
 @pipe.command(name="stats")
 @click.argument("pipes", nargs=-1)
 @click.option(
@@ -288,224 +253,6 @@ async def pipe_populate(
         await wait_job(cl, job_id, job_url, "Populating")
 
 
-@pipe.command(name="unlink")
-@click.argument("pipe_name_or_id")
-@click.argument("node_uid", default=None, required=False)
-@click.pass_context
-@coro
-async def pipe_unlink_output_node(
-    ctx: click.Context,
-    pipe_name_or_id: str,
-    node_uid: Optional[str] = None,
-):
-    """Unlink the output of a pipe. Works for Materialized Views, Copy Pipes, and Sinks."""
-    client: TinyB = ctx.ensure_object(dict)["client"]
-
-    try:
-        pipe = await client.pipe(pipe_name_or_id)
-
-        if pipe["type"] not in [PipeTypes.MATERIALIZED, PipeTypes.COPY, PipeTypes.DATA_SINK]:
-            raise CLIPipeException(FeedbackManager.error_unlinking_pipe_not_linked(pipe=pipe_name_or_id))
-
-        if pipe["type"] == PipeTypes.MATERIALIZED:
-            click.echo(FeedbackManager.info_unlinking_materialized_pipe(pipe=pipe["name"]))
-
-            if not node_uid:
-                for node in pipe["nodes"]:
-                    if "materialized" in node and node["materialized"] is not None:
-                        node_uid = node["id"]
-                        break
-
-            if not node_uid:
-                raise CLIPipeException(FeedbackManager.error_unlinking_pipe_not_linked(pipe=pipe_name_or_id))
-            else:
-                await client.pipe_unlink_materialized(pipe["name"], node_uid)
-                click.echo(FeedbackManager.success_pipe_unlinked(pipe=pipe["name"]))
-
-        if pipe["type"] == PipeTypes.COPY:
-            click.echo(FeedbackManager.info_unlinking_copy_pipe(pipe=pipe["name"]))
-
-            if not node_uid:
-                for node in pipe["nodes"]:
-                    if node["node_type"] == "copy":
-                        node_uid = node["id"]
-                        break
-
-            if not node_uid:
-                raise CLIPipeException(FeedbackManager.error_unlinking_pipe_not_linked(pipe=pipe_name_or_id))
-            else:
-                await client.pipe_remove_copy(pipe["name"], node_uid)
-                click.echo(FeedbackManager.success_pipe_unlinked(pipe=pipe["name"]))
-
-        if pipe["type"] == PipeTypes.DATA_SINK:
-            click.echo(FeedbackManager.info_unlinking_sink_pipe(pipe=pipe["name"]))
-
-            if not node_uid:
-                for node in pipe["nodes"]:
-                    if node["node_type"] == "sink":
-                        node_uid = node["id"]
-                        break
-
-            if not node_uid:
-                raise CLIPipeException(FeedbackManager.error_unlinking_pipe_not_linked(pipe=pipe_name_or_id))
-            else:
-                await client.pipe_remove_sink(pipe["name"], node_uid)
-                click.echo(FeedbackManager.success_pipe_unlinked(pipe=pipe["name"]))
-
-        if pipe["type"] == PipeTypes.STREAM:
-            click.echo(FeedbackManager.info_unlinking_stream_pipe(pipe=pipe["name"]))
-            node_uid = next((node["id"] for node in pipe["nodes"] if node["node_type"] == PipeNodeTypes.STREAM), None)
-
-            if not node_uid:
-                raise CLIPipeException(FeedbackManager.error_unlinking_pipe_not_linked(pipe=pipe_name_or_id))
-            else:
-                await client.pipe_remove_stream(pipe["name"], node_uid)
-                click.echo(FeedbackManager.success_pipe_unlinked(pipe=pipe["name"]))
-
-    except AuthNoTokenException:
-        raise
-    except Exception as e:
-        raise CLIPipeException(FeedbackManager.error_exception(error=e))
-
-
-@pipe.command(name="append")
-@click.argument("pipe_name_or_uid")
-@click.argument("sql")
-@click.pass_context
-@coro
-async def pipe_append_node(
-    ctx: click.Context,
-    pipe_name_or_uid: str,
-    sql: str,
-):
-    """Append a node to a pipe"""
-
-    client = ctx.ensure_object(dict)["client"]
-    try:
-        res = await client.pipe_append_node(pipe_name_or_uid, sql)
-        click.echo(
-            FeedbackManager.success_node_changed(
-                pipe_name_or_uid=pipe_name_or_uid, node_name=res["name"], node_id=res["id"]
-            )
-        )
-    except DoesNotExistException:
-        raise CLIPipeException(FeedbackManager.error_pipe_does_not_exist(pipe=pipe_name_or_uid))
-
-
-async def common_pipe_publish_node(ctx: click.Context, pipe_name_or_id: str, node_uid: Optional[str] = None):
-    """Change the published node of a pipe"""
-    client: TinyB = ctx.ensure_object(dict)["client"]
-    host = ctx.ensure_object(dict)["config"].get("host", DEFAULT_API_HOST)
-
-    try:
-        pipe = await client.pipe(pipe_name_or_id)
-        if not node_uid:
-            node = pipe["nodes"][-1]["name"]
-            click.echo(FeedbackManager.info_using_node(node=node))
-        else:
-            node = node_uid
-
-        await client.pipe_set_endpoint(pipe_name_or_id, node)
-        click.echo(FeedbackManager.success_node_published(pipe=pipe_name_or_id, host=host))
-    except AuthNoTokenException:
-        raise
-    except DoesNotExistException:
-        raise CLIPipeException(FeedbackManager.error_pipe_does_not_exist(pipe=pipe_name_or_id))
-    except Exception as e:
-        raise CLIPipeException(FeedbackManager.error_exception(error=e))
-
-
-@pipe.command(name="publish")
-@click.argument("pipe_name_or_id")
-@click.argument("node_uid", default=None, required=False)
-@click.pass_context
-@coro
-async def pipe_publish_node(
-    ctx: click.Context,
-    pipe_name_or_id: str,
-    node_uid: Optional[str] = None,
-):
-    """Change the published node of a pipe"""
-
-    await common_pipe_publish_node(ctx, pipe_name_or_id, node_uid)
-
-
-@pipe.command(name="unpublish")
-@click.argument("pipe_name_or_id")
-@click.argument("node_uid", default=None, required=False)
-@click.pass_context
-@coro
-async def pipe_unpublish_node(
-    ctx: click.Context,
-    pipe_name_or_id: str,
-    node_uid: Optional[str] = None,
-):
-    """Unpublish the endpoint of a pipe"""
-    client: TinyB = ctx.ensure_object(dict)["client"]
-    host = ctx.ensure_object(dict)["config"].get("host", DEFAULT_API_HOST)
-
-    try:
-        pipe = await client.pipe(pipe_name_or_id)
-
-        if not pipe["endpoint"]:
-            raise CLIPipeException(FeedbackManager.error_remove_no_endpoint())
-
-        if not node_uid:
-            node = pipe["endpoint"]
-            click.echo(FeedbackManager.info_using_node(node=node))
-        else:
-            node = node_uid
-
-        await client.pipe_remove_endpoint(pipe_name_or_id, node)
-        click.echo(FeedbackManager.success_node_unpublished(pipe=pipe_name_or_id, host=host))
-    except AuthNoTokenException:
-        raise
-    except DoesNotExistException:
-        raise CLIPipeException(FeedbackManager.error_pipe_does_not_exist(pipe=pipe_name_or_id))
-    except Exception as e:
-        raise CLIPipeException(FeedbackManager.error_exception(error=e))
-
-
-@pipe.command(name="set_endpoint")
-@click.argument("pipe_name_or_id")
-@click.argument("node_uid", default=None, required=False)
-@click.pass_context
-@coro
-async def pipe_published_node(
-    ctx: click.Context,
-    pipe_name_or_id: str,
-    node_uid: Optional[str] = None,
-    no_live_warning: bool = False,
-):
-    """Same as 'publish', change the published node of a pipe"""
-
-    await common_pipe_publish_node(ctx, pipe_name_or_id, node_uid)
-
-
-@pipe.command(name="rm")
-@click.argument("pipe_name_or_id")
-@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
-@click.pass_context
-@coro
-async def pipe_delete(ctx: click.Context, pipe_name_or_id: str, yes: bool):
-    """Delete a pipe. pipe_name_or_id can be either a Pipe name or id in the Workspace or a local path to a .pipe file"""
-
-    client: TinyB = ctx.ensure_object(dict)["client"]
-
-    file_path = pipe_name_or_id
-    if os.path.exists(file_path):
-        result = await process_file(file_path, client)
-        pipe_name_or_id = result[0]["name"]
-
-    if yes or click.confirm(FeedbackManager.warning_confirm_delete_pipe(pipe=pipe_name_or_id)):
-        try:
-            await client.pipe_delete(pipe_name_or_id)
-        except DoesNotExistException:
-            raise CLIPipeException(FeedbackManager.error_pipe_does_not_exist(pipe=pipe_name_or_id))
-
-        click.echo(FeedbackManager.success_delete_pipe(pipe=pipe_name_or_id))
-
-
 @pipe.command(name="token_read")
 @click.argument("pipe_name")
 @click.pass_context

tinybird/tb/modules/shell.py

@@ -196,6 +196,14 @@ class Shell:
             history=self.history,
         )
 
+    @property
+    def datasources(self):
+        return [Path(f).stem for f in glob.glob(f"{self.folder}/**/*.datasource", recursive=True)]
+
+    @property
+    def pipes(self):
+        return [Path(f).stem for f in glob.glob(f"{self.folder}/**/*.pipe", recursive=True)]
+
     def get_history(self):
         try:
             history_file = os.path.expanduser("~/.tb_history")
@@ -222,7 +230,6 @@ class Shell:
         line = argline.strip()
         if not line:
             return
-
         # Implement the command logic here
         # Replace do_* methods with equivalent logic:
         command_parts = line.split(maxsplit=1)