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

tinybird/tb/modules/datasource.py

@@ -3,10 +3,10 @@
 # - 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 json
 import os
 import re
+import time
 import uuid
 from datetime import datetime
 from pathlib import Path
@@ -20,14 +20,12 @@ from click import Context
 
 from tinybird.datafile.common import get_name_version
 from tinybird.prompts import quarantine_prompt
-from tinybird.syncasync import sync_to_async
 from tinybird.tb.client import AuthNoTokenException, DoesNotExistException, TinyB
 from tinybird.tb.modules.build import process as build_project
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import (
     _analyze,
     analyze_file,
-    coro,
     echo_safe_humanfriendly_tables_format_smart_table,
     get_format_from_filename_or_url,
     load_connector_config,
@@ -66,12 +64,11 @@ def datasource(ctx):
     help="Force a type of the output",
 )
 @click.pass_context
-@coro
-async def datasource_ls(ctx: Context, match: Optional[str], format_: str):
+def datasource_ls(ctx: Context, match: Optional[str], format_: str):
     """List data sources"""
 
     client: TinyB = ctx.ensure_object(dict)["client"]
-    ds = await client.datasources()
+    ds = client.datasources()
     columns = ["shared from", "name", "row_count", "size", "created at", "updated at", "connection"]
     table_human_readable = []
     table_machine_readable = []
@@ -134,8 +131,7 @@ async def datasource_ls(ctx: Context, match: Optional[str], format_: str):
 @click.option("--events", type=str, help="Events to append data from")
 @click.option("--concurrency", help="How many files to submit concurrently", default=1, hidden=True)
 @click.pass_context
-@coro
-async def datasource_append(
+def datasource_append(
     ctx: Context,
     datasource_name: str,
     data: Optional[str],
@@ -194,7 +190,7 @@ async def datasource_append(
     else:
         tip = "Did you deploy your project? Run `tb --cloud deploy` first."
 
-    datasources = await client.datasources()
+    datasources = client.datasources()
     if not datasources:
         raise CLIDatasourceException(FeedbackManager.error(message=f"No data sources found. {tip}"))
 
@@ -265,7 +261,7 @@ async def datasource_append(
 
     if events:
         click.echo(FeedbackManager.highlight(message=f"\n» Sending events to {datasource_name}"))
-        response = await sync_to_async(requests.post)(
+        response = requests.post(
             f"{client.host}/v0/events?name={datasource_name}",
             headers={"Authorization": f"Bearer {client.token}"},
             data=events,
@@ -290,12 +286,12 @@ async def datasource_append(
                     message=f"✗ {quarantined_rows} row{'' if quarantined_rows == 1 else 's'} went to quarantine"
                 )
             )
-            await analyze_quarantine(datasource_name, project, client)
+            analyze_quarantine(datasource_name, project, client)
             return
     else:
         click.echo(FeedbackManager.highlight(message=f"\n» Appending data to {datasource_name}"))
         try:
-            await push_data(
+            push_data(
                 client,
                 datasource_name,
                 data,
@@ -307,7 +303,7 @@ async def datasource_append(
             is_quarantined = "quarantine" in str(e)
             click.echo(FeedbackManager.error(message="✗ " + str(e)))
             if is_quarantined:
-                await analyze_quarantine(datasource_name, project, client)
+                analyze_quarantine(datasource_name, project, client)
                 return
             else:
                 raise e
@@ -320,8 +316,7 @@ async def datasource_append(
 @click.option("--sql-condition", default=None, help="SQL WHERE condition to replace data", hidden=True)
 @click.option("--skip-incompatible-partition-key", is_flag=True, default=False, hidden=True)
 @click.pass_context
-@coro
-async def datasource_replace(
+def datasource_replace(
     ctx: Context,
     datasource_name,
     url,
@@ -340,7 +335,7 @@ async def datasource_replace(
     if skip_incompatible_partition_key:
         replace_options.add("skip_incompatible_partition_key")
     client: TinyB = ctx.obj["client"]
-    await push_data(
+    push_data(
         client,
         datasource_name,
         url,
@@ -359,8 +354,7 @@ async def datasource_replace(
     hidden=True,
 )
 @click.pass_context
-@coro
-async def datasource_analyze(ctx, url_or_file, connector):
+def datasource_analyze(ctx, url_or_file, connector):
     """Analyze a URL or a file before creating a new data source"""
     client = ctx.obj["client"]
 
@@ -379,7 +373,7 @@ async def datasource_analyze(ctx, url_or_file, connector):
         for t in data:
             click.echo(FeedbackManager.info_datasource_row(row=row_format.format(*[str(element) for element in t])))
 
-    analysis, _ = await _analyze(
+    analysis, _ = _analyze(
         url_or_file, client, format=get_format_from_filename_or_url(url_or_file), connector=_connector
     )
 
@@ -418,14 +412,13 @@ async def datasource_analyze(ctx, url_or_file, connector):
     "--cascade", is_flag=True, default=False, help="Truncate dependent DS attached in cascade to the given DS"
 )
 @click.pass_context
-@coro
-async def datasource_truncate(ctx, datasource_name, yes, cascade):
+def datasource_truncate(ctx, datasource_name, yes, cascade):
     """Truncate a data source"""
 
     client = ctx.obj["client"]
     if yes or click.confirm(FeedbackManager.warning_confirm_truncate_datasource(datasource=datasource_name)):
         try:
-            await client.datasource_truncate(datasource_name)
+            client.datasource_truncate(datasource_name)
         except AuthNoTokenException:
             raise
         except DoesNotExistException:
@@ -437,7 +430,7 @@ async def datasource_truncate(ctx, datasource_name, yes, cascade):
 
         if cascade:
             try:
-                ds_cascade_dependencies = await client.datasource_dependencies(
+                ds_cascade_dependencies = client.datasource_dependencies(
                     no_deps=False,
                     match=None,
                     pipe=None,
@@ -454,7 +447,7 @@ async def datasource_truncate(ctx, datasource_name, yes, cascade):
             for cascade_ds in cascade_dependent_ds:
                 if yes or click.confirm(FeedbackManager.warning_confirm_truncate_datasource(datasource=cascade_ds)):
                     try:
-                        await client.datasource_truncate(cascade_ds)
+                        client.datasource_truncate(cascade_ds)
                     except DoesNotExistException:
                         raise CLIDatasourceException(
                             FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name)
@@ -471,8 +464,7 @@ async def datasource_truncate(ctx, datasource_name, yes, cascade):
 @click.option("--wait", is_flag=True, default=False, help="Wait for delete job to finish, disabled by default")
 @click.option("--dry-run", is_flag=True, default=False, help="Run the command without deleting anything")
 @click.pass_context
-@coro
-async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait, dry_run):
+def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait, dry_run):
     """
     Delete rows from a datasource
 
@@ -492,7 +484,7 @@ async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait,
         )
     ):
         try:
-            res = await client.datasource_delete_rows(datasource_name, sql_condition, dry_run)
+            res = client.datasource_delete_rows(datasource_name, sql_condition, dry_run)
             if dry_run:
                 click.echo(
                     FeedbackManager.success_dry_run_delete_rows_datasource(
@@ -515,7 +507,7 @@ async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait,
                 i = 0
                 while True:
                     try:
-                        res = await client._req(f"v0/jobs/{job_id}")
+                        res = client._req(f"v0/jobs/{job_id}")
                     except Exception:
                         raise CLIDatasourceException(FeedbackManager.error_job_status(url=job_url))
                     if res["status"] == "done":
@@ -529,7 +521,7 @@ async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait,
                     elif res["status"] == "error":
                         print("\n")  # noqa: T201
                         raise CLIDatasourceException(FeedbackManager.error_exception(error=res["error"]))
-                    await asyncio.sleep(1)
+                    time.sleep(1)
                     i += 1
                     progress_line(i)
 
@@ -551,8 +543,7 @@ async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait,
 @click.argument("datasource")
 @click.option("--limit", type=int, default=5, help="Limit the number of rows to return")
 @click.pass_context
-@coro
-async def datasource_data(ctx: Context, datasource: str, limit: int):
+def datasource_data(ctx: Context, datasource: str, limit: int):
     """Print data returned by an endpoint
 
     Syntax: tb datasource data <datasource_name>
@@ -560,7 +551,7 @@ async def datasource_data(ctx: Context, datasource: str, limit: int):
 
     client: TinyB = ctx.ensure_object(dict)["client"]
     try:
-        res = await client.query(f"SELECT * FROM {datasource} LIMIT {limit} FORMAT JSON")
+        res = client.query(f"SELECT * FROM {datasource} LIMIT {limit} FORMAT JSON")
     except AuthNoTokenException:
         raise
     except Exception as e:
@@ -587,8 +578,7 @@ async def datasource_data(ctx: Context, datasource: str, limit: int):
 @click.option("--where", type=str, default=None, help="Condition to filter data")
 @click.option("--target", type=str, help="Target file path (default: datasource_name.{format})")
 @click.pass_context
-@coro
-async def datasource_export(
+def datasource_export(
     ctx: Context,
     datasource: str,
     format_: str,
@@ -617,7 +607,7 @@ async def datasource_export(
         else:
             query += " FORMAT JSONEachRow"
 
-        res = await client.query(query)
+        res = client.query(query)
 
         target_path = persist_fixture(datasource, res, project.folder, format=format_, target=target)
         file_size = os.path.getsize(target_path)
@@ -636,16 +626,15 @@ async def datasource_export(
 @click.argument("datasource_name")
 @click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
 @click.pass_context
-@coro
-async def datasource_sync(ctx: Context, datasource_name: str, yes: bool):
+def datasource_sync(ctx: Context, datasource_name: str, yes: bool):
     try:
         client: TinyB = ctx.obj["client"]
-        ds = await client.get_datasource(datasource_name)
+        ds = client.get_datasource(datasource_name)
 
         warning_message = FeedbackManager.warning_datasource_sync_bucket(datasource=datasource_name)
 
         if yes or click.confirm(warning_message):
-            await client.datasource_sync(ds["id"])
+            client.datasource_sync(ds["id"])
             click.echo(FeedbackManager.success_sync_datasource(datasource=datasource_name))
     except AuthNoTokenException:
         raise
@@ -664,8 +653,7 @@ async def datasource_sync(ctx: Context, datasource_name: str, yes: bool):
 @click.option("--gcs", is_flag=True, default=False, help="Create a data source from a GCS connection")
 @click.option("--kafka", is_flag=True, default=False, help="Create a data source from a Kafka connection")
 @click.pass_context
-@coro
-async def datasource_create(
+def datasource_create(
     ctx: Context,
     name: str,
     blank: bool,
@@ -781,7 +769,7 @@ async def datasource_create(
             raise Exception("This action requires authentication. Run 'tb login' first.")
         project_config = CLIConfig.get_project_config()
         tb_client: TinyB = project_config.get_client(token=config.get("token"), host=config.get("host"))
-        await create_resources_from_prompt(tb_client, user_token, prompt, project, feature="tb_datasource_create")
+        create_resources_from_prompt(tb_client, user_token, prompt, project, feature="tb_datasource_create")
         click.echo(FeedbackManager.success(message="✓ .datasource created!"))
         return
 
@@ -832,9 +820,9 @@ async def datasource_create(
                         sasl_mechanism,
                         security_protocol,
                         topics,
-                    ) = await connection_create_kafka(ctx)
+                    ) = connection_create_kafka(ctx)
                 elif datasource_type == "s3":
-                    await generate_aws_iamrole_connection_file_with_secret(
+                    generate_aws_iamrole_connection_file_with_secret(
                         connection_name,
                         service="s3",
                         role_arn_secret_name="S3_ARN",
@@ -843,7 +831,7 @@ async def datasource_create(
                         with_default_secret=True,
                     )
                 elif datasource_type == "gcs":
-                    await generate_gcs_connection_file_with_secrets(
+                    generate_gcs_connection_file_with_secrets(
                         connection_name,
                         service="gcs",
                         svc_account_creds="GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON",
@@ -896,7 +884,7 @@ async def datasource_create(
             path = Path(file)
 
         data_format = path.suffix.lstrip(".")
-        ds_content = await analyze_file(str(path), client, format=data_format)
+        ds_content = analyze_file(str(path), client, format=data_format)
         default_name = normalize_datasource_name(path.stem)
         name = name or click.prompt(
             FeedbackManager.highlight(message=f"? Data source name [{default_name}]"),
@@ -908,7 +896,7 @@ async def datasource_create(
         if not url:
             url = click.prompt(FeedbackManager.highlight(message="? URL"))
         format = url.split(".")[-1]
-        ds_content = await analyze_file(url, client, format)
+        ds_content = analyze_file(url, client, format)
         default_name = normalize_datasource_name(Path(url).stem)
         name = name or click.prompt(
             FeedbackManager.highlight(message=f"? Data source name [{default_name}]"),
@@ -925,7 +913,7 @@ async def datasource_create(
         )
 
     if datasource_type == "kafka":
-        connections = await client.connections("kafka")
+        connections = client.connections("kafka")
         kafka_connection_files = project.get_kafka_connection_files()
 
         # if we have no topics from before and no connections, we need to build the project
@@ -941,13 +929,13 @@ async def datasource_create(
                 click.echo(FeedbackManager.gray(message="» Building project..."))
                 build_project(project=project, tb_client=client, watch=False, silent=True)
                 click.echo(FeedbackManager.success(message="✓ Build completed!"))
-                connections = await client.connections("kafka")
+                connections = client.connections("kafka")
 
         connection_id = next((c["id"] for c in connections if c["name"] == connection), connection)
 
         if not topics:
             try:
-                topics = await client.kafka_list_topics(connection_id) if connection_id else []
+                topics = client.kafka_list_topics(connection_id) if connection_id else []
             except Exception:
                 topics = []
 
@@ -975,7 +963,7 @@ KAFKA_GROUP_ID {group_id}
 
     if datasource_type == "s3":
         if not connection:
-            connections = await client.connections("s3")
+            connections = client.connections("s3")
             connection = next((c["name"] for c in connections if c["name"] == connection), connection)
         ds_content += f"""
 IMPORT_CONNECTION_NAME "{connection}"
@@ -985,7 +973,7 @@ IMPORT_SCHEDULE "@auto"
 
     if datasource_type == "gcs":
         if not connection:
-            connections = await client.connections("gcs")
+            connections = client.connections("gcs")
             connection = next((c["name"] for c in connections if c["name"] == connection), connection)
         ds_content += f"""
 IMPORT_CONNECTION_NAME "{connection}"
@@ -1026,11 +1014,9 @@ def generate_kafka_group_id(topic: str):
     return f"{topic}_{int(datetime.timestamp(datetime.now()))}"
 
 
-async def analyze_quarantine(datasource_name: str, project: Project, client: TinyB):
+def analyze_quarantine(datasource_name: str, project: Project, client: TinyB):
     config = CLIConfig.get_project_config()
-    res = await client.query(
-        f"SELECT * FROM {datasource_name}_quarantine ORDER BY insertion_date DESC LIMIT 1 FORMAT JSON"
-    )
+    res = client.query(f"SELECT * FROM {datasource_name}_quarantine ORDER BY insertion_date DESC LIMIT 1 FORMAT JSON")
     quarantine_data = res["data"]
     error_message = json.dumps(res["data"])
     user_token = config.get_user_token()

tinybird/tb/modules/endpoint.py

@@ -17,7 +17,7 @@ from click import Context
 from tinybird.datafile.common import get_name_version
 from tinybird.tb.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.common import echo_safe_humanfriendly_tables_format_smart_table
 from tinybird.tb.modules.exceptions import CLIPipeException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -38,15 +38,14 @@ def endpoint(ctx):
     help="Force a type of the output",
 )
 @click.pass_context
-@coro
-async def endpoint_ls(ctx: Context, match: str, format_: str):
+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")
+    pipes = 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()
+    tokens = client.tokens()
     columns = ["name", "updated at", "nodes", "url"]
     table_human_readable = []
     table_machine_readable = []
@@ -80,17 +79,16 @@ async def endpoint_ls(ctx: Context, match: str, format_: str):
 @endpoint.command(name="token")
 @click.argument("pipe_name")
 @click.pass_context
-@coro
-async def endpoint_token(ctx: click.Context, pipe_name: str):
+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)
+        client.pipe_file(pipe_name)
     except DoesNotExistException:
         raise CLIPipeException(FeedbackManager.error_pipe_does_not_exist(pipe=pipe_name))
 
-    tokens = await client.tokens()
+    tokens = client.tokens()
     token = get_endpoint_token(tokens, pipe_name)
     if token:
         click.echo(token)
@@ -111,8 +109,7 @@ async def endpoint_token(ctx: click.Context, pipe_name: str):
     "--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):
+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 ...
@@ -122,7 +119,7 @@ async def endpoint_data(ctx: Context, pipe: str, query: str, format_: str):
     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)
+        res = client.pipe_data(pipe, format=req_format, sql=query, params=params)
     except AuthNoTokenException:
         raise
     except Exception as e:
@@ -158,13 +155,12 @@ async def endpoint_data(ctx: Context, pipe: str, query: str, format_: str):
     help="Language used for sending the request. Options: http, python, curl, javascript, rust, go",
 )
 @click.pass_context
-@coro
-async def endpoint_url(ctx: Context, pipe: str, language: str):
+def endpoint_url(ctx: Context, pipe: str, language: str):
     """Print the URL of an endpoint"""
     if language != "http":
         click.echo(FeedbackManager.highlight(message=f"\n» Generating snippet for {language} language"))
     client: TinyB = ctx.ensure_object(dict)["client"]
-    tokens = await client.tokens()
+    tokens = client.tokens()
     token = get_endpoint_token(tokens, pipe) or client.token
     click.echo(build_endpoint_snippet(client, pipe, token, language, client.staging))
     if language != "http":
@@ -192,13 +188,12 @@ def get_endpoint_token(tokens: List[Dict[str, Any]], pipe_name: str) -> Optional
     help="Force a type of the output. To parse the output, keep in mind to use `tb --no-version-warning endpoint stats` option.",
 )
 @click.pass_context
-@coro
-async def endpoint_stats(ctx: click.Context, pipes: Tuple[str, ...], format_: str):
+def endpoint_stats(ctx: click.Context, pipes: Tuple[str, ...], format_: str):
     """
     Print endpoint stats for the last 7 days
     """
     client: TinyB = ctx.ensure_object(dict)["client"]
-    all_pipes = await client.pipes()
+    all_pipes = client.pipes()
     pipes_to_get_stats = []
     pipes_ids: Dict = {}
 
@@ -232,7 +227,7 @@ async def endpoint_stats(ctx: click.Context, pipes: Tuple[str, ...], format_: st
         FORMAT JSON
     """
 
-    res = await client.query(sql)
+    res = client.query(sql)
 
     if res and "error" in res:
         raise CLIPipeException(FeedbackManager.error_exception(error=str(res["error"])))

tinybird/tb/modules/info.py

@@ -6,7 +6,7 @@ import click
 from tinybird.tb.client import TinyB
 from tinybird.tb.config import get_display_cloud_host
 from tinybird.tb.modules.cli import CLIConfig, cli
-from tinybird.tb.modules.common import coro, echo_json, force_echo, format_robust_table
+from tinybird.tb.modules.common import echo_json, force_echo, format_robust_table
 from tinybird.tb.modules.exceptions import CLILocalException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.local_common import TB_LOCAL_ADDRESS, get_tinybird_local_config
@@ -15,8 +15,7 @@ from tinybird.tb.modules.project import Project
 
 @cli.command(name="info")
 @click.pass_context
-@coro
-async def info(ctx: click.Context) -> None:
+def info(ctx: click.Context) -> None:
     """Get information about the project that is currently being used"""
     ctx_config = ctx.ensure_object(dict)["config"]
     project: Project = ctx.ensure_object(dict)["project"]
@@ -27,11 +26,11 @@ async def info(ctx: click.Context) -> None:
         return
 
     click.echo(FeedbackManager.highlight(message="» Tinybird Cloud:"))
-    cloud_table, cloud_columns = await get_cloud_info(ctx_config)
+    cloud_table, cloud_columns = get_cloud_info(ctx_config)
     click.echo(FeedbackManager.highlight(message="\n» Tinybird Local:"))
-    local_table, local_columns = await get_local_info(ctx_config)
+    local_table, local_columns = get_local_info(ctx_config)
     click.echo(FeedbackManager.highlight(message="\n» Project:"))
-    project_table, project_columns = await get_project_info(project.folder)
+    project_table, project_columns = get_project_info(project.folder)
     if output == "json":
         cloud_data = {}
         if cloud_columns and cloud_table and isinstance(cloud_table, list) and len(cloud_table) > 0:
@@ -47,7 +46,7 @@ async def info(ctx: click.Context) -> None:
         echo_json({"cloud": cloud_data, "local": local_data, "project": project_data})
 
 
-async def get_cloud_info(ctx_config: Dict[str, Any]) -> Tuple[Iterable[Any], List[str]]:
+def get_cloud_info(ctx_config: Dict[str, Any]) -> Tuple[Iterable[Any], List[str]]:
     config = CLIConfig.get_project_config()
 
     try:
@@ -57,7 +56,7 @@ async def get_cloud_info(ctx_config: Dict[str, Any]) -> Tuple[Iterable[Any], Lis
         ui_host = get_display_cloud_host(api_host)
         user_email = config.get("user_email") or "No user email found"
         user_token = config.get_user_token() or "No user token found"
-        return await get_env_info(client, ctx_config, user_email, token, user_token, api_host, ui_host)
+        return get_env_info(client, ctx_config, user_email, token, user_token, api_host, ui_host)
     except Exception:
         click.echo(
             FeedbackManager.warning(
@@ -67,16 +66,16 @@ async def get_cloud_info(ctx_config: Dict[str, Any]) -> Tuple[Iterable[Any], Lis
         return [], []
 
 
-async def get_local_info(config: Dict[str, Any]) -> Tuple[Iterable[Any], List[str]]:
+def get_local_info(config: Dict[str, Any]) -> Tuple[Iterable[Any], List[str]]:
     try:
-        local_config = await get_tinybird_local_config(config, test=False, silent=False)
+        local_config = get_tinybird_local_config(config, test=False, silent=False)
         local_client = local_config.get_client(host=TB_LOCAL_ADDRESS, staging=False)
         user_email = local_config.get_user_email() or "No user email found"
         token = local_config.get_token() or "No token found"
         user_token = local_config.get_user_token() or "No user token found"
         api_host = TB_LOCAL_ADDRESS
         ui_host = get_display_cloud_host(api_host)
-        return await get_env_info(local_client, config, user_email, token, user_token, api_host, ui_host, is_local=True)
+        return get_env_info(local_client, config, user_email, token, user_token, api_host, ui_host, is_local=True)
     except CLILocalException as e:
         raise e
     except Exception as e:
@@ -88,7 +87,7 @@ async def get_local_info(config: Dict[str, Any]) -> Tuple[Iterable[Any], List[st
         return [], []
 
 
-async def get_env_info(
+def get_env_info(
     client: TinyB,
     config: Dict[str, Any],
     user_email: str,
@@ -98,8 +97,8 @@ async def get_env_info(
     ui_host: str,
     is_local=False,
 ) -> Tuple[List[Any], List[str]]:
-    user_workspaces = await client.user_workspaces(version="v1")
-    current_workspace = await client.workspace_info(version="v1")
+    user_workspaces = client.user_workspaces(version="v1")
+    current_workspace = client.workspace_info(version="v1")
 
     def _get_current_workspace(user_workspaces: Dict[str, Any], current_workspace_id: str) -> Optional[Dict[str, Any]]:
         def get_workspace_by_name(workspaces: List[Dict[str, Any]], name: str) -> Optional[Dict[str, Any]]:
@@ -136,7 +135,7 @@ async def get_env_info(
     return table, columns
 
 
-async def get_project_info(project_path: Optional[str] = None) -> Tuple[Iterable[Any], List[str]]:
+def get_project_info(project_path: Optional[str] = None) -> Tuple[Iterable[Any], List[str]]:
     config = CLIConfig.get_project_config()
     tinyb_path = config.get_tinyb_file()
     current_path = os.getcwd()