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

tinybird/tb/modules/common.py

@@ -5,7 +5,6 @@
 #   the function to the proper command file.
 # - Please, **do not** define commands here.
 
-import asyncio
 import json
 import os
 import re
@@ -16,13 +15,11 @@ import uuid
 from contextlib import closing
 from copy import deepcopy
 from enum import Enum
-from functools import wraps
 from os import environ, getcwd, getenv
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Literal, Optional, Set, Tuple, TypedDict, Union
 from urllib.parse import urlparse
 
-import aiofiles
 import click
 import click.formatting
 import humanfriendly
@@ -58,7 +55,6 @@ from tinybird.tb.modules.table import format_table
 if TYPE_CHECKING:
     from tinybird.connectors import Connector
 
-from tinybird.syncasync import async_to_sync, sync_to_async
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.exceptions import (
     CLIAuthException,
@@ -97,22 +93,14 @@ def create_connector(connector: str, options: Dict[str, Any]):
     return _create_connector(connector, options)
 
 
-def coro(f):
-    @wraps(f)
-    def wrapper(*args, **kwargs):
-        return asyncio.run(f(*args, **kwargs))
-
-    return wrapper
-
-
-async def gather_with_concurrency(n, *tasks):
-    semaphore = asyncio.Semaphore(n)
-
-    async def sem_task(task):
-        async with semaphore:
-            return await task
-
-    return await asyncio.gather(*(sem_task(task) for task in tasks))
+def gather_with_concurrency(n, *tasks):
+    results = []
+    for task in tasks:
+        if callable(task):
+            results.append(task())
+        else:
+            results.append(task)
+    return results
 
 
 def format_robust_table(data: Iterable[Any], column_names: List[str]):
@@ -201,9 +189,9 @@ def generate_datafile(
     return f
 
 
-async def get_current_workspace(config: CLIConfig) -> Optional[Dict[str, Any]]:
+def get_current_workspace(config: CLIConfig) -> Optional[Dict[str, Any]]:
     client = config.get_client()
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches(version="v1")).get("workspaces", [])
+    workspaces: List[Dict[str, Any]] = (client.user_workspaces_and_branches(version="v1")).get("workspaces", [])
     return _get_current_workspace_common(workspaces, config["id"])
 
 
@@ -217,8 +205,8 @@ def _get_current_workspace_common(
     return next((workspace for workspace in workspaces if workspace["id"] == current_workspace_id), None)
 
 
-async def get_current_environment(client, config):
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches(version="v1")).get("workspaces", [])
+def get_current_environment(client, config):
+    workspaces: List[Dict[str, Any]] = (client.user_workspaces_and_branches(version="v1")).get("workspaces", [])
     return next((workspace for workspace in workspaces if workspace["id"] == config["id"]), None)
 
 
@@ -383,36 +371,36 @@ def create_tb_client(ctx: Context) -> TinyB:
     return _get_tb_client(token, host)
 
 
-async def _analyze(filename: str, client: TinyB, format: str, connector: Optional["Connector"] = None):
+def _analyze(filename: str, client: TinyB, format: str, connector: Optional["Connector"] = None):
     data: Optional[bytes] = None
     if not connector:
         parsed = urlparse(filename)
         if parsed.scheme in ("http", "https"):
-            meta = await client.datasource_analyze(filename)
+            meta = client.datasource_analyze(filename)
         else:
-            async with aiofiles.open(filename, "rb") as file:
+            with open(filename, "rb") as file:
                 # We need to read the whole file in binary for Parquet, while for the
                 # others we just read 1KiB
                 if format == "parquet":
-                    data = await file.read()
+                    data = file.read()
                 else:
-                    data = await file.read(1024 * 1024)
+                    data = file.read(1024 * 1024)
 
-            meta = await client.datasource_analyze_file(data)
+            meta = client.datasource_analyze_file(data)
     else:
         meta = connector.datasource_analyze(filename)
     return meta, data
 
 
-async def analyze_file(filename: str, client: TinyB, format: str):
-    meta, data = await _analyze(filename, client, format)
+def analyze_file(filename: str, client: TinyB, format: str):
+    meta, data = _analyze(filename, client, format)
     schema = meta["analysis"]["schema"]
     schema = schema.replace(", ", ",\n    ")
     content = f"""DESCRIPTION >\n    Generated from {filename}\n\nSCHEMA >\n    {schema}"""
     return content
 
 
-async def _generate_datafile(
+def _generate_datafile(
     filename: str,
     client: TinyB,
     format: str,
@@ -420,14 +408,14 @@ async def _generate_datafile(
     force: Optional[bool] = False,
     folder: Optional[str] = None,
 ):
-    meta, data = await _analyze(filename, client, format, connector=connector)
+    meta, data = _analyze(filename, client, format, connector=connector)
     schema = meta["analysis"]["schema"]
     schema = schema.replace(", ", ",\n    ")
     datafile = f"""DESCRIPTION >\n    Generated from {filename}\n\nSCHEMA >\n    {schema}"""
     return generate_datafile(datafile, filename, data, force, _format=format, folder=folder)
 
 
-async def configure_connector(connector):
+def configure_connector(connector):
     if connector not in SUPPORTED_CONNECTORS:
         raise CLIException(FeedbackManager.error_invalid_connector(connectors=", ".join(SUPPORTED_CONNECTORS)))
 
@@ -443,7 +431,7 @@ async def configure_connector(connector):
 
         try:
             config = {"project_id": project, "service_account": service_account, "bucket_name": bucket_name}
-            await write_config(config, file_name)
+            write_config(config, file_name)
         except Exception:
             raise CLIException(FeedbackManager.error_file_config(config_file=config_file))
     elif connector == "snowflake":
@@ -483,7 +471,7 @@ async def configure_connector(connector):
                 "bucket_name": bucket_name,
                 "project_id": project,
             }
-            await write_config(config, file_name)
+            write_config(config, file_name)
         except Exception:
             raise CLIException(FeedbackManager.error_file_config(config_file=config_file))
 
@@ -592,13 +580,13 @@ def ask_for_user_token(action: str, ui_host: str) -> str:
     )
 
 
-async def check_user_token(ctx: Context, token: str):
+def check_user_token(ctx: Context, token: str):
     client: TinyB = ctx.ensure_object(dict)["client"]
     try:
         user_client: TinyB = deepcopy(client)
         user_client.token = token
 
-        is_authenticated = await user_client.check_auth_login()
+        is_authenticated = user_client.check_auth_login()
     except Exception as e:
         raise CLIWorkspaceException(FeedbackManager.error_exception(error=str(e)))
 
@@ -616,12 +604,12 @@ async def check_user_token(ctx: Context, token: str):
         )
 
 
-async def check_user_token_with_client(client: TinyB, token: str):
+def check_user_token_with_client(client: TinyB, token: str):
     try:
         user_client: TinyB = deepcopy(client)
         user_client.token = token
 
-        is_authenticated = await user_client.check_auth_login()
+        is_authenticated = user_client.check_auth_login()
     except Exception as e:
         raise CLIWorkspaceException(FeedbackManager.error_exception(error=str(e)))
 
@@ -639,15 +627,15 @@ async def check_user_token_with_client(client: TinyB, token: str):
         )
 
 
-async def fork_workspace(client: TinyB, user_client: TinyB, created_workspace):
+def fork_workspace(client: TinyB, user_client: TinyB, created_workspace):
     config = CLIConfig.get_project_config()
 
-    datasources = await client.datasources()
+    datasources = client.datasources()
     for datasource in datasources:
-        await user_client.datasource_share(datasource["id"], config["id"], created_workspace["id"])
+        user_client.datasource_share(datasource["id"], config["id"], created_workspace["id"])
 
 
-async def create_workspace_non_interactive(
+def create_workspace_non_interactive(
     ctx: Context,
     workspace_name: str,
     user_token: str,
@@ -662,7 +650,7 @@ async def create_workspace_non_interactive(
         user_client: TinyB = deepcopy(client)
         user_client.token = user_token
 
-        created_workspace = await user_client.create_workspace(workspace_name, organization_id, version="v1")
+        created_workspace = user_client.create_workspace(workspace_name, organization_id, version="v1")
         if organization_id and organization_name:
             click.echo(
                 FeedbackManager.success_workspace_created_with_organization(
@@ -673,13 +661,13 @@ async def create_workspace_non_interactive(
             click.echo(FeedbackManager.success_workspace_created(workspace_name=workspace_name))
 
         if fork:
-            await fork_workspace(client, user_client, created_workspace)
+            fork_workspace(client, user_client, created_workspace)
 
     except Exception as e:
         raise CLIWorkspaceException(FeedbackManager.error_exception(error=str(e)))
 
 
-async def create_workspace_interactive(
+def create_workspace_interactive(
     ctx: Context,
     workspace_name: Optional[str],
     user_token: str,
@@ -697,7 +685,7 @@ async def create_workspace_interactive(
     if not workspace_name:
         raise CLIException(FeedbackManager.error_workspace_name_required())
 
-    await create_workspace_non_interactive(
+    create_workspace_non_interactive(
         ctx,
         workspace_name,
         user_token,
@@ -707,8 +695,8 @@ async def create_workspace_interactive(
     )
 
 
-async def print_data_branch_summary(client, job_id, response=None):
-    response = await client.job(job_id) if job_id else response or {"partitions": []}
+def print_data_branch_summary(client, job_id, response=None):
+    response = client.job(job_id) if job_id else response or {"partitions": []}
     columns = ["Data Source", "Partition", "Status", "Error"]
     table = []
     for partition in response["partitions"]:
@@ -717,7 +705,7 @@ async def print_data_branch_summary(client, job_id, response=None):
     echo_safe_humanfriendly_tables_format_smart_table(table, column_names=columns)
 
 
-async def print_branch_regression_tests_summary(client, job_id, host, response=None):
+def print_branch_regression_tests_summary(client, job_id, host, response=None):
     def format_metric(metric: Union[str, float], is_percentage: bool = False) -> str:
         if isinstance(metric, float):
             if is_percentage:
@@ -728,7 +716,7 @@ async def print_branch_regression_tests_summary(client, job_id, host, response=N
             return metric
 
     failed = False
-    response = await client.job(job_id) if job_id else response or {"progress": []}
+    response = client.job(job_id) if job_id else response or {"progress": []}
     output = "\n"
     for step in response["progress"]:
         run = step["run"]
@@ -927,7 +915,7 @@ def get_format_from_filename_or_url(filename_or_url: str) -> str:
     return "csv"
 
 
-async def push_data(
+def push_data(
     client: TinyB,
     datasource_name: str,
     url,
@@ -966,14 +954,14 @@ async def push_data(
     else:
         urls = [url]
 
-    async def process_url(
+    def process_url(
         datasource_name: str, url: str, mode: str, sql_condition: Optional[str], replace_options: Optional[Set[str]]
     ):
         parsed = urlparse(url)
         # poor man's format detection
         _format = get_format_from_filename_or_url(url)
         if parsed.scheme in ("http", "https"):
-            res = await client.datasource_create_from_url(
+            res = client.datasource_create_from_url(
                 datasource_name,
                 url,
                 mode=mode,
@@ -983,7 +971,7 @@ async def push_data(
                 replace_options=replace_options,
             )
         else:
-            res = await client.datasource_append_data(
+            res = client.datasource_append_data(
                 datasource_name,
                 file=url,
                 mode=mode,
@@ -994,7 +982,7 @@ async def push_data(
 
         datasource_name = res["datasource"]["name"]
         try:
-            datasource = await client.get_datasource(datasource_name)
+            datasource = client.get_datasource(datasource_name)
         except DoesNotExistException:
             raise CLIException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
         except Exception as e:
@@ -1021,7 +1009,7 @@ async def push_data(
 
     try:
         tasks = [process_url(datasource_name, url, mode, sql_condition, replace_options) for url in urls]
-        output = await gather_with_concurrency(concurrency, *tasks)
+        output = gather_with_concurrency(concurrency, *tasks)
         parser, total_rows, appended_rows = list(output)[-1]
     except AuthNoTokenException:
         raise
@@ -1040,9 +1028,9 @@ async def push_data(
             click.echo(FeedbackManager.success_progress_blocks())
 
 
-async def sync_data(ctx, datasource_name: str, yes: bool):
+def sync_data(ctx, datasource_name: str, yes: bool):
     client: TinyB = ctx.obj["client"]
-    datasource = await client.get_datasource(datasource_name)
+    datasource = client.get_datasource(datasource_name)
 
     VALID_DATASOURCES = ["bigquery", "snowflake", "s3", "gcs"]
     if datasource["type"] not in VALID_DATASOURCES:
@@ -1056,17 +1044,17 @@ async def sync_data(ctx, datasource_name: str, yes: bool):
         )
     )
     if yes or click.confirm(warning_message):
-        await client.datasource_sync(datasource["id"])
+        client.datasource_sync(datasource["id"])
         click.echo(FeedbackManager.success_sync_datasource(datasource=datasource_name))
 
 
 # eval "$(_TB_COMPLETE=source_bash tb)"
 def autocomplete_topics(ctx: Context, args, incomplete):
     try:
-        config = async_to_sync(get_config)(None, None)
+        config = get_config(None, None)
         ctx.ensure_object(dict)["config"] = config
         client = create_tb_client(ctx)
-        topics = async_to_sync(client.kafka_list_topics)(args[2])
+        topics = client.kafka_list_topics(args[2])
         return [t for t in topics if incomplete in t]
     except Exception:
         return []
@@ -1148,8 +1136,8 @@ def validate_string_connector_param(param, s):
         raise CLIConnectionException(param + " format is not correct, it must be a string")
 
 
-async def validate_connection_name(client, connection_name, service):
-    if await client.get_connector(connection_name, service) is not None:
+def validate_connection_name(client, connection_name, service):
+    if client.get_connector(connection_name, service) is not None:
         raise CLIConnectionException(FeedbackManager.error_connection_already_exists(name=connection_name))
 
 
@@ -1159,9 +1147,9 @@ def _get_setting_value(connection, setting, sensitive_settings):
     return connection.get(setting, "")
 
 
-async def switch_workspace(config: CLIConfig, workspace_name_or_id: str) -> None:
+def switch_workspace(config: CLIConfig, workspace_name_or_id: str) -> None:
     try:
-        response = await config.get_client().user_workspaces(version="v1")
+        response = config.get_client().user_workspaces(version="v1")
         workspaces = response["workspaces"]
 
         workspace = next(
@@ -1178,7 +1166,7 @@ async def switch_workspace(config: CLIConfig, workspace_name_or_id: str) -> None
 
         config.set_token(workspace["token"])
         config.set_token_for_host(workspace["token"], config.get_host())
-        _ = await try_update_config_with_remote(config)
+        _ = try_update_config_with_remote(config)
 
         # Set the id and name afterwards.
         # When working with branches the call to try_update_config_with_remote above
@@ -1197,7 +1185,7 @@ async def switch_workspace(config: CLIConfig, workspace_name_or_id: str) -> None
         raise CLIException(FeedbackManager.error_exception(error=str(e)))
 
 
-async def switch_to_workspace_by_user_workspace_data(config: CLIConfig, user_workspace_data: Dict[str, Any]):
+def switch_to_workspace_by_user_workspace_data(config: CLIConfig, user_workspace_data: Dict[str, Any]):
     try:
         config["id"] = user_workspace_data["id"]
         config["name"] = user_workspace_data["name"]
@@ -1210,10 +1198,10 @@ async def switch_to_workspace_by_user_workspace_data(config: CLIConfig, user_wor
         raise CLIException(FeedbackManager.error_exception(error=str(e)))
 
 
-async def print_current_workspace(config: CLIConfig) -> None:
-    _ = await try_update_config_with_remote(config, only_if_needed=True)
+def print_current_workspace(config: CLIConfig) -> None:
+    _ = try_update_config_with_remote(config, only_if_needed=True)
 
-    current_main_workspace = await get_current_main_workspace(config)
+    current_main_workspace = get_current_main_workspace(config)
     assert isinstance(current_main_workspace, dict)
 
     columns = ["name", "id", "role", "plan", "current"]
@@ -1291,7 +1279,7 @@ class ConnectionReplacements:
 # ======
 
 
-async def get_host_from_region(
+def get_host_from_region(
     config: CLIConfig, region_name_or_host_or_id: str, host: Optional[str] = None
 ) -> Tuple[List[Region], str]:
     regions: List[Region]
@@ -1300,7 +1288,7 @@ async def get_host_from_region(
     host = host or config.get_host(use_defaults_if_needed=True)
 
     try:
-        regions = await get_regions(config)
+        regions = get_regions(config)
         assert isinstance(regions, list)
     except Exception:
         regions = []
@@ -1330,10 +1318,10 @@ async def get_host_from_region(
     return regions, host
 
 
-async def get_regions(config: CLIConfig) -> List[Region]:
+def get_regions(config: CLIConfig) -> List[Region]:
     regions: List[Region] = []
     try:
-        response = await config.get_client().regions()
+        response = config.get_client().regions()
         regions = response.get("regions", [])
         first_default_region = next((region for region in regions if region["api_host"] == DEFAULT_API_HOST), None)
         if first_default_region:
@@ -1353,7 +1341,7 @@ def get_region_from_host(region_name_or_host: str, regions: List[Region]) -> Opt
     return None
 
 
-async def try_update_config_with_remote(
+def try_update_config_with_remote(
     config: CLIConfig, raise_on_errors: bool = True, only_if_needed: bool = False, auto_persist: bool = True
 ) -> bool:
     response: Dict[str, Any]
@@ -1367,7 +1355,7 @@ async def try_update_config_with_remote(
         return True
 
     try:
-        response = await config.get_client().workspace_info(version="v1")
+        response = config.get_client().workspace_info(version="v1")
     except AuthException:
         if raise_on_errors:
             raise CLIAuthException(FeedbackManager.error_invalid_token_for_host(host=config.get_host()))
@@ -1406,7 +1394,7 @@ def ask_for_admin_token_interactively(ui_host: str, default_token: Optional[str]
     )
 
 
-async def try_authenticate(
+def try_authenticate(
     config: CLIConfig,
     regions: Optional[List[Region]] = None,
     interactive: bool = False,
@@ -1415,7 +1403,7 @@ async def try_authenticate(
     host: Optional[str] = config.get_host()
 
     if not regions and interactive:
-        regions = await get_regions(config)
+        regions = get_regions(config)
 
     selected_region: Optional[Region] = None
     default_password: Optional[str] = None
@@ -1449,18 +1437,18 @@ async def try_authenticate(
     config.set_token(token)
 
     add_telemetry_event("auth_token", token=token)
-    authenticated: bool = await try_update_config_with_remote(config, raise_on_errors=not try_all_regions)
+    authenticated: bool = try_update_config_with_remote(config, raise_on_errors=not try_all_regions)
 
     # No luck? Let's try auth in all other regions
     if not authenticated and try_all_regions and not interactive:
         if not regions:
-            regions = await get_regions(config)
+            regions = get_regions(config)
 
         # Check other regions, ignoring the previously tested region
         for region in [r for r in regions if r is not selected_region]:
             name, host, ui_host = get_region_info(config, region)
             config.set_host(host)
-            authenticated = await try_update_config_with_remote(config, raise_on_errors=False)
+            authenticated = try_update_config_with_remote(config, raise_on_errors=False)
             if authenticated:
                 click.echo(FeedbackManager.success_using_host(name=name, host=get_display_cloud_host(ui_host)))
                 break
@@ -1481,7 +1469,7 @@ async def try_authenticate(
     return True
 
 
-async def wait_job(
+def wait_job(
     tb_client: TinyB,
     job_id: str,
     job_url: str,
@@ -1508,12 +1496,11 @@ async def wait_job(
                 progress_bar.update(progress_bar.length if progress_bar.length else 0)
 
         try:
-            # TODO: Simplify this as it's not needed to use two functions for
-            result = await wait_job_no_ui(tb_client, job_id, progressbar_cb)
+            result = wait_job_no_ui(tb_client, job_id, progressbar_cb)
             if result["status"] != "done":
                 raise CLIException(FeedbackManager.error_while_running_job(error=result["error"]))
             return result
-        except asyncio.TimeoutError:
+        except TimeoutError:
             raise CLIException(FeedbackManager.error_while_running_job(error="Reach timeout, job cancelled"))
         except JobException as e:
             raise CLIException(FeedbackManager.error_while_running_job(error=str(e)))
@@ -1521,23 +1508,23 @@ async def wait_job(
             raise CLIException(FeedbackManager.error_getting_job_info(error=str(e), url=job_url))
 
 
-async def wait_job_no_ui(
+def wait_job_no_ui(
     tb_client: TinyB,
     job_id: str,
     status_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
 ) -> Dict[str, Any]:
     try:
-        result = await asyncio.wait_for(tb_client.wait_for_job(job_id, status_callback=status_callback), None)
+        result = tb_client.wait_for_job(job_id, status_callback=status_callback)
         if result["status"] != "done":
             raise JobException(result.get("error"))
         return result
-    except asyncio.TimeoutError:
-        await tb_client.job_cancel(job_id)
+    except TimeoutError:
+        tb_client.job_cancel(job_id)
         raise
 
 
-async def get_current_main_workspace(config: CLIConfig) -> Optional[Dict[str, Any]]:
-    current_workspace = await config.get_client().user_workspaces_and_branches(version="v1")
+def get_current_main_workspace(config: CLIConfig) -> Optional[Dict[str, Any]]:
+    current_workspace = config.get_client().user_workspaces_and_branches(version="v1")
     return _get_current_main_workspace_common(current_workspace, config.get("id", current_workspace["id"]))
 
 
@@ -1618,13 +1605,13 @@ def is_major_semver(new_version: Version, current_version: Version) -> bool:
     return new_version.major != current_version.major
 
 
-async def print_release_summary(config: CLIConfig, semver: Optional[str], info: bool = False, dry_run=False):
+def print_release_summary(config: CLIConfig, semver: Optional[str], info: bool = False, dry_run=False):
     if not semver:
         click.echo(FeedbackManager.info_release_no_rollback())
         return
     try:
         client = config.get_client()
-        response = await client.release_rm(config["id"], semver, confirmation=config["name"], dry_run=True)
+        response = client.release_rm(config["id"], semver, confirmation=config["name"], dry_run=True)
     except Exception as e:
         raise CLIReleaseException(FeedbackManager.error_exception(error=str(e)))
     else:
@@ -1660,21 +1647,21 @@ async def print_release_summary(config: CLIConfig, semver: Optional[str], info:
             echo_safe_humanfriendly_tables_format_smart_table(rows, column_names=columns)
 
 
-async def get_oldest_rollback(config: CLIConfig, client: TinyB) -> Optional[str]:
-    oldest_rollback_response = await client.release_oldest_rollback(config["id"])
+def get_oldest_rollback(config: CLIConfig, client: TinyB) -> Optional[str]:
+    oldest_rollback_response = client.release_oldest_rollback(config["id"])
     return oldest_rollback_response.get("semver") if oldest_rollback_response else None
 
 
-async def remove_release(
+def remove_release(
     dry_run: bool, config: CLIConfig, semver: Optional[str], client: TinyB, force: bool, show_print=True
 ):
     if semver == OLDEST_ROLLBACK:
-        semver = await get_oldest_rollback(config, client)
+        semver = get_oldest_rollback(config, client)
     if show_print:
-        await print_release_summary(config, semver, info=True, dry_run=True)
+        print_release_summary(config, semver, info=True, dry_run=True)
     if not dry_run:
         if semver:
-            response = await client.release_rm(
+            response = client.release_rm(
                 config["id"], semver, confirmation=config["name"], dry_run=dry_run, force=force
             )
             click.echo(FeedbackManager.success_release_delete(semver=response.get("semver")))
@@ -1682,7 +1669,7 @@ async def remove_release(
             click.echo(FeedbackManager.info_no_release_deleted())
 
 
-async def run_aws_iamrole_connection_flow(
+def run_aws_iamrole_connection_flow(
     client: TinyB,
     service: str,
     environment: str,
@@ -1701,7 +1688,7 @@ async def run_aws_iamrole_connection_flow(
     region = click.prompt("🌐 Region (the region where the bucket is located, e.g. 'us-east-1')", prompt_suffix="\n> ")
     validate_string_connector_param("Region", region)
 
-    access_policy, trust_policy, _ = await get_aws_iamrole_policies(
+    access_policy, trust_policy, _ = get_aws_iamrole_policies(
         client, service=service, policy=policy, bucket=bucket_name, external_id_seed=connection_name
     )
 
@@ -1759,7 +1746,7 @@ async def run_aws_iamrole_connection_flow(
     return role_arn, region, bucket_name
 
 
-async def run_gcp_svc_account_connection_flow(
+def run_gcp_svc_account_connection_flow(
     environment: str,
 ) -> None:
     click.echo(FeedbackManager.prompt_gcs_svc_account_login_gcp())
@@ -1775,7 +1762,7 @@ async def run_gcp_svc_account_connection_flow(
     input()
 
 
-async def production_aws_iamrole_only(
+def production_aws_iamrole_only(
     prod_client: TinyB,
     service: str,
     region: str,
@@ -1784,7 +1771,7 @@ async def production_aws_iamrole_only(
     connection_name: str,
     policy: str,
 ) -> Tuple[str, str, str]:
-    _, trust_policy, external_id = await get_aws_iamrole_policies(
+    _, trust_policy, external_id = get_aws_iamrole_policies(
         prod_client, service=service, policy=policy, bucket=bucket_name, external_id_seed=connection_name
     )
 
@@ -1819,7 +1806,7 @@ async def production_aws_iamrole_only(
     return role_arn, region, external_id
 
 
-async def get_aws_iamrole_policies(
+def get_aws_iamrole_policies(
     client: TinyB,
     service: str,
     policy: str = "write",
@@ -1831,9 +1818,9 @@ async def get_aws_iamrole_policies(
         service = DataConnectorType.AMAZON_S3
     try:
         if policy == "write":
-            access_policy = await client.get_access_write_policy(service, bucket)
+            access_policy = client.get_access_write_policy(service, bucket)
         elif policy == "read":
-            access_policy = await client.get_access_read_policy(service, bucket)
+            access_policy = client.get_access_read_policy(service, bucket)
         else:
             raise Exception(f"Access policy {policy} not supported. Choose from 'read' or 'write'")
         if not len(access_policy) > 0:
@@ -1843,7 +1830,7 @@ async def get_aws_iamrole_policies(
 
     trust_policy: Dict[str, Any] = {}
     try:
-        trust_policy = await client.get_trust_policy(service, external_id_seed)
+        trust_policy = client.get_trust_policy(service, external_id_seed)
         if not len(trust_policy) > 0:
             raise Exception(f"{service.upper()} Integration not supported in this region")
     except Exception as e:
@@ -1932,7 +1919,7 @@ class DataConnectorType(str, Enum):
         return self.value
 
 
-async def create_aws_iamrole_connection(client: TinyB, service: str, connection_name, role_arn, region) -> None:
+def create_aws_iamrole_connection(client: TinyB, service: str, connection_name, role_arn, region) -> None:
     conn_file_name = f"{connection_name}.connection"
     conn_file_path = Path(getcwd(), conn_file_name)
 
@@ -1950,14 +1937,14 @@ async def create_aws_iamrole_connection(client: TinyB, service: str, connection_
 
     click.echo("** Creating connection...")
     try:
-        _ = await client.connection_create(params)
+        _ = client.connection_create(params)
     except Exception as e:
         raise CLIConnectionException(
             FeedbackManager.error_connection_create(connection_name=connection_name, error=str(e))
         )
 
-    async with aiofiles.open(conn_file_path, "w") as f:
-        await f.write(
+    with open(conn_file_path, "w") as f:
+        f.write(
             f"""TYPE {service}
 
 """
@@ -1990,36 +1977,34 @@ def get_ca_pem_content(ca_pem: Optional[str], filename: Optional[str] = None) ->
     return ca_pem_content
 
 
-requests_get = sync_to_async(requests.get, thread_sensitive=False)
-requests_delete = sync_to_async(requests.delete, thread_sensitive=False)
+requests_get = requests.get
+requests_delete = requests.delete
 
 
 def format_data_to_ndjson(data: List[Dict[str, Any]]) -> str:
     return "\n".join([json.dumps(row) for row in data])
 
 
-async def send_batch_events(
-    client: TinyB, datasource_name: str, data: List[Dict[str, Any]], batch_size: int = 10
-) -> None:
+def send_batch_events(client: TinyB, datasource_name: str, data: List[Dict[str, Any]], batch_size: int = 10) -> None:
     rows = len(data)
     time_start = time.time()
     for i in range(0, rows, batch_size):
         batch = data[i : i + batch_size]
         ndjson_data = format_data_to_ndjson(batch)
-        await client.datasource_events(datasource_name, ndjson_data)
+        client.datasource_events(datasource_name, ndjson_data)
     time_end = time.time()
     elapsed_time = time_end - time_start
     cols = len(data[0].keys()) if len(data) > 0 else 0
     click.echo(FeedbackManager.highlight(message=f"» {rows} rows x {cols} cols in {elapsed_time:.1f}s"))
 
 
-async def get_organizations_by_user(config: CLIConfig, user_token: Optional[str] = None) -> List[Dict[str, str]]:
+def get_organizations_by_user(config: CLIConfig, user_token: Optional[str] = None) -> List[Dict[str, str]]:
     """Fetches all organizations by user using the provided user token"""
     organizations = []
 
     try:
         user_client = config.get_client(token=user_token) if user_token else config.get_user_client()
-        user_workspaces = await user_client.user_workspaces_with_organization(version="v1")
+        user_workspaces = user_client.user_workspaces_with_organization(version="v1")
         admin_org_id = user_workspaces.get("organization_id")
         seen_org_ids = set()
 
@@ -2032,7 +2017,7 @@ async def get_organizations_by_user(config: CLIConfig, user_token: Optional[str]
 
         # Case: user is admin of an organization but not a member of any workspace in it
         if admin_org_id and admin_org_id not in seen_org_ids:
-            org = await user_client.organization(admin_org_id)
+            org = user_client.organization(admin_org_id)
             org["id"] = admin_org_id
             org["is_admin"] = True
             organizations.append(org)
@@ -2086,7 +2071,7 @@ def sort_organizations_by_user(organizations: List[Dict[str, Any]], user_email:
     return sorted_organizations
 
 
-async def ask_for_organization_interactively(organizations: List[Organization]) -> Optional[Organization]:
+def ask_for_organization_interactively(organizations: List[Organization]) -> Optional[Organization]:
     rows = [(index + 1, org["name"], org["role"], org["id"]) for index, org in enumerate(organizations)]
 
     echo_safe_humanfriendly_tables_format_smart_table(rows, column_names=["Idx", "Name", "Role", "Id"])
@@ -2107,7 +2092,7 @@ async def ask_for_organization_interactively(organizations: List[Organization])
     return organizations[org_index - 1]
 
 
-async def ask_for_organization_name(config: CLIConfig) -> str:
+def ask_for_organization_name(config: CLIConfig) -> str:
     user_email = config.get_user_email()
     default_organization_name = (
         user_email.split("@")[1].split(".")[0] if user_email else None
@@ -2125,28 +2110,28 @@ async def ask_for_organization_name(config: CLIConfig) -> str:
     )
 
 
-async def create_organization_and_add_workspaces(
+def create_organization_and_add_workspaces(
     config: CLIConfig, organization_name: str, user_token: str
 ) -> Dict[str, Any]:
     client: TinyB = config.get_client(token=user_token)
     try:
-        organization = await client.create_organization(organization_name)
+        organization = client.create_organization(organization_name)
         click.echo(FeedbackManager.success_organization_created(organization_name=organization_name))
     except Exception as e:
         raise CLIWorkspaceException(FeedbackManager.error_organization_creation(error=str(e)))
 
     # Add existing orphan workspaces to the organization - this is only needed for backwards compatibility
-    user_workspaces = await client.user_workspaces_with_organization(version="v1")
+    user_workspaces = client.user_workspaces_with_organization(version="v1")
     workspaces_to_migrate = []
     for workspace in user_workspaces["workspaces"]:
         if workspace.get("organization") is None and workspace.get("role") == "admin":
             workspaces_to_migrate.append(workspace["id"])
-    await client.add_workspaces_to_organization(organization["id"], workspaces_to_migrate)
+    client.add_workspaces_to_organization(organization["id"], workspaces_to_migrate)
 
     return organization
 
 
-async def get_user_token(config: CLIConfig, user_token: Optional[str] = None) -> str:
+def get_user_token(config: CLIConfig, user_token: Optional[str] = None) -> str:
     client = config.get_client()
     host = config.get_host() or CLIConfig.DEFAULTS["host"]
     ui_host = get_display_cloud_host(host)
@@ -2155,7 +2140,7 @@ async def get_user_token(config: CLIConfig, user_token: Optional[str] = None) ->
         user_token = config.get_user_token()
         if user_token:
             try:
-                await check_user_token_with_client(client, user_token)
+                check_user_token_with_client(client, user_token)
             except Exception:
                 user_token = None
                 pass
@@ -2168,12 +2153,12 @@ async def get_user_token(config: CLIConfig, user_token: Optional[str] = None) ->
                 )
             )
 
-    await check_user_token_with_client(client, user_token)
+    check_user_token_with_client(client, user_token)
 
     return user_token
 
 
-async def ask_for_organization(
+def ask_for_organization(
     organizations: Optional[List[Dict[str, Any]]],
     organization_id: Optional[str] = None,
     user_token: Optional[str] = None,
@@ -2190,9 +2175,9 @@ async def ask_for_organization(
         return organization_id, organization_name
 
     if organizations is None or len(organizations) == 0:
-        organization_name = await ask_for_organization_name(config)
-        user_token = await get_user_token(config, user_token)
-        organization = await create_organization_and_add_workspaces(config, organization_name, user_token)
+        organization_name = ask_for_organization_name(config)
+        user_token = get_user_token(config, user_token)
+        organization = create_organization_and_add_workspaces(config, organization_name, user_token)
         organization_id = organization.get("id")
     else:
         if len(organizations) == 1:
@@ -2200,7 +2185,7 @@ async def ask_for_organization(
             organization_id = organizations[0]["id"]
         else:
             sorted_organizations = sort_organizations_by_user(organizations, user_email=user_email)
-            current_organization = await ask_for_organization_interactively(sorted_organizations)
+            current_organization = ask_for_organization_interactively(sorted_organizations)
             if current_organization:
                 organization_id = current_organization.get("id")
                 organization_name = current_organization.get("name")