tinybird 0.0.1.dev26__py3-none-any.whl → 0.0.1.dev28__py3-none-any.whl

tinybird/tb/modules/deploy.py

@@ -0,0 +1,254 @@
+import glob
+import json
+import logging
+import time
+from pathlib import Path
+from typing import List
+
+import click
+import requests
+
+from tinybird.tb.modules.cli import cli
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def project_files(project_path: Path) -> List[str]:
+    project_file_extensions = ("datasource", "pipe")
+    project_files = []
+    for extension in project_file_extensions:
+        for project_file in glob.glob(f"{project_path}/**/*.{extension}", recursive=True):
+            logging.debug(f"Found project file: {project_file}")
+            project_files.append(project_file)
+    return project_files
+
+
+def promote_deployment(host: str, headers: dict) -> None:
+    TINYBIRD_API_URL = host + "/v1/deployments"
+    r = requests.get(TINYBIRD_API_URL, headers=headers)
+    result = r.json()
+    logging.debug(json.dumps(result, indent=2))
+
+    deployments = result.get("deployments")
+    if not deployments:
+        click.echo(FeedbackManager.error(message="No deployments found"))
+        return
+
+    if len(deployments) < 2:
+        click.echo(FeedbackManager.error(message="Only one deployment found"))
+        return
+
+    last_deployment, candidate_deployment = deployments[0], deployments[1]
+
+    if candidate_deployment.get("status") != "data_ready":
+        click.echo(FeedbackManager.error(message="Current deployment is not ready"))
+        return
+
+    if candidate_deployment.get("live"):
+        click.echo(FeedbackManager.error(message="Candidate deployment is already live"))
+    else:
+        click.echo(FeedbackManager.success(message="Promoting deployment"))
+
+        TINYBIRD_API_URL = host + f"/v1/deployments/{candidate_deployment.get('id')}/set-live"
+        r = requests.post(TINYBIRD_API_URL, headers=headers)
+        result = r.json()
+        logging.debug(json.dumps(result, indent=2))
+
+    click.echo(FeedbackManager.success(message="Removing old deployment"))
+
+    TINYBIRD_API_URL = host + f"/v1/deployments/{last_deployment.get('id')}"
+    r = requests.delete(TINYBIRD_API_URL, headers=headers)
+    result = r.json()
+    logging.debug(json.dumps(result, indent=2))
+
+    click.echo(FeedbackManager.success(message="Deployment promoted successfully"))
+
+
+def rollback_deployment(host: str, headers: dict) -> None:
+    TINYBIRD_API_URL = host + "/v1/deployments"
+    r = requests.get(TINYBIRD_API_URL, headers=headers)
+    result = r.json()
+    logging.debug(json.dumps(result, indent=2))
+
+    deployments = result.get("deployments")
+    if not deployments:
+        click.echo(FeedbackManager.error(message="No deployments found"))
+        return
+
+    if len(deployments) < 2:
+        click.echo(FeedbackManager.error(message="Only one deployment found"))
+        return
+
+    previous_deployment, current_deployment = deployments[0], deployments[1]
+
+    if previous_deployment.get("status") != "data_ready":
+        click.echo(FeedbackManager.error(message="Previous deployment is not ready"))
+        return
+
+    if previous_deployment.get("live"):
+        click.echo(FeedbackManager.error(message="Previous deployment is already live"))
+    else:
+        click.echo(FeedbackManager.success(message="Promoting previous deployment"))
+
+        TINYBIRD_API_URL = host + f"/v1/deployments/{previous_deployment.get('id')}/set-live"
+        r = requests.post(TINYBIRD_API_URL, headers=headers)
+        result = r.json()
+        logging.debug(json.dumps(result, indent=2))
+
+    click.echo(FeedbackManager.success(message="Removing current deployment"))
+
+    TINYBIRD_API_URL = host + f"/v1/deployments/{current_deployment.get('id')}"
+    r = requests.delete(TINYBIRD_API_URL, headers=headers)
+    result = r.json()
+    logging.debug(json.dumps(result, indent=2))
+
+    click.echo(FeedbackManager.success(message="Deployment rolled back successfully"))
+
+
+@cli.command()
+@click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
+@click.option(
+    "--wait/--no-wait",
+    is_flag=True,
+    default=False,
+    help="Wait for deploy to finish. Disabled by default.",
+)
+@click.option(
+    "--auto/--no-auto",
+    is_flag=True,
+    default=False,
+    help="Auto-promote the deployment. Only works if --wait is enabled. Disabled by default.",
+)
+def deploy(project_path: Path, wait: bool, auto: bool) -> None:
+    """
+    Validate and deploy the project server side.
+    """
+    # TODO: This code is duplicated in build_server.py
+    # Should be refactored to be shared
+    MULTIPART_BOUNDARY_DATA_PROJECT = "data_project://"
+    DATAFILE_TYPE_TO_CONTENT_TYPE = {
+        ".datasource": "text/plain",
+        ".pipe": "text/plain",
+    }
+
+    config = CLIConfig.get_project_config(str(project_path))
+    TINYBIRD_API_URL = (config.get_host() or "") + "/v1/deploy"
+    TINYBIRD_API_KEY = config.get_token()
+
+    files = [
+        ("context://", ("cli-version", "1.0.0", "text/plain")),
+    ]
+    fds = []
+    for file_path in project_files(project_path):
+        relative_path = str(Path(file_path).relative_to(project_path))
+        fd = open(file_path, "rb")
+        fds.append(fd)
+        content_type = DATAFILE_TYPE_TO_CONTENT_TYPE.get(Path(file_path).suffix, "application/unknown")
+        files.append((MULTIPART_BOUNDARY_DATA_PROJECT, (relative_path, fd.read().decode("utf-8"), content_type)))
+
+    deployment = None
+    try:
+        HEADERS = {"Authorization": f"Bearer {TINYBIRD_API_KEY}"}
+
+        r = requests.post(TINYBIRD_API_URL, files=files, headers=HEADERS)
+        result = r.json()
+        logging.debug(json.dumps(result, indent=2))
+
+        deploy_result = result.get("result")
+        if deploy_result == "success":
+            click.echo(FeedbackManager.success(message="Deploy submitted successfully"))
+            deployment = result.get("deployment")
+        elif deploy_result == "failed":
+            click.echo(FeedbackManager.error(message="Deploy failed"))
+            deploy_errors = result.get("errors")
+            for deploy_error in deploy_errors:
+                if deploy_error.get("filename", None):
+                    click.echo(
+                        FeedbackManager.error(message=f"{deploy_error.get('filename')}\n\n{deploy_error.get('error')}")
+                    )
+                else:
+                    click.echo(FeedbackManager.error(message=f"{deploy_error.get('error')}"))
+        else:
+            click.echo(FeedbackManager.error(message=f"Unknown build result {deploy_result}"))
+    finally:
+        for fd in fds:
+            fd.close()
+
+    if deployment and wait:
+        while deployment.get("status") != "data_ready":
+            time.sleep(5)
+            TINYBIRD_API_URL = (config.get_host() or "") + f"/v1/deployments/{deployment.get('id')}"
+            r = requests.get(TINYBIRD_API_URL, headers=HEADERS)
+            result = r.json()
+            deployment = result.get("deployment")
+            if deployment.get("status") == "failed":
+                click.echo(FeedbackManager.error(message="Deployment failed"))
+                return
+
+        click.echo(FeedbackManager.success(message="Deployment is ready"))
+
+        if auto:
+            promote_deployment((config.get_host() or ""), HEADERS)
+
+
+@cli.group(name="releases")
+def releases_group() -> None:
+    """
+    Release commands.
+    """
+    pass
+
+
+@releases_group.command(name="list")
+@click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
+def release_list(project_path: Path) -> None:
+    """
+    List all the releases you have in the project.
+    """
+    config = CLIConfig.get_project_config(str(project_path))
+
+    TINYBIRD_API_KEY = config.get_token()
+    HEADERS = {"Authorization": f"Bearer {TINYBIRD_API_KEY}"}
+    TINYBIRD_API_URL = (config.get_host() or "") + "/v1/deployments"
+
+    r = requests.get(TINYBIRD_API_URL, headers=HEADERS)
+    result = r.json()
+    logging.debug(json.dumps(result, indent=2))
+
+    columns = ["id", "status", "created_at", "live"]
+    table = []
+    for deployment in result.get("deployments"):
+        table.append(
+            [deployment.get("id"), deployment.get("status"), deployment.get("created_at"), deployment.get("live")]
+        )
+
+    echo_safe_humanfriendly_tables_format_smart_table(table, column_names=columns)
+
+
+@releases_group.command(name="promote")
+@click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
+def release_promote(project_path: Path) -> None:
+    """
+    Promote last deploy to ready and remove old one.
+    """
+    config = CLIConfig.get_project_config(str(project_path))
+
+    TINYBIRD_API_KEY = config.get_token()
+    HEADERS = {"Authorization": f"Bearer {TINYBIRD_API_KEY}"}
+
+    promote_deployment((config.get_host() or ""), HEADERS)
+
+
+@releases_group.command(name="rollback")
+@click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
+def release_rollback(project_path: Path) -> None:
+    """
+    Rollback to the previous release.
+    """
+    config = CLIConfig.get_project_config(str(project_path))
+
+    TINYBIRD_API_KEY = config.get_token()
+    HEADERS = {"Authorization": f"Bearer {TINYBIRD_API_KEY}"}
+
+    rollback_deployment((config.get_host() or ""), HEADERS)

tinybird/tb/modules/llm.py

@@ -1,10 +1,8 @@
-import asyncio
 import json
 import urllib.parse
 from copy import deepcopy
-from typing import Awaitable, Callable, List, Optional
+from typing import List
 
-from openai import OpenAI
 from pydantic import BaseModel
 
 from tinybird.client import TinyB
@@ -31,25 +29,43 @@ class TestExpectations(BaseModel):
 
 
 class LLM:
-    def __init__(self, user_token: str, client: TinyB, api_key: Optional[str] = None):
+    def __init__(
+        self,
+        user_token: str,
+        client: TinyB,
+    ):
         self.user_client = deepcopy(client)
         self.user_client.token = user_token
 
-        self.openai = OpenAI(api_key=api_key) if api_key else None
+    async def ask(self, prompt: str, system_prompt: str = "", model: str = "o1-mini") -> str:
+        """
+        Calls the model with the given prompt and returns the response.
 
-    async def _execute(self, action_fn: Callable[[], Awaitable[str]], checker_fn: Callable[[str], bool]):
-        is_valid = False
-        times = 0
+        Args:
+            prompt (str): The user prompt to send to the model.
 
-        while not is_valid and times < 5:
-            result = await action_fn()
-            if asyncio.iscoroutinefunction(checker_fn):
-                is_valid = await checker_fn(result)
-            else:
-                is_valid = checker_fn(result)
-            times += 1
+        Returns:
+            str: The response from the language model.
+        """
+        messages = []
 
-        return result
+        if system_prompt:
+            messages.append({"role": "user", "content": system_prompt})
+
+        if prompt:
+            messages.append({"role": "user", "content": prompt})
+
+        data = {
+            "model": model,
+            "messages": messages,
+        }
+        response = await self.user_client._req(
+            "/v0/llm",
+            method="POST",
+            data=json.dumps(data),
+            headers={"Content-Type": "application/json"},
+        )
+        return response.get("result", "")
 
     async def create_project(self, prompt: str) -> DataProject:
         try:

tinybird/tb/modules/llm_utils.py

@@ -0,0 +1,24 @@
+import re
+from typing import List
+
+
+def extract_xml(text: str, tag: str) -> str:
+    """
+    Extracts the content of the specified XML tag from the given text. Used for parsing structured responses
+
+    Args:
+        text (str): The text containing the XML.
+        tag (str): The XML tag to extract content from.
+
+    Returns:
+        str: The content of the specified XML tag, or an empty string if the tag is not found.
+    """
+    match = re.search(f"<{tag}>(.*?)</{tag}>", text, re.DOTALL)
+    return match.group(1) if match else ""
+
+
+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)

tinybird/tb/modules/local.py

@@ -65,7 +65,7 @@ def start_tinybird_local(
         if health == "healthy":
             break
         if health == "unhealthy":
-            raise CLIException("Tinybird Local is unhealthy. Please try running `tb local restart` in a few seconds.")
+            raise CLIException("Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds.")
 
         time.sleep(5)
 
@@ -82,7 +82,7 @@ def get_docker_client():
         client.ping()
         return client
     except Exception:
-        raise CLIException("Docker is not running or installed. Please ensure Docker is installed and running.")
+        raise CLIException("Docker is not running or installed. Make sure Docker is installed and running.")
 
 
 def stop_tinybird_local(docker_client):

tinybird/tb/modules/login.py

@@ -110,15 +110,15 @@ def start_server(auth_callback):
 @cli.command()
 @click.option(
     "--host",
-    help="Set custom host if it's different than https://api.tinybird.co. Check https://www.tinybird.co/docs/api-reference/overview#regions-and-endpoints for the available list of regions",
+    help="Set custom host if it's different than https://api.tinybird.co. See https://www.tinybird.co/docs/api-reference/overview#regions-and-endpoints for the available list of regions.",
 )
 @click.option(
     "--workspace",
-    help="Set the workspace to authenticate to. If not set, the default workspace will be used.",
+    help="Set the workspace to authenticate to. If unset, the default workspace will be used.",
 )
 @coro
 async def login(host: str, workspace: str):
-    """Authenticate via browser."""
+    """Authenticate using the browser."""
     auth_event = threading.Event()
     auth_code = [None]  # Using a list to store the code, as it's mutable
     host = host or "https://api.tinybird.co"
@@ -127,7 +127,7 @@ async def login(host: str, workspace: str):
         auth_code[0] = code
         auth_event.set()
 
-    click.echo("Opening browser for authentication...")
+    click.echo(FeedbackManager.highlight(message="» Opening browser for authentication..."))
 
     # Start the local server in a separate thread
     server_thread = threading.Thread(target=start_server, args=(auth_callback,))
@@ -169,7 +169,9 @@ async def login(host: str, workspace: str):
                 cli_config[k] = ws[k]
 
         cli_config.persist_to_file()
-
-        click.echo(FeedbackManager.success(message="✓ Authentication successful!"))
+        click.echo(FeedbackManager.info(message="\nWorkspace: %s" % ws["name"]))
+        click.echo(FeedbackManager.info(message="User: %s" % ws["user_email"]))
+        click.echo(FeedbackManager.info(message="Host: %s" % host))
+        click.echo(FeedbackManager.success(message="\n✓ Authentication successful!"))
     else:
         click.echo(FeedbackManager.error(message="Authentication failed or timed out."))

tinybird/tb/modules/mock.py

@@ -4,12 +4,14 @@ from pathlib import Path
 
 import click
 
+from tinybird.prompts import mock_prompt
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import CLIException, check_user_token_with_client, coro
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.datafile.fixture import build_fixture_name, persist_fixture
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.llm import LLM
+from tinybird.tb.modules.llm_utils import extract_xml
 from tinybird.tb.modules.local_common import get_tinybird_local_client
 
 
@@ -18,14 +20,15 @@ from tinybird.tb.modules.local_common import get_tinybird_local_client
 @click.option("--rows", type=int, default=10, help="Number of events to send")
 @click.option("--prompt", type=str, default="", help="Extra context to use for data generation")
 @click.option("--folder", type=str, default=".", help="Folder where datafiles will be placed")
-@click.pass_context
 @coro
-async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, folder: str) -> None:
+async def mock(datasource: str, rows: int, prompt: str, folder: str) -> None:
     """Load sample data into a Data Source.
 
     Args:
-        ctx: Click context object
-        datasource_file: Path to the datasource file to load sample data into
+        datasource: Path to the datasource file to load sample data into
+        rows: Number of events to send
+        prompt: Extra context to use for data generation
+        folder: Folder where datafiles will be placed
     """
 
     try:
@@ -62,13 +65,15 @@ async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, fold
         user_client.token = user_token
         llm = LLM(user_token=user_token, client=user_client)
         tb_client = await get_tinybird_local_client(os.path.abspath(folder))
-        sql = await llm.generate_sql_sample_data(datasource_content, rows=rows, prompt=prompt)
+        prompt = f"<datasource_schema>{datasource_content}</datasource_schema>\n<user_input>{prompt}</user_input>"
+        response = await llm.ask(prompt, system_prompt=mock_prompt(rows))
+        sql = extract_xml(response, "sql")
         if os.environ.get("TB_DEBUG", "") != "":
             logging.debug(sql)
         result = await tb_client.query(f"{sql} FORMAT JSON")
         data = result.get("data", [])[:rows]
         fixture_name = build_fixture_name(datasource_path.absolute().as_posix(), datasource_name, datasource_content)
-        persist_fixture(fixture_name, data)
+        persist_fixture(fixture_name, data, folder)
         click.echo(FeedbackManager.success(message=f"✓ /fixtures/{fixture_name}.ndjson created with {rows} rows"))
 
     except Exception as e:

tinybird/tb/modules/test.py

@@ -12,12 +12,14 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 import click
 import yaml
 
+from tinybird.prompts import test_create_prompt
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import coro
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.exceptions import CLIException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.llm import LLM
+from tinybird.tb.modules.llm_utils import extract_xml, parse_xml
 from tinybird.tb.modules.local_common import get_tinybird_local_client
 
 yaml.SafeDumper.org_represent_str = yaml.SafeDumper.represent_str  # type: ignore[attr-defined]
@@ -55,9 +57,9 @@ def test(ctx: click.Context) -> None:
 
 @test.command(
     name="create",
-    help="Create a test for an existing endpoint",
+    help="Create a test for an existing pipe",
 )
-@click.argument("pipe", type=str)
+@click.argument("name_or_filename", type=str)
 @click.option(
     "--folder",
     default=".",
@@ -66,64 +68,84 @@ def test(ctx: click.Context) -> None:
 )
 @click.option("--prompt", type=str, default=None, help="Prompt to be used to create the test")
 @coro
-async def test_create(pipe: str, prompt: Optional[str], folder: str) -> None:
+async def test_create(name_or_filename: str, prompt: Optional[str], folder: str) -> None:
     """
-    Create a test for an existing endpoint
+    Create a test for an existing pipe
     """
-
+    root_path = Path(folder)
     try:
-        pipe_path = Path(pipe)
-        pipe_name = pipe
-        if pipe_path.suffix == ".pipe":
-            pipe_name = pipe_path.stem
-        else:
-            pipe_path = Path("endpoints", f"{pipe}.pipe")
+        if ".pipe" in name_or_filename:
+            pipe_path = Path(name_or_filename)
             if not pipe_path.exists():
-                pipe_path = Path("pipes", f"{pipe}.pipe")
+                raise CLIException(FeedbackManager.error(message=f"Pipe {name_or_filename} not found"))
+        else:
+            pipe_folders = ("endpoints", "copies", "materializations", "sinks", "pipes")
+            pipe_path = next(
+                (
+                    root_path / folder / f"{name_or_filename}.pipe"
+                    for folder in pipe_folders
+                    if (root_path / folder / f"{name_or_filename}.pipe").exists()
+                ),
+                None,
+            )
+            if not pipe_path:
+                raise CLIException(FeedbackManager.error(message=f"Pipe {name_or_filename} not found"))
 
+        pipe_name = pipe_path.stem
         click.echo(FeedbackManager.highlight(message=f"\n» Creating tests for {pipe_name} endpoint..."))
-        pipe_path = Path(folder) / pipe_path
+        pipe_path = root_path / pipe_path
         pipe_content = pipe_path.read_text()
 
         client = await get_tinybird_local_client(os.path.abspath(folder))
         pipe_nodes = await client._req(f"/v0/pipes/{pipe_name}")
-        pipe_params = set([param["name"] for node in pipe_nodes["nodes"] for param in node["params"]])
+        parameters = set([param["name"] for node in pipe_nodes["nodes"] for param in node["params"]])
 
+        system_prompt = test_create_prompt.format(
+            name=pipe_name,
+            content=pipe_content,
+            parameters=parameters or "No parameters",
+        )
         config = CLIConfig.get_project_config(folder)
         user_token = config.get_user_token()
         llm = LLM(user_token=user_token, client=config.get_client())
 
-        test_expectations = await llm.create_tests(
-            pipe_content=pipe_content, pipe_params=pipe_params, prompt=prompt or ""
-        )
-        valid_test_expectations: List[Dict[str, Any]] = []
-        for test in test_expectations.tests:
-            valid_test = test.model_dump()
-            test_params = (
-                valid_test["parameters"] if valid_test["parameters"].startswith("?") else f"?{valid_test['parameters']}"
-            )
+        response = await llm.ask(prompt, system_prompt=system_prompt)
+        response = extract_xml(response, "response")
+        tests_content = parse_xml(response, "test")
+
+        tests: List[Dict[str, Any]] = []
+        for test_content in tests_content:
+            test = {}
+            test["name"] = extract_xml(test_content, "name")
+            test["description"] = extract_xml(test_content, "description")
+            parameters = extract_xml(test_content, "parameters")
+            test["parameters"] = parameters.split("?")[1] if "?" in parameters else parameters
+            test["expected_result"] = ""
 
             response = None
             try:
-                response = await client._req_raw(f"/v0/pipes/{pipe_name}.ndjson{test_params}")
+                response = await client._req_raw(f"/v0/pipes/{pipe_name}.ndjson?{parameters}")
             except Exception:
-                continue
-
-            if response.status_code >= 400:
-                valid_test["expected_http_status"] = response.status_code
-                valid_test["expected_result"] = response.json()["error"]
-            else:
-                if "expected_http_status" in valid_test:
-                    del valid_test["expected_http_status"]
-                valid_test["expected_result"] = response.text or ""
-
-            valid_test_expectations.append(valid_test)
+                pass
 
-        if valid_test_expectations:
-            generate_test_file(pipe_name, valid_test_expectations, folder, mode="a")
-            for test in valid_test_expectations:
+            if response:
+                if response.status_code >= 400:
+                    test["expected_http_status"] = response.status_code
+                    test["expected_result"] = response.json()["error"]
+                else:
+                    if "expected_http_status" in test:
+                        del test["expected_http_status"]
+                    test["expected_result"] = response.text or ""
+
+            tests.append(test)
+
+        if len(tests) > 0:
+            generate_test_file(pipe_name, tests, folder, mode="a")
+            for test in tests:
                 test_name = test["name"]
                 click.echo(FeedbackManager.info(message=f"✓ {test_name} created"))
+        else:
+            click.echo(FeedbackManager.info(message="* No tests created"))
 
         click.echo(FeedbackManager.success(message="✓ Done!\n"))
     except Exception as e:
@@ -156,10 +178,10 @@ async def test_update(pipe: str, folder: str) -> None:
         pipe_tests_path = Path(folder) / pipe_tests_path
         pipe_tests_content = yaml.safe_load(pipe_tests_path.read_text())
         for test in pipe_tests_content:
-            test_params = test["parameters"] if test["parameters"].startswith("?") else f"?{test['parameters']}"
+            test_params = test["parameters"].split("?")[1] if "?" in test["parameters"] else test["parameters"]
             response = None
             try:
-                response = await client._req_raw(f"/v0/pipes/{pipe_name}.ndjson{test_params}")
+                response = await client._req_raw(f"/v0/pipes/{pipe_name}.ndjson?{test_params}")
             except Exception:
                 continue
 
@@ -194,12 +216,12 @@ async def test_update(pipe: str, folder: str) -> None:
     help="Folder where tests will be placed",
 )
 @coro
-async def test_run(name: Tuple[str, ...], folder: str) -> None:
+async def run_tests(name: Tuple[str, ...], folder: str) -> None:
     click.echo(FeedbackManager.highlight(message="\n» Running tests"))
     client = await get_tinybird_local_client(os.path.abspath(folder))
     paths = [Path(n) for n in name]
     endpoints = [f"./tests/{p.stem}.yaml" for p in paths]
-    file_list: Iterable[str] = endpoints if len(endpoints) > 0 else glob.glob("./tests/**/*.y*ml", recursive=True)
+    test_files: Iterable[str] = endpoints if len(endpoints) > 0 else glob.glob("./tests/**/*.y*ml", recursive=True)
 
     async def run_test(test_file):
         test_file_path = Path(test_file)
@@ -207,11 +229,10 @@ async def test_run(name: Tuple[str, ...], folder: str) -> None:
         test_file_content = yaml.safe_load(test_file_path.read_text())
         for test in test_file_content:
             try:
-                test_params = test["parameters"] if test["parameters"].startswith("?") else f"?{test['parameters']}"
-
+                test_params = test["parameters"].split("?")[1] if "?" in test["parameters"] else test["parameters"]
                 response = None
                 try:
-                    response = await client._req_raw(f"/v0/pipes/{test_file_path.stem}.ndjson{test_params}")
+                    response = await client._req_raw(f"/v0/pipes/{test_file_path.stem}.ndjson?{test_params}")
                 except Exception:
                     raise Exception("Expected to not fail but got an error")
 
@@ -239,8 +260,9 @@ async def test_run(name: Tuple[str, ...], folder: str) -> None:
         return True
 
     failed_tests_count = 0
-    test_count = len(file_list)
-    for test_file in file_list:
+    test_count = len(test_files)
+
+    for test_file in test_files:
         if not await run_test(test_file):
             failed_tests_count += 1
 

tinybird/tb/modules/watch.py

@@ -23,7 +23,7 @@ class FileChangeHandler(FileSystemEventHandler):
 
     def should_process(self, event: Any) -> Optional[str]:
         if event.is_directory:
-            return False
+            return None
 
         def should_process_path(path: str) -> bool:
             if not os.path.exists(path):