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

tinybird/tb/modules/infra.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 import subprocess
 import sys
@@ -13,7 +12,7 @@ from click import Context
 
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.cli import CLIException, 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.config import CLIConfig
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -225,18 +224,18 @@ class Infrastructure:
     def __init__(self, client: TinyB):
         self.client = client
 
-    async def get_organizations_info(self, config: CLIConfig):
-        self.orgs = await get_organizations_by_user(config)
+    def get_organizations_info(self, config: CLIConfig):
+        self.orgs = get_organizations_by_user(config)
 
-    async def create_infra(self, name: str, host: str, organization_id: str) -> Dict[str, Any]:
+    def create_infra(self, name: str, host: str, organization_id: str) -> Dict[str, Any]:
         """Create a new infrastructure."""
-        infra = await self.client.infra_create(organization_id=organization_id, name=name, host=host)
+        infra = self.client.infra_create(organization_id=organization_id, name=name, host=host)
         return infra
 
-    async def list_infras(self) -> None:
+    def list_infras(self) -> None:
         """List all self-managed regions for the admin organization."""
 
-        infras = await self.get_infra_list()
+        infras = self.get_infra_list()
         columns = [
             "name",
             "host",
@@ -257,24 +256,24 @@ class Infrastructure:
         echo_safe_humanfriendly_tables_format_smart_table(table_human_readable, column_names=columns)
         click.echo("\n")
 
-    async def remove_infra(self, name: str):
+    def remove_infra(self, name: str):
         try:
             click.echo(FeedbackManager.highlight(message=f"» Deleting infrastructure '{name}' from Tinybird..."))
-            infras = await self.get_infra_list()
+            infras = self.get_infra_list()
             infra = next((infra for infra in infras if infra["name"] == name), None)
             if not infra:
                 raise CLIException(f"Infrastructure '{name}' not found")
-            await self.client.infra_delete(infra["id"], infra["organization_id"])
+            self.client.infra_delete(infra["id"], infra["organization_id"])
             click.echo(FeedbackManager.success(message=f"\n✓ Infrastructure '{name}' deleted"))
         except Exception as e:
             click.echo(FeedbackManager.error(message=f"✗ Error: {e}"))
 
-    async def update(self, infra_name: str, name: str, host: str):
-        infras_list = await self.get_infra_list()
+    def update(self, infra_name: str, name: str, host: str):
+        infras_list = self.get_infra_list()
         infra = next((infra for infra in infras_list if infra["name"] == infra_name), None)
         if not infra:
             return None
-        await self.client.infra_update(
+        self.client.infra_update(
             infra_id=infra["id"],
             organization_id=infra["organization_id"],
             name=name,
@@ -282,7 +281,7 @@ class Infrastructure:
         )
         return infra
 
-    async def get_infra_list(self) -> List[Dict[str, str]]:
+    def get_infra_list(self) -> List[Dict[str, str]]:
         """Get a list of all infrastructures across organizations.
 
         Returns:
@@ -298,7 +297,7 @@ class Infrastructure:
                 org_id = org.get("id") or ""
                 org_name = org.get("name")
                 try:
-                    infras = await self.client.infra_list(organization_id=org_id)
+                    infras = self.client.infra_list(organization_id=org_id)
                     for infra in infras:
                         infra["organization"] = org_name
                         all_infras.append(infra)
@@ -322,7 +321,7 @@ def infra(ctx: Context) -> None:
     client: TinyB = ctx.ensure_object(dict)["client"]
     config = CLIConfig.get_project_config()
     infra = Infrastructure(client)
-    asyncio.run(infra.get_organizations_info(config))
+    infra.get_organizations_info(config)
     ctx.ensure_object(dict)["infra"] = infra
 
 
@@ -340,8 +339,7 @@ def infra(ctx: Context) -> None:
 @click.option("--skip-apply", is_flag=True, help="Skip Terraform and kubectl configuration and application")
 @click.option("--organization-id", type=str, help="Organization ID for the self-managed region")
 @click.pass_context
-@coro
-async def infra_init(
+def infra_init(
     ctx: Context,
     name: str,
     cloud_provider: str,
@@ -380,7 +378,7 @@ async def infra_init(
     config = {}
     if config_path.exists():
         try:
-            with open(config_path, "r") as f:  # noqa: ASYNC230
+            with open(config_path, "r") as f:
                 config = json.load(f)
             click.echo(FeedbackManager.info(message="** Loaded existing configuration from config.json"))
         except json.JSONDecodeError:
@@ -442,7 +440,7 @@ async def infra_init(
         "kubernetes_context": kubernetes_context,
     }
 
-    with open(config_path, "w") as f:  # noqa: ASYNC230
+    with open(config_path, "w") as f:
         json.dump(config, f, indent=2)
 
     click.echo(FeedbackManager.info(message=f"** Configuration saved to {config_path}"))
@@ -450,16 +448,16 @@ async def infra_init(
     infra: Infrastructure = ctx.ensure_object(dict)["infra"]
     cli_config = CLIConfig.get_project_config()
 
-    infras = await infra.get_infra_list()
+    infras = infra.get_infra_list()
     infra_name = next((infra for infra in infras if infra["name"] == name), None)
     if not infra_name:
         # Handle organization if not provided
-        organization_id, organization_name = await ask_for_organization(infra.orgs, organization_id)
+        organization_id, organization_name = ask_for_organization(infra.orgs, organization_id)
         if not organization_id:
             return
         click.echo(FeedbackManager.highlight(message=f"\n» Creating infrastructure '{name}' in Tinybird..."))
         host = f"https://{dns_record}.{dns_zone_name}"
-        infra_obj = await infra.create_infra(name, host, organization_id)
+        infra_obj = infra.create_infra(name, host, organization_id)
     else:
         click.echo(FeedbackManager.highlight(message=f"» Infrastructure '{name}' already exists."))
         if infra_name["host"] != f"https://{dns_record}.{dns_zone_name}":
@@ -469,7 +467,7 @@ async def infra_init(
                 )
             )
             if click.confirm("Would you like to update the host in the infra provisioned at Tinybird?"):
-                await infra.update(infra_name=name, name=name, host=f"https://{dns_record}.{dns_zone_name}")
+                infra.update(infra_name=name, name=name, host=f"https://{dns_record}.{dns_zone_name}")
         organization_name = infra_name["organization"]
         infra_obj = infra_name
 
@@ -480,7 +478,7 @@ async def infra_init(
         "dns_record": dns_record,
     }
 
-    with open(tf_path, "w") as f:  # noqa: ASYNC230
+    with open(tf_path, "w") as f:
         f.write(terraform_content.lstrip())
 
     click.echo(FeedbackManager.info(message=f"** Created Terraform configuration in {tf_path}"))
@@ -498,7 +496,7 @@ async def infra_init(
         "infra_user": cli_config.get_user_email() or "",
     }
 
-    with open(yaml_path, "w") as f:  # noqa: ASYNC230
+    with open(yaml_path, "w") as f:
         f.write(new_content.lstrip())
 
     click.echo(FeedbackManager.info(message=f"** Created Kubernetes configuration in {yaml_path}"))
@@ -510,7 +508,7 @@ async def infra_init(
         command = f"terraform -chdir={infra_dir} init"
         click.echo(FeedbackManager.highlight(message=f"» Executing: {command}"))
 
-        init_result = subprocess.run(["terraform", f"-chdir={infra_dir}", "init"], capture_output=True, text=True)  # noqa: ASYNC221
+        init_result = subprocess.run(["terraform", f"-chdir={infra_dir}", "init"], capture_output=True, text=True)
 
         if init_result.returncode != 0:
             click.echo(FeedbackManager.error(message="✗ Error: Terraform initialization failed:"))
@@ -521,7 +519,7 @@ async def infra_init(
         click.echo(FeedbackManager.info(message="** Running Terraform plan..."))
         command = f"terraform -chdir={infra_dir} plan"
         click.echo(FeedbackManager.highlight(message=f"» Executing: {command}"))
-        plan_result = subprocess.run(command.split(), capture_output=True, text=True)  # noqa: ASYNC221
+        plan_result = subprocess.run(command.split(), capture_output=True, text=True)
 
         if plan_result.returncode != 0:
             click.echo(FeedbackManager.error(message="✗ Error: Terraform plan failed:"))
@@ -536,7 +534,7 @@ async def infra_init(
             click.echo(FeedbackManager.info(message="** Applying Terraform configuration..."))
             command = f"terraform -chdir={infra_dir} apply -auto-approve"
             click.echo(FeedbackManager.highlight(message=f"» Executing: {command}"))
-            apply_result = subprocess.run(command.split(), capture_output=True, text=True)  # noqa: ASYNC221
+            apply_result = subprocess.run(command.split(), capture_output=True, text=True)
 
             if apply_result.returncode != 0:
                 click.echo(FeedbackManager.error(message="✗ Error: Terraform apply failed:"))
@@ -553,7 +551,7 @@ async def infra_init(
             # Get current kubectl context
             command = "kubectl config current-context"
             click.echo(FeedbackManager.highlight(message=f"» Executing: {command}"))
-            current_context_result = subprocess.run(command.split(), capture_output=True, text=True)  # noqa: ASYNC221
+            current_context_result = subprocess.run(command.split(), capture_output=True, text=True)
 
             current_context = (
                 current_context_result.stdout.strip() if current_context_result.returncode == 0 else "unknown"
@@ -563,7 +561,7 @@ async def infra_init(
             command = "kubectl config get-contexts -o name"
             click.echo(FeedbackManager.highlight(message=f"» Executing: {command}"))
 
-            contexts_result = subprocess.run(command.split(), capture_output=True, text=True)  # noqa: ASYNC221
+            contexts_result = subprocess.run(command.split(), capture_output=True, text=True)
 
             if contexts_result.returncode != 0:
                 click.echo(FeedbackManager.error(message="✗ Error: Failed to get kubectl contexts:"))
@@ -605,7 +603,7 @@ async def infra_init(
 
             # Update the config with the selected context
             config["kubernetes_context"] = selected_context
-            with open(config_path, "w") as f:  # noqa: ASYNC230
+            with open(config_path, "w") as f:
                 json.dump(config, f, indent=2)
             click.echo(f"Updated configuration with selected Kubernetes context: {selected_context}")
 
@@ -616,7 +614,7 @@ async def infra_init(
             command = f"kubectl --context {selected_context} diff -f {str(yaml_path)}"
             click.echo(FeedbackManager.highlight(message=f"» Executing: {command}"))
 
-            diff_result = subprocess.run(command.split(), capture_output=True, text=True)  # noqa: ASYNC221
+            diff_result = subprocess.run(command.split(), capture_output=True, text=True)
 
             if diff_result.returncode not in [0, 1]:  # kubectl diff returns 1 when there are differences
                 if (
@@ -638,7 +636,7 @@ async def infra_init(
             # Now apply the configuration
             command = f"kubectl --context {selected_context} apply -f {str(yaml_path)}"
             click.echo(FeedbackManager.highlight(message=f"» Executing: {command}"))
-            apply_result = subprocess.run(command.split(), capture_output=True, text=True)  # noqa: ASYNC221
+            apply_result = subprocess.run(command.split(), capture_output=True, text=True)
 
             if apply_result.returncode != 0:
                 click.echo(FeedbackManager.error(message="✗ Error: Failed to apply Kubernetes configuration:"))
@@ -662,7 +660,7 @@ async def infra_init(
                     )
 
                     try:
-                        response = requests.get(endpoint_url, allow_redirects=False, timeout=5)  # noqa: ASYNC210
+                        response = requests.get(endpoint_url, allow_redirects=False, timeout=5)
                         if response.status_code < 400:  # Consider any non-error response as success
                             click.echo(
                                 "\n" + click.style("✅ HTTPS endpoint is now accessible!", fg="green", bold=True)
@@ -679,7 +677,7 @@ async def infra_init(
                         click.echo("  This might be due to DNS propagation or the Load Balancer provisioning delays")
                         click.echo(f"  Try accessing {endpoint_url} manually in a few minutes")
                     else:
-                        time.sleep(10)  # noqa: ASYNC251
+                        time.sleep(10)
 
     if not skip_apply:
         # Print a summary with the endpoint URL
@@ -698,20 +696,18 @@ async def infra_init(
 @infra.command(name="rm")
 @click.argument("name")
 @click.pass_context
-@coro
-async def infra_remove(ctx: click.Context, name: str):
+def infra_remove(ctx: click.Context, name: str):
     """Delete an infrastructure from Tinybird"""
     infra: Infrastructure = ctx.ensure_object(dict)["infra"]
-    await infra.remove_infra(name)
+    infra.remove_infra(name)
 
 
 @infra.command(name="ls")
 @click.pass_context
-@coro
-async def infra_list(ctx: click.Context):
+def infra_list(ctx: click.Context):
     """List self-managed infrastructures"""
     infra: Infrastructure = ctx.ensure_object(dict)["infra"]
-    await infra.list_infras()
+    infra.list_infras()
 
 
 @infra.command(name="add")
@@ -723,7 +719,7 @@ def infra_add(ctx: click.Context, name: str, host: Optional[str] = None, organiz
     """Creates a new self-managed region from an existing infrastructure URL."""
     infra: Infrastructure = ctx.ensure_object(dict)["infra"]
 
-    organization_id, organization_name = asyncio.run(ask_for_organization(infra.orgs, organization_id))
+    organization_id, organization_name = ask_for_organization(infra.orgs, organization_id)
     if not organization_id:
         return
 
@@ -736,7 +732,7 @@ def infra_add(ctx: click.Context, name: str, host: Optional[str] = None, organiz
     )
 
     click.echo(FeedbackManager.highlight(message=f"» Adding self-managed region '{name}' in Tinybird..."))
-    new_infra = asyncio.run(infra.create_infra(name, host, organization_id))
+    new_infra = infra.create_infra(name, host, organization_id)
     infra_token = new_infra["token"]
     click.echo(
         FeedbackManager.success(message=f"\n✓ Self-managed region '{name}' added in '{organization_name}' Organization")
@@ -758,8 +754,7 @@ def infra_add(ctx: click.Context, name: str, host: Optional[str] = None, organiz
 @click.option("--name", type=str, help="Name for identifying the self-managed region in Tinybird")
 @click.option("--host", type=str, help="Host for the self-managed region")
 @click.pass_context
-@coro
-async def infra_update(ctx: click.Context, infra_name: str, name: str, host: str):
+def infra_update(ctx: click.Context, infra_name: str, name: str, host: str):
     """Updates the URL of an existing self-managed region."""
     infra: Infrastructure = ctx.ensure_object(dict)["infra"]
     if not name and not host:
@@ -771,7 +766,7 @@ async def infra_update(ctx: click.Context, infra_name: str, name: str, host: str
             click.echo(
                 FeedbackManager.highlight(message=f"» Updating self-managed region'{infra_name}' in Tinybird...")
             )
-            infra_id = await infra.update(infra_name, name, host)
+            infra_id = infra.update(infra_name, name, host)
             if not infra_id:
                 raise CLIException(f"Self-managed region '{infra_name}' not found")
         except Exception as e:

tinybird/tb/modules/job.py

@@ -10,7 +10,7 @@ from click import Context
 
 from tinybird.tb.client import 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.common import echo_safe_humanfriendly_tables_format_smart_table
 from tinybird.tb.modules.exceptions import CLIException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -38,11 +38,10 @@ def job(ctx: Context) -> None:
     default=None,
 )
 @click.pass_context
-@coro
-async def jobs_ls(ctx: Context, status: Tuple[str, ...], kind: Tuple[str, ...]) -> None:
+def jobs_ls(ctx: Context, status: Tuple[str, ...], kind: Tuple[str, ...]) -> None:
     """List jobs, up to 100"""
     client: TinyB = ctx.ensure_object(dict)["client"]
-    jobs = await client.jobs(status=status, kind=kind)
+    jobs = client.jobs(status=status, kind=kind)
     columns = ["id", "kind", "status", "created at", "updated at", "job url"]
     click.echo(FeedbackManager.info_jobs())
     table = []
@@ -55,11 +54,10 @@ async def jobs_ls(ctx: Context, status: Tuple[str, ...], kind: Tuple[str, ...])
 @job.command(name="details")
 @click.argument("job_id")
 @click.pass_context
-@coro
-async def job_details(ctx: Context, job_id: str) -> None:
+def job_details(ctx: Context, job_id: str) -> None:
     """Get details for any job created in the last 48h"""
     client: TinyB = ctx.ensure_object(dict)["client"]
-    job = await client.job(job_id)
+    job = client.job(job_id)
     columns = []
     click.echo(FeedbackManager.info_job(job=job_id))
     table = []
@@ -72,13 +70,12 @@ async def job_details(ctx: Context, job_id: str) -> None:
 @job.command(name="cancel")
 @click.argument("job_id")
 @click.pass_context
-@coro
-async def job_cancel(ctx: Context, job_id: str) -> None:
+def job_cancel(ctx: Context, job_id: str) -> None:
     """Try to cancel a job"""
     client = ctx.ensure_object(dict)["client"]
 
     try:
-        result = await client.job_cancel(job_id)
+        result = client.job_cancel(job_id)
     except DoesNotExistException:
         raise CLIException(FeedbackManager.error_job_does_not_exist(job_id=job_id))
     except Exception as e:

tinybird/tb/modules/local.py

@@ -5,7 +5,6 @@ import requests
 
 from docker.client import DockerClient
 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 (
@@ -88,8 +87,7 @@ def local(ctx: click.Context) -> None:
 
 
 @local.command()
-@coro
-async def stop() -> None:
+def stop() -> None:
     """Stop Tinybird Local"""
     click.echo(FeedbackManager.highlight(message="» Shutting down Tinybird Local..."))
     docker_client = get_docker_client()
@@ -99,8 +97,7 @@ async def stop() -> None:
 
 @local.command()
 @click.pass_context
-@coro
-async def status(ctx: click.Context) -> None:
+def status(ctx: click.Context) -> None:
     """Check status of Tinybird Local"""
     docker_client = get_docker_client()
     container = get_existing_container_with_matching_env(docker_client, TB_CONTAINER_NAME, {})
@@ -115,7 +112,7 @@ async def status(ctx: click.Context) -> None:
             from tinybird.tb.modules.info import get_local_info
 
             config = ctx.ensure_object(dict).get("config", {})
-            await get_local_info(config)
+            get_local_info(config)
         elif status == "restarting" or (status == "running" and health == "starting"):
             click.echo(FeedbackManager.highlight(message="* Tinybird Local is starting..."))
         elif status == "removing":
@@ -129,8 +126,7 @@ async def status(ctx: click.Context) -> None:
 
 
 @local.command()
-@coro
-async def remove() -> None:
+def remove() -> None:
     """Remove Tinybird Local"""
     click.echo(FeedbackManager.highlight(message="» Removing Tinybird Local..."))
     docker_client = get_docker_client()
@@ -139,14 +135,13 @@ async def remove() -> None:
 
 
 @local.command()
-@coro
 @click.option(
     "--use-aws-creds",
     default=False,
     is_flag=True,
     help="Use local AWS credentials from your environment and pass them to the Tinybird docker container",
 )
-async def start(use_aws_creds: bool) -> None:
+def start(use_aws_creds: bool) -> None:
     """Start Tinybird Local"""
     click.echo(FeedbackManager.highlight(message="» Starting Tinybird Local..."))
     docker_client = get_docker_client()
@@ -155,14 +150,13 @@ async def start(use_aws_creds: bool) -> None:
 
 
 @local.command()
-@coro
 @click.option(
     "--use-aws-creds",
     default=False,
     is_flag=True,
     help="Use local AWS credentials from your environment and pass them to the Tinybird docker container",
 )
-async def restart(use_aws_creds: bool) -> None:
+def restart(use_aws_creds: bool) -> None:
     """Restart Tinybird Local"""
     click.echo(FeedbackManager.highlight(message="» Restarting Tinybird Local..."))
     docker_client = get_docker_client()

tinybird/tb/modules/local_common.py

@@ -28,16 +28,16 @@ TB_LOCAL_ADDRESS = f"http://{TB_LOCAL_HOST}:{TB_LOCAL_PORT}"
 TB_LOCAL_DEFAULT_WORKSPACE_NAME = "Tinybird_Local_Testing"
 
 
-async def get_tinybird_local_client(
+def get_tinybird_local_client(
     config_obj: Dict[str, Any], test: bool = False, staging: bool = False, silent: bool = False
 ) -> TinyB:
     """Get a Tinybird client connected to the local environment."""
 
-    config = await get_tinybird_local_config(config_obj, test=test, silent=silent)
+    config = get_tinybird_local_config(config_obj, test=test, silent=silent)
     return config.get_client(host=TB_LOCAL_ADDRESS, staging=staging)
 
 
-async def get_tinybird_local_config(config_obj: Dict[str, Any], test: bool = False, silent: bool = False) -> CLIConfig:
+def get_tinybird_local_config(config_obj: Dict[str, Any], test: bool = False, silent: bool = False) -> CLIConfig:
     """Craft a client config with a workspace name based on the path of the project files
 
     It uses the tokens from tinybird local
@@ -76,7 +76,7 @@ async def get_tinybird_local_config(config_obj: Dict[str, Any], test: bool = Fal
             ws = None
 
         if not ws:
-            await user_client.create_workspace(ws_name, assign_to_organization_id=user_org_id, version="v1")
+            user_client.create_workspace(ws_name, assign_to_organization_id=user_org_id, version="v1")
             user_workspaces = requests.get(f"{TB_LOCAL_ADDRESS}/v1/user/workspaces?token={admin_token}").json()
             ws = next((ws for ws in user_workspaces["workspaces"] if ws["name"] == ws_name), None)
             if not ws:

tinybird/tb/modules/login.py

@@ -19,7 +19,7 @@ import requests
 
 from tinybird.tb.config import DEFAULT_API_HOST
 from tinybird.tb.modules.cli import CLIConfig, cli
-from tinybird.tb.modules.common import ask_for_region_interactively, coro, get_regions
+from tinybird.tb.modules.common import ask_for_region_interactively, get_regions
 from tinybird.tb.modules.exceptions import CLILoginException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -135,8 +135,7 @@ def start_server(auth_callback, auth_host):
     default="browser",
     help="Set the authentication method to use. Default: browser.",
 )
-@coro
-async def login(host: Optional[str], auth_host: str, workspace: str, interactive: bool, method: str):
+def login(host: Optional[str], auth_host: str, workspace: str, interactive: bool, method: str):
     """Authenticate using the browser."""
     try:
         cli_config = CLIConfig.get_project_config()
@@ -148,7 +147,7 @@ async def login(host: Optional[str], auth_host: str, workspace: str, interactive
             else:
                 click.echo(FeedbackManager.highlight(message="» No region detected, select one from the list below:"))
 
-            regions = await get_regions(cli_config)
+            regions = get_regions(cli_config)
             selected_region = ask_for_region_interactively(regions)
 
             # If the user cancels the selection, we'll exit
@@ -202,7 +201,7 @@ async def login(host: Optional[str], auth_host: str, workspace: str, interactive
 
                     time.sleep(2)  # noqa: ASYNC251
 
-            await poll_for_tokens()
+            poll_for_tokens()
             return
 
         auth_event = threading.Event()
@@ -236,12 +235,12 @@ async def login(host: Optional[str], auth_host: str, workspace: str, interactive
         if auth_event.wait(timeout=SERVER_MAX_WAIT_TIME):  # Wait for up to 180 seconds
             params = {}
             params["code"] = auth_code[0]
-            response = requests.get(  # noqa: ASYNC210
+            response = requests.get(
                 f"{auth_host}/api/cli-login?{urlencode(params)}",
             )
 
             data = response.json()
-            await authenticate_with_tokens(data, host, cli_config)
+            authenticate_with_tokens(data, host, cli_config)
         else:
             raise Exception("Authentication failed or timed out.")
     except Exception as e:
@@ -308,13 +307,13 @@ def create_one_time_code():
     return seperator.join(parts), full_code
 
 
-async def authenticate_with_tokens(data: Dict[str, Any], host: Optional[str], cli_config: CLIConfig):
+def authenticate_with_tokens(data: Dict[str, Any], host: Optional[str], cli_config: CLIConfig):
     cli_config.set_token(data.get("workspace_token", ""))
     host = host or data.get("api_host", "")
     cli_config.set_token_for_host(data.get("workspace_token", ""), host)
     cli_config.set_user_token(data.get("user_token", ""))
     cli_config.set_host(host)
-    ws = await cli_config.get_client(token=data.get("workspace_token", ""), host=host).workspace_info(version="v1")
+    ws = cli_config.get_client(token=data.get("workspace_token", ""), host=host).workspace_info(version="v1")
     for k in ("id", "name", "user_email", "user_id", "scope"):
         if k in ws:
             cli_config[k] = ws[k]
@@ -322,7 +321,7 @@ async def authenticate_with_tokens(data: Dict[str, Any], host: Optional[str], cl
     path = os.path.join(os.getcwd(), ".tinyb")
     cli_config.persist_to_file(override_with_path=path)
 
-    auth_info: Dict[str, Any] = await cli_config.get_user_client().check_auth_login()
+    auth_info: Dict[str, Any] = cli_config.get_user_client().check_auth_login()
     if not auth_info.get("is_valid", False):
         raise Exception(FeedbackManager.error_auth_login_not_valid(host=cli_config.get_host()))
 

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")