tinybird 0.0.1.dev234__py3-none-any.whl → 0.0.1.dev236__py3-none-any.whl

tinybird/tb/modules/materialization.py

@@ -7,7 +7,6 @@ from tinybird.datafile.common import PipeTypes, get_name_version
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import (
-    coro,
     echo_safe_humanfriendly_tables_format_smart_table,
     wait_job,
 )
@@ -31,15 +30,14 @@ def materialization(ctx):
     help="Force a type of the output",
 )
 @click.pass_context
-@coro
-async def materialization_ls(ctx: click.Context, match: str, format_: str):
+def materialization_ls(ctx: click.Context, match: str, format_: str):
     """List materializations"""
 
     client: TinyB = ctx.ensure_object(dict)["client"]
-    pipes = await client.pipes(dependencies=True, node_attrs="name,materialized", attrs="name,updated_at,endpoint,type")
+    pipes = client.pipes(dependencies=True, node_attrs="name,materialized", attrs="name,updated_at,endpoint,type")
     materializations = [p for p in pipes if p.get("type") == PipeTypes.MATERIALIZED]
     materializations = sorted(materializations, key=lambda p: p["updated_at"])
-    datasources = await client.datasources()
+    datasources = client.datasources()
     columns = ["name", "updated at", "nodes", "target datasource"]
     table_human_readable = []
     table_machine_readable = []
@@ -90,8 +88,7 @@ async def materialization_ls(ctx: click.Context, match: str, format_: str):
     help="Waits for populate jobs to finish, showing a progress bar. Disabled by default.",
 )
 @click.pass_context
-@coro
-async def pipe_populate(
+def pipe_populate(
     ctx: click.Context,
     pipe_name: str,
     node: str,
@@ -108,7 +105,7 @@ async def pipe_populate(
 
     cl: TinyB = ctx.ensure_object(dict)["client"]
 
-    pipe = await cl.pipe(pipe_name)
+    pipe = cl.pipe(pipe_name)
 
     if pipe["type"] != PipeTypes.MATERIALIZED:
         raise CLIPipeException(FeedbackManager.error_pipe_not_materialized(pipe=pipe_name))
@@ -124,7 +121,7 @@ async def pipe_populate(
 
         node = materialized_ids[0]
 
-    response = await cl.populate_node(pipe_name, node, populate_condition=sql_condition, truncate=truncate)
+    response = cl.populate_node(pipe_name, node, populate_condition=sql_condition, truncate=truncate)
     if "job" not in response:
         raise CLIPipeException(response)
 
@@ -135,4 +132,4 @@ async def pipe_populate(
     else:
         click.echo(FeedbackManager.info_populate_job_url(url=job_url))
     if wait:
-        await wait_job(cl, job_id, job_url, "Populating")
+        wait_job(cl, job_id, job_url, "Populating")

tinybird/tb/modules/mock.py

@@ -7,7 +7,7 @@ import click
 from tinybird.prompts import mock_prompt
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.cli import cli
-from tinybird.tb.modules.common import coro, push_data
+from tinybird.tb.modules.common import push_data
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.datafile.fixture import persist_fixture, persist_fixture_sql
 from tinybird.tb.modules.exceptions import CLIMockException
@@ -34,8 +34,7 @@ from tinybird.tb.modules.project import Project
     help="Format of the fixture to create",
 )
 @click.pass_context
-@coro
-async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, format_: str) -> None:
+def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, format_: str) -> None:
     """Generate sample data for a data source.
 
     Args:
@@ -71,7 +70,7 @@ async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, form
         if not user_token:
             raise Exception("This action requires authentication. Run 'tb login' first.")
 
-        data = await create_mock_data(
+        data = create_mock_data(
             datasource_name,
             datasource_content,
             rows,
@@ -87,7 +86,7 @@ async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, form
         fixture_path = persist_fixture(datasource_name, data, folder, format=format_)
         click.echo(FeedbackManager.info(message=f"✓ /fixtures/{datasource_name}.{format_} created"))
         if env == "cloud":
-            await append_fixture(tb_client, datasource_name, str(fixture_path))
+            append_fixture(tb_client, datasource_name, str(fixture_path))
 
         click.echo(FeedbackManager.success(message=f"✓ Sample data for {datasource_name} created with {rows} rows"))
 
@@ -95,12 +94,12 @@ async def mock(ctx: click.Context, datasource: str, rows: int, prompt: str, form
         raise CLIMockException(FeedbackManager.error(message=str(e)))
 
 
-async def append_fixture(
+def append_fixture(
     tb_client: TinyB,
     datasource_name: str,
     url: str,
 ):
-    await push_data(
+    push_data(
         tb_client,
         datasource_name,
         url,
@@ -110,7 +109,7 @@ async def append_fixture(
     )
 
 
-async def create_mock_data(
+def create_mock_data(
     datasource_name: str,
     datasource_content: str,
     rows: int,
@@ -136,7 +135,7 @@ async def create_mock_data(
             sql = extract_xml(response, "sql")
             sql_path = persist_fixture_sql(datasource_name, sql, folder)
             sql_format = "JSON" if format_ == "ndjson" else "CSV"
-            result = await tb_client.query(f"SELECT * FROM ({sql}) LIMIT {rows} FORMAT {sql_format}")
+            result = tb_client.query(f"SELECT * FROM ({sql}) LIMIT {rows} FORMAT {sql_format}")
             if sql_format == "JSON":
                 data = result.get("data", [])[:rows]
                 error_response = result.get("error", None)

tinybird/tb/modules/open.py

@@ -5,7 +5,6 @@ from click import Context
 
 from tinybird.tb.config import get_display_cloud_host
 from tinybird.tb.modules.cli import cli
-from tinybird.tb.modules.common import coro
 from tinybird.tb.modules.exceptions import CLIException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.local_common import get_build_workspace_name
@@ -17,8 +16,7 @@ from tinybird.tb.modules.local_common import get_build_workspace_name
     help="Set the workspace you want to open. If unset, your current workspace will be used.",
 )
 @click.pass_context
-@coro
-async def open(ctx: Context, workspace: str):
+def open(ctx: Context, workspace: str):
     """Open workspace in the browser."""
 
     config = ctx.ensure_object(dict)["config"]

tinybird/tb/modules/pipe.py

@@ -13,7 +13,6 @@ from tinybird.datafile.common import get_name_version
 from tinybird.tb.client import 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.exceptions import CLIPipeException
@@ -36,12 +35,11 @@ def pipe(ctx):
     help="Force a type of the output",
 )
 @click.pass_context
-@coro
-async def pipe_ls(ctx: Context, match: str, format_: str):
+def pipe_ls(ctx: Context, match: str, format_: str):
     """List pipes"""
 
     client: TinyB = ctx.ensure_object(dict)["client"]
-    pipes = await client.pipes(dependencies=False, node_attrs="name", attrs="name,updated_at,type")
+    pipes = client.pipes(dependencies=False, node_attrs="name", attrs="name,updated_at,type")
     pipes = sorted(pipes, key=lambda p: p["updated_at"])
 
     columns = ["name", "published date", "nodes", "type"]

tinybird/tb/modules/secret.py

@@ -4,10 +4,9 @@ from typing import Dict, Optional
 import click
 from dotenv import dotenv_values, set_key
 
-from tinybird.syncasync import async_to_sync
 from tinybird.tb.client import 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.common import echo_safe_humanfriendly_tables_format_smart_table
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.project import Project
 
@@ -21,12 +20,11 @@ def secret(ctx):
 @secret.command(name="ls")
 @click.option("--match", default=None, help="Retrieve any secrets matching the pattern. For example, --match _test")
 @click.pass_context
-@coro
-async def secret_ls(ctx: click.Context, match: Optional[str]):
+def secret_ls(ctx: click.Context, match: Optional[str]):
     """List secrets"""
 
     client: TinyB = ctx.ensure_object(dict)["client"]
-    secrets = await client.secrets()
+    secrets = client.secrets()
     columns = ["name", "created_at", "updated_at"]
     table_human_readable = []
     table_machine_readable = []
@@ -54,8 +52,7 @@ async def secret_ls(ctx: click.Context, match: Optional[str]):
 @click.argument("value", required=False)
 @click.option("--multiline", is_flag=True, help="Whether to use multiline input")
 @click.pass_context
-@coro
-async def secret_set(ctx: click.Context, name: str, value: Optional[str], multiline: bool):
+def secret_set(ctx: click.Context, name: str, value: Optional[str], multiline: bool):
     """Create or update secrets"""
     try:
         if not value:
@@ -73,14 +70,14 @@ async def secret_set(ctx: click.Context, name: str, value: Optional[str], multil
         client: TinyB = ctx.ensure_object(dict)["client"]
         existing_secret = None
         try:
-            existing_secret = await client.get_secret(name)
+            existing_secret = client.get_secret(name)
         except Exception:
             pass
 
         if existing_secret:
-            await client.update_secret(name, value)
+            client.update_secret(name, value)
         else:
-            await client.create_secret(name, value)
+            client.create_secret(name, value)
         click.echo(FeedbackManager.success(message=f"\n✓ Secret '{name}' set"))
     except Exception as e:
         click.echo(FeedbackManager.error(message=f"✗ Error: {e}"))
@@ -89,13 +86,12 @@ async def secret_set(ctx: click.Context, name: str, value: Optional[str], multil
 @secret.command(name="rm")
 @click.argument("name")
 @click.pass_context
-@coro
-async def secret_rm(ctx: click.Context, name: str):
+def secret_rm(ctx: click.Context, name: str):
     """Delete a secret"""
     try:
         click.echo(FeedbackManager.highlight(message=f"\n» Deleting secret '{name}'..."))
         client: TinyB = ctx.ensure_object(dict)["client"]
-        await client.delete_secret(name)
+        client.delete_secret(name)
         click.echo(FeedbackManager.success(message=f"\n✓ Secret '{name}' deleted"))
     except Exception as e:
         click.echo(FeedbackManager.error(message=f"✗ Error: {e}"))
@@ -133,14 +129,14 @@ def load_secrets(project: Project, client: TinyB):
                 continue
 
             try:
-                existing_secret = async_to_sync(client.get_secret)(name)
+                existing_secret = client.get_secret(name)
             except Exception:
                 existing_secret = None
             try:
                 if existing_secret:
-                    async_to_sync(client.update_secret)(name, value)
+                    client.update_secret(name, value)
                 else:
-                    async_to_sync(client.create_secret)(name, value)
+                    client.create_secret(name, value)
             except Exception as e:
                 click.echo(FeedbackManager.error(message=f"✗ Error setting secret '{name}': {e}"))
 

tinybird/tb/modules/shell.py

@@ -1,5 +1,3 @@
-import asyncio
-import concurrent.futures
 import os
 import subprocess
 import sys
@@ -315,26 +313,15 @@ class Shell:
             if q.lower().startswith("delete"):
                 raise CLIException(FeedbackManager.error_invalid_query())
 
-            def run_query_in_thread():
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                try:
-                    return loop.run_until_complete(
-                        self.tb_client.query(f"SELECT * FROM ({query}) LIMIT {rows_limit} FORMAT JSON")
-                    )
-                finally:
-                    loop.close()
-
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                res = executor.submit(run_query_in_thread).result()
+            res = self.tb_client.query(f"SELECT * FROM ({query}) LIMIT {rows_limit} FORMAT JSON")
 
-                if isinstance(res, dict) and "error" in res:
-                    click.echo(FeedbackManager.error_exception(error=res["error"]))
+            if isinstance(res, dict) and "error" in res:
+                click.echo(FeedbackManager.error_exception(error=res["error"]))
 
-                if isinstance(res, dict) and "data" in res and res["data"]:
-                    print_table_formatted(res, "QUERY")
-                else:
-                    click.echo(FeedbackManager.info_no_rows())
+            if isinstance(res, dict) and "data" in res and res["data"]:
+                print_table_formatted(res, "QUERY")
+            else:
+                click.echo(FeedbackManager.info_no_rows())
 
         except Exception as e:
             click.echo(FeedbackManager.error_exception(error=str(e)))

tinybird/tb/modules/sink.py

@@ -8,7 +8,7 @@ from click import Context
 from tinybird.datafile.common import get_name_version
 from tinybird.tb.client import AuthNoTokenException, TinyB
 from tinybird.tb.modules.cli import cli
-from tinybird.tb.modules.common import coro, echo_safe_humanfriendly_tables_format_smart_table, wait_job
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table, wait_job
 from tinybird.tb.modules.exceptions import CLIPipeException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -29,12 +29,11 @@ def sink(ctx):
     help="Force a type of the output",
 )
 @click.pass_context
-@coro
-async def sink_ls(ctx: Context, match: str, format_: str):
+def sink_ls(ctx: Context, match: str, format_: str):
     """List sink pipes"""
 
     client: TinyB = ctx.ensure_object(dict)["client"]
-    pipes = await client.pipes(dependencies=False, node_attrs="name", attrs="name,updated_at,type")
+    pipes = client.pipes(dependencies=False, node_attrs="name", attrs="name,updated_at,type")
     sinks = [p for p in pipes if p.get("type") == "sink"]
     sinks = sorted(sinks, key=lambda p: p["updated_at"])
     columns = ["name", "updated at", "nodes"]
@@ -79,8 +78,7 @@ async def sink_ls(ctx: Context, match: str, format_: str):
     help="Key and value of the params you want the Sink pipe to be called with. For example: tb pipe sink run <my_sink_pipe> --param foo=bar",
 )
 @click.pass_context
-@coro
-async def sink_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: str, param: Optional[Tuple[str]]):
+def sink_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: str, param: Optional[Tuple[str]]):
     """Run a sink pipe"""
 
     params = dict(key_value.split("=") for key_value in param) if param else {}
@@ -88,7 +86,7 @@ async def sink_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: s
     client: TinyB = ctx.ensure_object(dict)["client"]
 
     try:
-        response = await client.pipe_run(pipe_name_or_id, "sink", params, mode)
+        response = client.pipe_run(pipe_name_or_id, "sink", params, mode)
         job_id = response["job"]["id"]
         job_url = response["job"]["job_url"]
         click.echo(FeedbackManager.gray(message="Job URL: ") + FeedbackManager.info(message=f"{job_url}"))
@@ -96,7 +94,7 @@ async def sink_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: s
 
         if wait:
             click.echo("\n")
-            await wait_job(client, job_id, job_url, FeedbackManager.highlight(message="» Exporting data"))
+            wait_job(client, job_id, job_url, FeedbackManager.highlight(message="» Exporting data"))
             click.echo(FeedbackManager.success(message="✓ Data exported"))
 
     except AuthNoTokenException:

tinybird/tb/modules/test.py

@@ -3,7 +3,6 @@
 # - 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 asyncio
 import difflib
 import glob
 import sys
@@ -89,7 +88,7 @@ def test_create(ctx: click.Context, name_or_filename: str, prompt: str) -> None:
         pipe_name = pipe_path.stem
         click.echo(FeedbackManager.highlight(message=f"» Creating tests for {pipe_name} endpoint..."))
         pipe_content = pipe_path.read_text()
-        pipe = asyncio.run(client._req(f"/v0/pipes/{pipe_name}"))
+        pipe = client._req(f"/v0/pipes/{pipe_name}")
         parameters = set([param["name"] for node in pipe["nodes"] for param in node["params"]])
 
         system_prompt = test_create_prompt.format(
@@ -118,7 +117,7 @@ def test_create(ctx: click.Context, name_or_filename: str, prompt: str) -> None:
 
             response = None
             try:
-                response = asyncio.run(get_pipe_data(client, pipe_name=pipe_name, test_params=test["parameters"]))
+                response = get_pipe_data(client, pipe_name=pipe_name, test_params=test["parameters"])
             except Exception:
                 pass
 
@@ -176,7 +175,7 @@ def test_update(ctx: click.Context, pipe: str) -> None:
             test_params = test["parameters"].split("?")[1] if "?" in test["parameters"] else test["parameters"]
             response = None
             try:
-                response = asyncio.run(get_pipe_data(client, pipe_name=pipe_name, test_params=test_params))
+                response = get_pipe_data(client, pipe_name=pipe_name, test_params=test_params)
             except Exception:
                 continue
 
@@ -233,9 +232,7 @@ def run_tests(ctx: click.Context, name: Tuple[str, ...]) -> None:
                     test_params = test["parameters"].split("?")[1] if "?" in test["parameters"] else test["parameters"]
                     response = None
                     try:
-                        response = asyncio.run(
-                            get_pipe_data(client, pipe_name=test_file_path.stem, test_params=test_params)
-                        )
+                        response = get_pipe_data(client, pipe_name=test_file_path.stem, test_params=test_params)
                     except Exception:
                         continue
 
@@ -281,20 +278,20 @@ def run_tests(ctx: click.Context, name: Tuple[str, ...]) -> None:
         cleanup_test_workspace(client, project.folder)
 
 
-async def get_pipe_data(client: TinyB, pipe_name: str, test_params: str) -> Response:
-    pipe = await client._req(f"/v0/pipes/{pipe_name}")
+def get_pipe_data(client: TinyB, pipe_name: str, test_params: str) -> Response:
+    pipe = client._req(f"/v0/pipes/{pipe_name}")
     output_node = next(
         (node for node in pipe["nodes"] if node["node_type"] != "default" and node["node_type"] != "standard"),
         {"name": "not_found"},
     )
     if output_node["node_type"] == "endpoint":
-        return await client._req_raw(f"/v0/pipes/{pipe_name}.ndjson?{test_params}")
+        return client._req_raw(f"/v0/pipes/{pipe_name}.ndjson?{test_params}")
 
     params = {
         "q": output_node["sql"],
         "pipeline": pipe_name,
     }
-    return await client._req_raw(f"""/v0/sql?{urllib.parse.urlencode(params)}&{test_params}""")
+    return client._req_raw(f"""/v0/sql?{urllib.parse.urlencode(params)}&{test_params}""")
 
 
 def get_pipe_path(name_or_filename: str, folder: str) -> Path:
@@ -320,8 +317,6 @@ def cleanup_test_workspace(client: TinyB, path: str) -> None:
     try:
         user_token = tokens["user_token"]
         user_client.token = user_token
-        asyncio.run(
-            user_client.delete_workspace(get_test_workspace_name(path), hard_delete_confirmation="yes", version="v1")
-        )
+        user_client.delete_workspace(get_test_workspace_name(path), hard_delete_confirmation="yes", version="v1")
     except Exception:
         pass

tinybird/tb/modules/tinyunit/tinyunit.py

@@ -191,7 +191,7 @@ def generate_file(file: str, overwrite: bool = False) -> None:
         raise CLIException(FeedbackManager.error_file_already_exists(file=p))
 
 
-async def run_test_file(tb_client: TinyB, file: str) -> List[TestResult]:
+def run_test_file(tb_client: TinyB, file: str) -> List[TestResult]:
     results: List[TestResult] = []
     for test_case in parse_file(file):
         if not test_case.sql and not test_case.pipe:
@@ -211,7 +211,7 @@ async def run_test_file(tb_client: TinyB, file: str) -> List[TestResult]:
         if test_case.sql and not test_case.pipe:
             q = f"SELECT * FROM ({test_case.sql}) LIMIT 20 FORMAT JSON"
             try:
-                test_response = await tb_client.query(q)
+                test_response = tb_client.query(q)
                 results.append(
                     TestResult(
                         name=test_case.name,
@@ -241,7 +241,7 @@ async def run_test_file(tb_client: TinyB, file: str) -> List[TestResult]:
             params = test_case.pipe.params
             try:
                 sql = test_case.sql if test_case.sql else None
-                test_response = await tb_client.pipe_data(pipe, format="json", params=params, sql=sql)
+                test_response = tb_client.pipe_data(pipe, format="json", params=params, sql=sql)
                 results.append(
                     TestResult(
                         name=test_case.name,

tinybird/tb/modules/token.py

@@ -10,7 +10,6 @@ from tinybird.tb.client import AuthNoTokenException, TinyB
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import (
     DoesNotExistException,
-    coro,
     echo_safe_humanfriendly_tables_format_smart_table,
 )
 from tinybird.tb.modules.exceptions import CLITokenException
@@ -26,8 +25,7 @@ def token(ctx: Context) -> None:
 @token.command(name="ls")
 @click.option("--match", default=None, help="Retrieve any token matching the pattern. For example, --match _test")
 @click.pass_context
-@coro
-async def token_ls(
+def token_ls(
     ctx: Context,
     match: Optional[str] = None,
 ) -> None:
@@ -37,7 +35,7 @@ async def token_ls(
     client: TinyB = obj["client"]
 
     try:
-        tokens = await client.token_list(match)
+        tokens = client.token_list(match)
         columns = ["id", "name", "token"]
         table = list(map(lambda token: [token.get(key, "") for key in columns], tokens))
 
@@ -54,15 +52,14 @@ async def token_ls(
 @click.argument("token_id")
 @click.option("--yes", is_flag=True, default=False, help="Don't ask for confirmation")
 @click.pass_context
-@coro
-async def token_rm(ctx: Context, token_id: str, yes: bool) -> None:
+def token_rm(ctx: Context, token_id: str, yes: bool) -> None:
     """Remove a static token."""
 
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     client: TinyB = obj["client"]
     if yes or click.confirm(FeedbackManager.warning_confirm_delete_token(token=token_id)):
         try:
-            await client.token_delete(token_id)
+            client.token_delete(token_id)
         except AuthNoTokenException:
             raise
         except DoesNotExistException:
@@ -76,15 +73,14 @@ async def token_rm(ctx: Context, token_id: str, yes: bool) -> None:
 @click.argument("token_id")
 @click.option("--yes", is_flag=True, default=False, help="Don't ask for confirmation")
 @click.pass_context
-@coro
-async def token_refresh(ctx: Context, token_id: str, yes: bool) -> None:
+def token_refresh(ctx: Context, token_id: str, yes: bool) -> None:
     """Refresh a Static Token."""
 
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     client: TinyB = obj["client"]
     if yes or click.confirm(FeedbackManager.warning_confirm_refresh_token(token=token_id)):
         try:
-            await client.token_refresh(token_id)
+            client.token_refresh(token_id)
         except AuthNoTokenException:
             raise
         except DoesNotExistException:
@@ -97,15 +93,14 @@ async def token_refresh(ctx: Context, token_id: str, yes: bool) -> None:
 @token.command(name="scopes")
 @click.argument("token_id")
 @click.pass_context
-@coro
-async def token_scopes(ctx: Context, token_id: str) -> None:
+def token_scopes(ctx: Context, token_id: str) -> None:
     """List Static Token scopes."""
 
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     client: TinyB = obj["client"]
 
     try:
-        scopes = await client.token_scopes(token_id)
+        scopes = client.token_scopes(token_id)
         columns = ["type", "resource", "filter"]
         table = list(map(lambda scope: [scope.get(key, "") for key in columns], scopes))
         click.echo(FeedbackManager.info_token_scopes(token=token_id))
@@ -120,15 +115,14 @@ async def token_scopes(ctx: Context, token_id: str) -> None:
 @token.command(name="copy")
 @click.argument("token_id")
 @click.pass_context
-@coro
-async def token_copy(ctx: Context, token_id: str) -> None:
+def token_copy(ctx: Context, token_id: str) -> None:
     """Copy a Static Token."""
 
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     client: TinyB = obj["client"]
 
     try:
-        token = await client.token_get(token_id)
+        token = client.token_get(token_id)
         pyperclip.copy(token["token"].strip())
     except AuthNoTokenException:
         raise
@@ -197,8 +191,7 @@ def create(ctx: Context) -> None:
     "--fixed-params", multiple=True, help="Fixed parameters in key=value format, multiple values separated by commas"
 )
 @click.pass_context
-@coro
-async def create_jwt_token(ctx: Context, name: str, ttl: timedelta, scope, resource, fixed_params) -> None:
+def create_jwt_token(ctx: Context, name: str, ttl: timedelta, scope, resource, fixed_params) -> None:
     """Create a JWT token with a TTL specify."""
 
     obj: Dict[str, Any] = ctx.ensure_object(dict)
@@ -231,7 +224,7 @@ async def create_jwt_token(ctx: Context, name: str, ttl: timedelta, scope, resou
         )
 
     try:
-        response = await client.create_jwt_token(name, expiration_time, scopes)
+        response = client.create_jwt_token(name, expiration_time, scopes)
     except AuthNoTokenException:
         raise
     except Exception as e:
@@ -275,8 +268,7 @@ class DynamicOptionsCommand(click.Command):
 )
 @click.argument("name")
 @click.pass_context
-@coro
-async def create_static_token(ctx, name: str):
+def create_static_token(ctx, name: str):
     """Create a Static Token."""
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     client: TinyB = obj["client"]
@@ -336,15 +328,15 @@ async def create_static_token(ctx, name: str):
         token = None
         try:
             click.echo(FeedbackManager.highlight(message=f"\n» Checking if token '{name}' exists..."))
-            token = await client.token_get(name)
+            token = client.token_get(name)
         except Exception:
             pass
         if token:
             click.echo(FeedbackManager.info(message=f"* Token '{name}' found, updating it..."))
-            await client.alter_tokens(name, scoped_parsed)
+            client.alter_tokens(name, scoped_parsed)
         else:
             click.echo(FeedbackManager.info(message=f"* Token '{name}' not found, creating it..."))
-            await client.create_token(name, scoped_parsed, origin_code=None)
+            client.create_token(name, scoped_parsed, origin_code=None)
     except AuthNoTokenException:
         raise
     except Exception as e:

tinybird/tb/modules/watch.py

@@ -1,4 +1,3 @@
-import asyncio
 import os
 import time
 from pathlib import Path
@@ -223,13 +222,10 @@ def watch_files(
     build_ok: bool,
 ) -> None:
     # Handle both sync and async process functions
-    async def process_wrapper(files: List[str]) -> None:
+    def process_wrapper(files: List[str]) -> None:
         click.echo(FeedbackManager.highlight(message="» Rebuilding project..."))
         time_start = time.time()
-        if asyncio.iscoroutinefunction(process):
-            await process(files, watch=True)
-        else:
-            process(files, watch=True)
+        process(files, watch=True)
         time_end = time.time()
         elapsed_time = time_end - time_start
         click.echo(
@@ -238,7 +234,7 @@ def watch_files(
         )
         shell.reprint_prompt()
 
-    event_handler = FileChangeHandler(filenames, lambda f: asyncio.run(process_wrapper(f)), build_ok)
+    event_handler = FileChangeHandler(filenames, lambda f: process_wrapper(f), build_ok)
     observer = Observer()
 
     observer.schedule(event_handler, path=str(project.path), recursive=True)