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

tinybird/tb/client.py

@@ -1,20 +1,18 @@
-import asyncio
 import json
 import logging
 import os
 import ssl
+import time
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Mapping, Optional, Set, Tuple, Union
 from urllib.parse import quote, urlencode
 
-import aiofiles
 import requests
 import requests.adapters
 from requests import Response
 from urllib3 import Retry
 
 from tinybird.ch_utils.constants import COPY_ENABLED_TABLE_FUNCTIONS
-from tinybird.syncasync import sync_to_async
 from tinybird.tb.modules.telemetry import add_telemetry_event
 
 HOST = "https://api.tinybird.co"
@@ -108,7 +106,7 @@ class TinyB:
         self.env = env
         self.staging = staging
 
-    async def _req_raw(
+    def _req_raw(
         self,
         endpoint: str,
         data=None,
@@ -143,25 +141,15 @@ class TinyB:
                     session.mount("http://", requests.adapters.HTTPAdapter(max_retries=retry))
                 if method == "POST":
                     if files:
-                        response = await sync_to_async(session.post, thread_sensitive=False)(
-                            url, files=files, verify=verify_ssl, **kwargs
-                        )
+                        response = session.post(url, files=files, verify=verify_ssl, **kwargs)
                     else:
-                        response = await sync_to_async(session.post, thread_sensitive=False)(
-                            url, data=data, verify=verify_ssl, **kwargs
-                        )
+                        response = session.post(url, data=data, verify=verify_ssl, **kwargs)
                 elif method == "PUT":
-                    response = await sync_to_async(session.put, thread_sensitive=False)(
-                        url, data=data, verify=verify_ssl, **kwargs
-                    )
+                    response = session.put(url, data=data, verify=verify_ssl, **kwargs)
                 elif method == "DELETE":
-                    response = await sync_to_async(session.delete, thread_sensitive=False)(
-                        url, data=data, verify=verify_ssl, **kwargs
-                    )
+                    response = session.delete(url, data=data, verify=verify_ssl, **kwargs)
                 else:
-                    response = await sync_to_async(session.get, thread_sensitive=False)(
-                        url, verify=verify_ssl, **kwargs
-                    )
+                    response = session.get(url, verify=verify_ssl, **kwargs)
         except Exception as e:
             raise e
 
@@ -183,7 +171,7 @@ class TinyB:
 
         return response
 
-    async def _req(
+    def _req(
         self,
         endpoint: str,
         data=None,
@@ -194,7 +182,7 @@ class TinyB:
         **kwargs,
     ):
         token_to_use = use_token if use_token else self.token
-        response = await self._req_raw(endpoint, data, files, method, retries, use_token, **kwargs)
+        response = self._req_raw(endpoint, data, files, method, retries, use_token, **kwargs)
 
         if response.status_code == 403:
             error = parse_error_response(response)
@@ -231,18 +219,18 @@ class TinyB:
 
         return response
 
-    async def tokens(self):
-        response = await self._req("/v0/tokens")
+    def tokens(self):
+        response = self._req("/v0/tokens")
         return response["tokens"]
 
-    async def get_token_by_name(self, name: str):
-        tokens = await self.tokens()
+    def get_token_by_name(self, name: str):
+        tokens = self.tokens()
         for tk in tokens:
             if tk["name"] == name:
                 return tk
         return None
 
-    async def create_token(
+    def create_token(
         self, name: str, scope: List[str], origin_code: Optional[str], origin_resource_name_or_id: Optional[str] = None
     ):
         origin = origin_code or "C"  # == Origins.CUSTOM  if none specified
@@ -256,70 +244,68 @@ class TinyB:
         # TODO: We should support sending multiple scopes in the body of the request
         url = f"/v0/tokens?{urlencode(params)}"
         url = url + "&" + "&".join([f"scope={scope}" for scope in scope])
-        return await self._req(
+        return self._req(
             url,
             method="POST",
             data="",
         )
 
-    async def alter_tokens(self, name: str, scopes: List[str]):
+    def alter_tokens(self, name: str, scopes: List[str]):
         if not scopes:
             return
         scopes_url: str = "&".join([f"scope={scope}" for scope in scopes])
         url = f"/v0/tokens/{name}"
         if len(url + "?" + scopes_url) > TinyB.MAX_GET_LENGTH:
-            return await self._req(url, method="PUT", data=scopes_url)
+            return self._req(url, method="PUT", data=scopes_url)
         else:
             url = url + "?" + scopes_url
-            return await self._req(url, method="PUT", data="")
+            return self._req(url, method="PUT", data="")
 
-    async def datasources(self, branch: Optional[str] = None, used_by: bool = False) -> List[Dict[str, Any]]:
+    def datasources(self, branch: Optional[str] = None, used_by: bool = False) -> List[Dict[str, Any]]:
         params = {}
         if used_by:
             params["attrs"] = "used_by"
-        response = await self._req(f"/v0/datasources?{urlencode(params)}")
+        response = self._req(f"/v0/datasources?{urlencode(params)}")
         ds = response["datasources"]
 
         if branch:
             ds = [x for x in ds if x["name"].startswith(branch)]
         return ds
 
-    async def secrets(self) -> List[Dict[str, Any]]:
-        response = await self._req("/v0/variables")
+    def secrets(self) -> List[Dict[str, Any]]:
+        response = self._req("/v0/variables")
         return response["variables"]
 
-    async def get_secret(self, name: str) -> Optional[Dict[str, Any]]:
-        return await self._req(f"/v0/variables/{name}")
+    def get_secret(self, name: str) -> Optional[Dict[str, Any]]:
+        return self._req(f"/v0/variables/{name}")
 
-    async def create_secret(self, name: str, value: str):
-        response = await self._req("/v0/variables", method="POST", data={"name": name, "value": value})
+    def create_secret(self, name: str, value: str):
+        response = self._req("/v0/variables", method="POST", data={"name": name, "value": value})
         return response
 
-    async def update_secret(self, name: str, value: str):
-        response = await self._req(f"/v0/variables/{name}", method="PUT", data={"value": value})
+    def update_secret(self, name: str, value: str):
+        response = self._req(f"/v0/variables/{name}", method="PUT", data={"value": value})
         return response
 
-    async def delete_secret(self, name: str):
-        response = await self._req(f"/v0/variables/{name}", method="DELETE")
+    def delete_secret(self, name: str):
+        response = self._req(f"/v0/variables/{name}", method="DELETE")
         return response
 
-    async def get_connections(self, service: Optional[str] = None):
+    def get_connections(self, service: Optional[str] = None):
         params = {}
 
         if service:
             params["service"] = service
 
-        response = await self._req(f"/v0/connectors?{urlencode(params)}")
+        response = self._req(f"/v0/connectors?{urlencode(params)}")
         return response["connectors"]
 
-    async def connections(self, connector: Optional[str] = None, skip_bigquery: Optional[bool] = False):
-        response = await self._req("/v0/connectors")
+    def connections(self, connector: Optional[str] = None, skip_bigquery: Optional[bool] = False):
+        response = self._req("/v0/connectors")
         connectors = response["connectors"]
         bigquery_connection = None
         if not skip_bigquery:
-            bigquery_connection = (
-                await self.bigquery_connection() if connector == "bigquery" or connector is None else None
-            )
+            bigquery_connection = self.bigquery_connection() if connector == "bigquery" or connector is None else None
         connectors = [*connectors, bigquery_connection] if bigquery_connection else connectors
         if connector:
             return [
@@ -344,13 +330,13 @@ class TinyB:
             for c in connectors
         ]
 
-    async def bigquery_connection(self):
-        bigquery_resources = await self.list_gcp_resources()
+    def bigquery_connection(self):
+        bigquery_resources = self.list_gcp_resources()
         if len(bigquery_resources) == 0:
             return None
 
-        gcp_account_details: Dict[str, Any] = await self.get_gcp_service_account_details()
-        datasources = await self.datasources()
+        gcp_account_details: Dict[str, Any] = self.get_gcp_service_account_details()
+        datasources = self.datasources()
         bigquery_datasources = [ds["name"] for ds in datasources if ds["type"] == "bigquery"]
         return {
             "id": gcp_account_details["account"].split("@")[0],
@@ -360,13 +346,13 @@ class TinyB:
             "settings": gcp_account_details,
         }
 
-    async def get_datasource(self, ds_name: str, used_by: bool = False) -> Dict[str, Any]:
+    def get_datasource(self, ds_name: str, used_by: bool = False) -> Dict[str, Any]:
         params = {
             "attrs": "used_by" if used_by else "",
         }
-        return await self._req(f"/v0/datasources/{ds_name}?{urlencode(params)}")
+        return self._req(f"/v0/datasources/{ds_name}?{urlencode(params)}")
 
-    async def alter_datasource(
+    def alter_datasource(
         self,
         ds_name: str,
         new_schema: Optional[str] = None,
@@ -384,44 +370,44 @@ class TinyB:
             params.update({"ttl": ttl})
         if indexes:
             params.update({"indexes": indexes})
-        res = await self._req(f"/v0/datasources/{ds_name}/alter", method="POST", data=params)
+        res = self._req(f"/v0/datasources/{ds_name}/alter", method="POST", data=params)
 
         if "Error" in res:
             raise Exception(res["error"])
 
         return res
 
-    async def update_datasource(self, ds_name: str, data: Dict[str, Any]):
-        res = await self._req(f"/v0/datasources/{ds_name}", method="PUT", data=data)
+    def update_datasource(self, ds_name: str, data: Dict[str, Any]):
+        res = self._req(f"/v0/datasources/{ds_name}", method="PUT", data=data)
 
         if "Error" in res:
             raise Exception(res["error"])
 
         return res
 
-    async def pipe_file(self, pipe: str):
-        return await self._req(f"/v1/pipes/{pipe}.pipe")
+    def pipe_file(self, pipe: str):
+        return self._req(f"/v1/pipes/{pipe}.pipe")
 
-    async def connection_file(self, connection: str):
-        return await self._req(f"/v0/connectors/{connection}.connection")
+    def connection_file(self, connection: str):
+        return self._req(f"/v0/connectors/{connection}.connection")
 
-    async def datasource_file(self, datasource: str):
+    def datasource_file(self, datasource: str):
         try:
-            return await self._req(f"/v0/datasources/{datasource}.datasource")
+            return self._req(f"/v0/datasources/{datasource}.datasource")
         except DoesNotExistException:
             raise Exception(f"Data Source {datasource} not found.")
 
-    async def datasource_analyze(self, url):
+    def datasource_analyze(self, url):
         params = {"url": url}
-        return await self._req(f"/v0/analyze?{urlencode(params)}", method="POST", data="")
+        return self._req(f"/v0/analyze?{urlencode(params)}", method="POST", data="")
 
-    async def datasource_analyze_file(self, data):
-        return await self._req("/v0/analyze", method="POST", data=data)
+    def datasource_analyze_file(self, data):
+        return self._req("/v0/analyze", method="POST", data=data)
 
-    async def datasource_create_from_definition(self, parameter_definition: Dict[str, str]):
-        return await self._req("/v0/datasources", method="POST", data=parameter_definition)
+    def datasource_create_from_definition(self, parameter_definition: Dict[str, str]):
+        return self._req("/v0/datasources", method="POST", data=parameter_definition)
 
-    async def datasource_create_from_url(
+    def datasource_create_from_url(
         self,
         table_name: str,
         url: str,
@@ -440,18 +426,18 @@ class TinyB:
                 params[option] = "true"
 
         req_url = f"/v0/datasources?{urlencode(params, safe='')}"
-        res = await self._req(req_url, method="POST", data=b"")
+        res = self._req(req_url, method="POST", data=b"")
 
         if "error" in res:
             raise Exception(res["error"])
 
-        return await self.wait_for_job(res["id"], status_callback, backoff_multiplier=1.5, maximum_backoff_seconds=20)
+        return self.wait_for_job(res["id"], status_callback, backoff_multiplier=1.5, maximum_backoff_seconds=20)
 
-    async def datasource_delete(self, datasource_name: str, force: bool = False, dry_run: bool = False):
+    def datasource_delete(self, datasource_name: str, force: bool = False, dry_run: bool = False):
         params = {"force": "true" if force else "false", "dry_run": "true" if dry_run else "false"}
-        return await self._req(f"/v0/datasources/{datasource_name}?{urlencode(params)}", method="DELETE")
+        return self._req(f"/v0/datasources/{datasource_name}?{urlencode(params)}", method="DELETE")
 
-    async def datasource_append_data(
+    def datasource_append_data(
         self,
         datasource_name: str,
         file: Union[str, Path],
@@ -469,33 +455,27 @@ class TinyB:
             for option in list(replace_options):
                 params[option] = "true"
 
-        async with aiofiles.open(file, "rb") as content:
-            file_content = await content.read()
-            if format == "csv":
-                files = {"csv": ("csv", file_content)}
-            else:
-                files = {"ndjson": ("ndjson", file_content)}
-
-            res = await self._req(
-                f"v0/datasources?{urlencode(params, safe='')}",
-                files=files,
-                method="POST",
-            )
-            if status_callback:
-                status_callback(res)
-
-            return res
+        with open(file, "rb") as content:
+            file_content = content.read()
+        if format == "csv":
+            files = {"csv": ("csv", file_content)}
+        else:
+            files = {"ndjson": ("ndjson", file_content)}
+        res = self._req(f"v0/datasources?{urlencode(params, safe='')}", files=files, method="POST")
+        if status_callback:
+            status_callback(res)
+        return res
 
-    async def datasource_truncate(self, datasource_name: str):
-        return await self._req(f"/v0/datasources/{datasource_name}/truncate", method="POST", data="")
+    def datasource_truncate(self, datasource_name: str):
+        return self._req(f"/v0/datasources/{datasource_name}/truncate", method="POST", data="")
 
-    async def datasource_delete_rows(self, datasource_name: str, delete_condition: str, dry_run: bool = False):
+    def datasource_delete_rows(self, datasource_name: str, delete_condition: str, dry_run: bool = False):
         params = {"delete_condition": delete_condition}
         if dry_run:
             params.update({"dry_run": "true"})
-        return await self._req(f"/v0/datasources/{datasource_name}/delete", method="POST", data=params)
+        return self._req(f"/v0/datasources/{datasource_name}/delete", method="POST", data=params)
 
-    async def datasource_dependencies(
+    def datasource_dependencies(
         self, no_deps: bool, match: str, pipe: str, datasource: str, check_for_partial_replace: bool, recursive: bool
     ):
         params = {
@@ -510,45 +490,45 @@ class TinyB:
         if datasource:
             params["datasource"] = datasource
 
-        return await self._req(f"/v0/dependencies?{urlencode(params)}", timeout=60)
+        return self._req(f"/v0/dependencies?{urlencode(params)}", timeout=60)
 
-    async def datasource_share(self, datasource_id: str, current_workspace_id: str, destination_workspace_id: str):
+    def datasource_share(self, datasource_id: str, current_workspace_id: str, destination_workspace_id: str):
         params = {"origin_workspace_id": current_workspace_id, "destination_workspace_id": destination_workspace_id}
-        return await self._req(f"/v0/datasources/{datasource_id}/share", method="POST", data=params)
+        return self._req(f"/v0/datasources/{datasource_id}/share", method="POST", data=params)
 
-    async def datasource_unshare(self, datasource_id: str, current_workspace_id: str, destination_workspace_id: str):
+    def datasource_unshare(self, datasource_id: str, current_workspace_id: str, destination_workspace_id: str):
         params = {"origin_workspace_id": current_workspace_id, "destination_workspace_id": destination_workspace_id}
-        return await self._req(f"/v0/datasources/{datasource_id}/share", method="DELETE", data=params)
+        return self._req(f"/v0/datasources/{datasource_id}/share", method="DELETE", data=params)
 
-    async def datasource_sync(self, datasource_id: str):
-        return await self._req(f"/v0/datasources/{datasource_id}/scheduling/runs", method="POST", data="")
+    def datasource_sync(self, datasource_id: str):
+        return self._req(f"/v0/datasources/{datasource_id}/scheduling/runs", method="POST", data="")
 
-    async def datasource_scheduling_state(self, datasource_id: str):
-        response = await self._req(f"/v0/datasources/{datasource_id}/scheduling/state", method="GET")
+    def datasource_scheduling_state(self, datasource_id: str):
+        response = self._req(f"/v0/datasources/{datasource_id}/scheduling/state", method="GET")
         return response["state"]
 
-    async def datasource_scheduling_pause(self, datasource_id: str):
-        return await self._req(
+    def datasource_scheduling_pause(self, datasource_id: str):
+        return self._req(
             f"/v0/datasources/{datasource_id}/scheduling/state",
             method="PUT",
             data='{"state": "paused"}',
         )
 
-    async def datasource_scheduling_resume(self, datasource_id: str):
-        return await self._req(
+    def datasource_scheduling_resume(self, datasource_id: str):
+        return self._req(
             f"/v0/datasources/{datasource_id}/scheduling/state",
             method="PUT",
             data='{"state": "running"}',
         )
 
-    async def datasource_exchange(self, datasource_a: str, datasource_b: str):
+    def datasource_exchange(self, datasource_a: str, datasource_b: str):
         payload = {"datasource_a": datasource_a, "datasource_b": datasource_b}
-        return await self._req("/v0/datasources/exchange", method="POST", data=payload)
+        return self._req("/v0/datasources/exchange", method="POST", data=payload)
 
-    async def datasource_events(self, datasource_name: str, data: str):
-        return await self._req(f"/v0/events?name={datasource_name}", method="POST", data=data)
+    def datasource_events(self, datasource_name: str, data: str):
+        return self._req(f"/v0/events?name={datasource_name}", method="POST", data=data)
 
-    async def analyze_pipe_node(
+    def analyze_pipe_node(
         self, pipe_name: str, node: Dict[str, Any], dry_run: str = "false", datasource_name: Optional[str] = None
     ):
         params = {"include_datafile": "true", "dry_run": dry_run, **node.get("params", node)}
@@ -557,10 +537,10 @@ class TinyB:
         node_name = node["params"]["name"] if node.get("params", None) else node["name"]
         if datasource_name:
             params["datasource"] = datasource_name
-        response = await self._req(f"/v0/pipes/{pipe_name}/nodes/{node_name}/analysis?{urlencode(params)}")
+        response = self._req(f"/v0/pipes/{pipe_name}/nodes/{node_name}/analysis?{urlencode(params)}")
         return response
 
-    async def populate_node(
+    def populate_node(
         self,
         pipe_name: str,
         node_name: str,
@@ -573,27 +553,25 @@ class TinyB:
             params.update({"populate_subset": populate_subset})
         if populate_condition:
             params.update({"populate_condition": populate_condition})
-        response = await self._req(
-            f"/v0/pipes/{pipe_name}/nodes/{node_name}/population?{urlencode(params)}", method="POST"
-        )
+        response = self._req(f"/v0/pipes/{pipe_name}/nodes/{node_name}/population?{urlencode(params)}", method="POST")
         return response
 
-    async def pipes(self, branch=None, dependencies: bool = False, node_attrs=None, attrs=None) -> List[Dict[str, Any]]:
+    def pipes(self, branch=None, dependencies: bool = False, node_attrs=None, attrs=None) -> List[Dict[str, Any]]:
         params = {
             "dependencies": "true" if dependencies else "false",
             "attrs": attrs if attrs else "",
             "node_attrs": node_attrs if node_attrs else "",
         }
-        response = await self._req(f"/v0/pipes?{urlencode(params)}")
+        response = self._req(f"/v0/pipes?{urlencode(params)}")
         pipes = response["pipes"]
         if branch:
             pipes = [x for x in pipes if x["name"].startswith(branch)]
         return pipes
 
-    async def pipe(self, pipe: str):
-        return await self._req(f"/v0/pipes/{pipe}")
+    def pipe(self, pipe: str):
+        return self._req(f"/v0/pipes/{pipe}")
 
-    async def pipe_data(
+    def pipe_data(
         self,
         pipe_name_or_uid: str,
         sql: Optional[str] = None,
@@ -607,29 +585,27 @@ class TinyB:
         url = f"/v0/pipes/{pipe_name_or_uid}.{format}"
         query_string = urlencode(params)
         if len(url + "?" + query_string) > TinyB.MAX_GET_LENGTH:
-            return await self._req(f"/v0/pipes/{pipe_name_or_uid}.{format}", method="POST", data=params)
+            return self._req(f"/v0/pipes/{pipe_name_or_uid}.{format}", method="POST", data=params)
         else:
             url = url + "?" + query_string
-            return await self._req(url)
+            return self._req(url)
 
-    async def pipe_create(self, pipe_name: str, sql: str):
-        return await self._req(
-            f"/v0/pipes?name={pipe_name}&sql={quote(sql, safe='')}", method="POST", data=sql.encode()
-        )
+    def pipe_create(self, pipe_name: str, sql: str):
+        return self._req(f"/v0/pipes?name={pipe_name}&sql={quote(sql, safe='')}", method="POST", data=sql.encode())
 
-    async def pipe_delete(self, pipe_name: str):
-        return await self._req(f"/v0/pipes/{pipe_name}", method="DELETE")
+    def pipe_delete(self, pipe_name: str):
+        return self._req(f"/v0/pipes/{pipe_name}", method="DELETE")
 
-    async def pipe_append_node(self, pipe_name_or_uid: str, sql: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_uid}/nodes", method="POST", data=sql.encode())
+    def pipe_append_node(self, pipe_name_or_uid: str, sql: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_uid}/nodes", method="POST", data=sql.encode())
 
-    async def pipe_set_endpoint(self, pipe_name_or_uid: str, published_node_uid: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_uid}/nodes/{published_node_uid}/endpoint", method="POST")
+    def pipe_set_endpoint(self, pipe_name_or_uid: str, published_node_uid: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_uid}/nodes/{published_node_uid}/endpoint", method="POST")
 
-    async def pipe_remove_endpoint(self, pipe_name_or_uid: str, published_node_uid: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_uid}/nodes/{published_node_uid}/endpoint", method="DELETE")
+    def pipe_remove_endpoint(self, pipe_name_or_uid: str, published_node_uid: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_uid}/nodes/{published_node_uid}/endpoint", method="DELETE")
 
-    async def pipe_update_copy(
+    def pipe_update_copy(
         self,
         pipe_name_or_id: str,
         node_id: str,
@@ -645,45 +621,45 @@ class TinyB:
         if mode:
             data["mode"] = mode
 
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/copy", method="PUT", data=data)
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/copy", method="PUT", data=data)
 
-    async def pipe_remove_copy(self, pipe_name_or_id: str, node_id: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/copy", method="DELETE")
+    def pipe_remove_copy(self, pipe_name_or_id: str, node_id: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/copy", method="DELETE")
 
-    async def pipe_run(
+    def pipe_run(
         self, pipe_name_or_id: str, pipe_type: str, params: Optional[Dict[str, str]] = None, mode: Optional[str] = None
     ):
         params = {**params} if params else {}
         if mode:
             params["_mode"] = mode
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/{pipe_type}?{urlencode(params)}", method="POST")
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/{pipe_type}?{urlencode(params)}", method="POST")
 
-    async def pipe_resume_copy(self, pipe_name_or_id: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/copy/resume", method="POST")
+    def pipe_resume_copy(self, pipe_name_or_id: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/copy/resume", method="POST")
 
-    async def pipe_pause_copy(self, pipe_name_or_id: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/copy/pause", method="POST")
+    def pipe_pause_copy(self, pipe_name_or_id: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/copy/pause", method="POST")
 
-    async def pipe_create_sink(self, pipe_name_or_id: str, node_id: str, params: Optional[Dict[str, str]] = None):
+    def pipe_create_sink(self, pipe_name_or_id: str, node_id: str, params: Optional[Dict[str, str]] = None):
         params = {**params} if params else {}
-        return await self._req(
+        return self._req(
             f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/sink?{urlencode(params)}", method="POST", data=""
         )
 
-    async def pipe_remove_sink(self, pipe_name_or_id: str, node_id: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/sink", method="DELETE")
+    def pipe_remove_sink(self, pipe_name_or_id: str, node_id: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/sink", method="DELETE")
 
-    async def pipe_remove_stream(self, pipe_name_or_id: str, node_id: str):
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/stream", method="DELETE")
+    def pipe_remove_stream(self, pipe_name_or_id: str, node_id: str):
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/nodes/{node_id}/stream", method="DELETE")
 
-    async def pipe_run_sink(self, pipe_name_or_id: str, params: Optional[Dict[str, str]] = None):
+    def pipe_run_sink(self, pipe_name_or_id: str, params: Optional[Dict[str, str]] = None):
         params = {**params} if params else {}
-        return await self._req(f"/v0/pipes/{pipe_name_or_id}/sink?{urlencode(params)}", method="POST")
+        return self._req(f"/v0/pipes/{pipe_name_or_id}/sink?{urlencode(params)}", method="POST")
 
-    async def pipe_unlink_materialized(self, pipe_name: str, node_id: str):
-        return await self._req(f"/v0/pipes/{pipe_name}/nodes/{node_id}/materialization", method="DELETE")
+    def pipe_unlink_materialized(self, pipe_name: str, node_id: str):
+        return self._req(f"/v0/pipes/{pipe_name}/nodes/{node_id}/materialization", method="DELETE")
 
-    async def query(self, sql: str, pipeline: Optional[str] = None, playground: Optional[str] = None):
+    def query(self, sql: str, pipeline: Optional[str] = None, playground: Optional[str] = None):
         params = {}
         if pipeline:
             params = {"pipeline": pipeline}
@@ -692,43 +668,43 @@ class TinyB:
         params.update({"release_replacements": "true"})
 
         if len(sql) > TinyB.MAX_GET_LENGTH:
-            return await self._req(f"/v0/sql?{urlencode(params)}", data=sql, method="POST")
+            return self._req(f"/v0/sql?{urlencode(params)}", data=sql, method="POST")
         else:
-            return await self._req(f"/v0/sql?q={quote(sql, safe='')}&{urlencode(params)}")
+            return self._req(f"/v0/sql?q={quote(sql, safe='')}&{urlencode(params)}")
 
-    async def jobs(
+    def jobs(
         self, status: Optional[Tuple[str, ...]] = None, kind: Optional[Tuple[str, ...]] = None
     ) -> List[Dict[str, Any]]:
-        async def fetch_jobs(params: Dict[str, str]) -> List[Dict[str, Any]]:
+        def fetch_jobs(params: Dict[str, str]) -> List[Dict[str, Any]]:
             query_string = urlencode(params) if params else ""
             endpoint = f"/v0/jobs?{query_string}" if query_string else "/v0/jobs"
-            response = await self._req(endpoint)
+            response = self._req(endpoint)
             return response["jobs"]
 
         if not status and not kind:
-            return await fetch_jobs({})
+            return fetch_jobs({})
         result: List[Dict[str, Any]] = []
         if status and kind:
             for s in status:
                 for k in kind:
-                    result.extend(await fetch_jobs({"status": s, "kind": k}))
+                    result.extend(fetch_jobs({"status": s, "kind": k}))
         elif status:
             for s in status:
-                result.extend(await fetch_jobs({"status": s}))
+                result.extend(fetch_jobs({"status": s}))
         elif kind:
             for k in kind:
-                result.extend(await fetch_jobs({"kind": k}))
+                result.extend(fetch_jobs({"kind": k}))
 
         return result
 
-    async def job(self, job_id: str):
-        return await self._req(f"/v0/jobs/{job_id}")
+    def job(self, job_id: str):
+        return self._req(f"/v0/jobs/{job_id}")
 
-    async def job_cancel(self, job_id: str):
-        return await self._req(f"/v0/jobs/{job_id}/cancel", method="POST", data=b"")
+    def job_cancel(self, job_id: str):
+        return self._req(f"/v0/jobs/{job_id}/cancel", method="POST", data=b"")
 
-    async def user_workspaces(self, version: str = "v0"):
-        data = await self._req(f"/{version}/user/workspaces/?with_environments=false")
+    def user_workspaces(self, version: str = "v0"):
+        data = self._req(f"/{version}/user/workspaces/?with_environments=false")
         # TODO: this is repeated in local_common.py but I'm avoiding circular imports
         local_port = int(os.getenv("TB_LOCAL_PORT", 80))
         local_host = f"http://localhost:{local_port}"
@@ -738,24 +714,24 @@ class TinyB:
         local_workspaces = [x for x in data["workspaces"] if not x["name"].startswith("Tinybird_Local_")]
         return {**data, "workspaces": local_workspaces}
 
-    async def user_workspaces_and_branches(self, version: str = "v0"):
-        return await self._req(f"/{version}/user/workspaces/?with_environments=true")
+    def user_workspaces_and_branches(self, version: str = "v0"):
+        return self._req(f"/{version}/user/workspaces/?with_environments=true")
 
-    async def user_workspaces_with_organization(self, version: str = "v0"):
-        return await self._req(
+    def user_workspaces_with_organization(self, version: str = "v0"):
+        return self._req(
             f"/{version}/user/workspaces/?with_environments=false&with_organization=true&with_members_and_owner=false"
         )
 
-    async def user_workspace_branches(self, version: str = "v0"):
-        return await self._req(f"/{version}/user/workspaces/?with_environments=true&only_environments=true")
+    def user_workspace_branches(self, version: str = "v0"):
+        return self._req(f"/{version}/user/workspaces/?with_environments=true&only_environments=true")
 
-    async def branches(self):
-        return await self._req("/v0/environments")
+    def branches(self):
+        return self._req("/v0/environments")
 
-    async def releases(self, workspace_id):
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases")
+    def releases(self, workspace_id):
+        return self._req(f"/v0/workspaces/{workspace_id}/releases")
 
-    async def create_workspace(
+    def create_workspace(
         self,
         name: str,
         assign_to_organization_id: Optional[str] = None,
@@ -764,9 +740,9 @@ class TinyB:
         url = f"/{version}/workspaces?name={name}"
         if assign_to_organization_id:
             url += f"&assign_to_organization_id={assign_to_organization_id}"
-        return await self._req(url, method="POST", data=b"")
+        return self._req(url, method="POST", data=b"")
 
-    async def create_workspace_branch(
+    def create_workspace_branch(
         self,
         branch_name: str,
         last_partition: Optional[bool],
@@ -779,9 +755,9 @@ class TinyB:
         }
         if ignore_datasources:
             params["ignore_datasources"] = ",".join(ignore_datasources)
-        return await self._req(f"/v0/environments?{urlencode(params)}", method="POST", data=b"")
+        return self._req(f"/v0/environments?{urlencode(params)}", method="POST", data=b"")
 
-    async def branch_workspace_data(
+    def branch_workspace_data(
         self,
         workspace_id: str,
         last_partition: bool,
@@ -797,9 +773,9 @@ class TinyB:
         if ignore_datasources:
             params["ignore_datasources"] = ",".join(ignore_datasources)
         url = f"/v0/environments/{workspace_id}/data?{urlencode(params)}"
-        return await self._req(url, method="POST", data=b"")
+        return self._req(url, method="POST", data=b"")
 
-    async def branch_regression_tests(
+    def branch_regression_tests(
         self,
         branch_id: str,
         pipe_name: Optional[str],
@@ -850,9 +826,9 @@ class TinyB:
             url = f"/v0/environments/{branch_id}/regression/main"
         else:
             url = f"/v0/environments/{branch_id}/regression"
-        return await self._req(url, method="POST", data=data, headers={"Content-Type": "application/json"})
+        return self._req(url, method="POST", data=data, headers={"Content-Type": "application/json"})
 
-    async def branch_regression_tests_file(
+    def branch_regression_tests_file(
         self, branch_id: str, regression_commands: List[Dict[str, Any]], run_in_main: Optional[bool] = False
     ):
         data = json.dumps(regression_commands)
@@ -860,72 +836,72 @@ class TinyB:
             url = f"/v0/environments/{branch_id}/regression/main"
         else:
             url = f"/v0/environments/{branch_id}/regression"
-        return await self._req(url, method="POST", data=data, headers={"Content-Type": "application/json"})
+        return self._req(url, method="POST", data=data, headers={"Content-Type": "application/json"})
 
-    async def delete_workspace(self, id: str, hard_delete_confirmation: Optional[str], version: str = "v0"):
+    def delete_workspace(self, id: str, hard_delete_confirmation: Optional[str], version: str = "v0"):
         data = {"confirmation": hard_delete_confirmation}
-        return await self._req(f"/{version}/workspaces/{id}", data, method="DELETE")
+        return self._req(f"/{version}/workspaces/{id}", data, method="DELETE")
 
-    async def delete_branch(self, id: str):
-        return await self._req(f"/v0/environments/{id}", method="DELETE")
+    def delete_branch(self, id: str):
+        return self._req(f"/v0/environments/{id}", method="DELETE")
 
-    async def add_users_to_workspace(self, workspace: Dict[str, Any], users_emails: List[str], role: Optional[str]):
+    def add_users_to_workspace(self, workspace: Dict[str, Any], users_emails: List[str], role: Optional[str]):
         users = ",".join(users_emails)
-        return await self._req(
+        return self._req(
             f"/v0/workspaces/{workspace['id']}/users/",
             method="PUT",
             data={"operation": "add", "users": users, "role": role},
         )
 
-    async def remove_users_from_workspace(self, workspace: Dict[str, Any], users_emails: List[str]):
+    def remove_users_from_workspace(self, workspace: Dict[str, Any], users_emails: List[str]):
         users = ",".join(users_emails)
-        return await self._req(
+        return self._req(
             f"/v0/workspaces/{workspace['id']}/users/", method="PUT", data={"operation": "remove", "users": users}
         )
 
-    async def set_role_for_users_in_workspace(self, workspace: Dict[str, Any], users_emails: List[str], role: str):
+    def set_role_for_users_in_workspace(self, workspace: Dict[str, Any], users_emails: List[str], role: str):
         users = ",".join(users_emails)
-        return await self._req(
+        return self._req(
             f"/v0/workspaces/{workspace['id']}/users/",
             method="PUT",
             data={"operation": "change_role", "users": users, "new_role": role},
         )
 
-    async def workspace(self, workspace_id: str, with_token: bool = False):
+    def workspace(self, workspace_id: str, with_token: bool = False):
         params = {"with_token": "true" if with_token else "false"}
-        return await self._req(f"/v0/workspaces/{workspace_id}?{urlencode(params)}")
+        return self._req(f"/v0/workspaces/{workspace_id}?{urlencode(params)}")
 
-    async def workspace_info(self, version: str = "v0") -> Dict[str, Any]:
-        return await self._req(f"/{version}/workspace")
+    def workspace_info(self, version: str = "v0") -> Dict[str, Any]:
+        return self._req(f"/{version}/workspace")
 
-    async def organization(self, organization_id: str):
-        return await self._req(f"/v0/organizations/{organization_id}")
+    def organization(self, organization_id: str):
+        return self._req(f"/v0/organizations/{organization_id}")
 
-    async def create_organization(
+    def create_organization(
         self,
         name: str,
     ):
         url = f"/v0/organizations?name={name}"
-        return await self._req(url, method="POST", data=b"")
+        return self._req(url, method="POST", data=b"")
 
-    async def add_workspaces_to_organization(self, organization_id: str, workspace_ids: List[str]):
+    def add_workspaces_to_organization(self, organization_id: str, workspace_ids: List[str]):
         if not workspace_ids:
             return
-        return await self._req(
+        return self._req(
             f"/v0/organizations/{organization_id}/workspaces",
             method="PUT",
             data=json.dumps({"workspace_ids": ",".join(workspace_ids)}),
         )
 
-    async def infra_create(self, organization_id: str, name: str, host: str) -> Dict[str, Any]:
+    def infra_create(self, organization_id: str, name: str, host: str) -> Dict[str, Any]:
         params = {
             "organization_id": organization_id,
             "name": name,
             "host": host,
         }
-        return await self._req(f"/v1/infra?{urlencode(params)}", method="POST")
+        return self._req(f"/v1/infra?{urlencode(params)}", method="POST")
 
-    async def infra_update(self, infra_id: str, organization_id: str, name: str, host: str) -> Dict[str, Any]:
+    def infra_update(self, infra_id: str, organization_id: str, name: str, host: str) -> Dict[str, Any]:
         params = {
             "organization_id": organization_id,
         }
@@ -933,16 +909,16 @@ class TinyB:
             params["name"] = name
         if host:
             params["host"] = host
-        return await self._req(f"/v1/infra/{infra_id}?{urlencode(params)}", method="PUT")
+        return self._req(f"/v1/infra/{infra_id}?{urlencode(params)}", method="PUT")
 
-    async def infra_list(self, organization_id: str) -> List[Dict[str, Any]]:
-        data = await self._req(f"/v1/infra?organization_id={organization_id}")
+    def infra_list(self, organization_id: str) -> List[Dict[str, Any]]:
+        data = self._req(f"/v1/infra?organization_id={organization_id}")
         return data.get("infras", [])
 
-    async def infra_delete(self, infra_id: str, organization_id: str) -> Dict[str, Any]:
-        return await self._req(f"/v1/infra/{infra_id}?organization_id={organization_id}", method="DELETE")
+    def infra_delete(self, infra_id: str, organization_id: str) -> Dict[str, Any]:
+        return self._req(f"/v1/infra/{infra_id}?organization_id={organization_id}", method="DELETE")
 
-    async def wait_for_job(
+    def wait_for_job(
         self,
         job_id: str,
         status_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
@@ -954,7 +930,7 @@ class TinyB:
         done: bool = False
         while not done:
             params = {"debug": "blocks,block_log"}
-            res = await self._req(f"/v0/jobs/{job_id}?{urlencode(params)}")
+            res = self._req(f"/v0/jobs/{job_id}?{urlencode(params)}")
 
             if res["status"] == "error":
                 error_message = "There has been an error"
@@ -974,19 +950,19 @@ class TinyB:
 
             if not done:
                 backoff_seconds = min(backoff_seconds * backoff_multiplier, maximum_backoff_seconds)
-                await asyncio.sleep(backoff_seconds)
+                time.sleep(backoff_seconds)
 
         return res
 
-    async def datasource_kafka_connect(self, connection_id, datasource_name, topic, group, auto_offset_reset):
-        return await self._req(
+    def datasource_kafka_connect(self, connection_id, datasource_name, topic, group, auto_offset_reset):
+        return self._req(
             f"/v0/datasources?connector={connection_id}&name={datasource_name}&"
             f"kafka_topic={topic}&kafka_group_id={group}&kafka_auto_offset_reset={auto_offset_reset}",
             method="POST",
             data=b"",
         )
 
-    async def connection_create_kafka(
+    def connection_create_kafka(
         self,
         kafka_bootstrap_servers,
         kafka_key,
@@ -1016,24 +992,24 @@ class TinyB:
             params["kafka_ssl_ca_pem"] = kafka_ssl_ca_pem
         connection_params = {key: value for key, value in params.items() if value is not None}
 
-        return await self._req(
+        return self._req(
             "/v0/connectors",
             method="POST",
             headers={"Content-Type": "application/json"},
             data=json.dumps(connection_params),
         )
 
-    async def kafka_list_topics(self, connection_id: str, timeout=5):
-        resp = await self._req(f"/v0/connectors/{connection_id}/preview?preview_activity=false", timeout=timeout)
+    def kafka_list_topics(self, connection_id: str, timeout=5):
+        resp = self._req(f"/v0/connectors/{connection_id}/preview?preview_activity=false", timeout=timeout)
         return [x["topic"] for x in resp["preview"]]
 
-    async def get_gcp_service_account_details(self) -> Dict[str, Any]:
-        return await self._req("/v0/datasources-bigquery-credentials")
+    def get_gcp_service_account_details(self) -> Dict[str, Any]:
+        return self._req("/v0/datasources-bigquery-credentials")
 
-    async def list_connectors(self, service: Optional[str] = None) -> List[Dict[str, Any]]:
+    def list_connectors(self, service: Optional[str] = None) -> List[Dict[str, Any]]:
         try:
             params: str = f"?service={service}" if service else ""
-            result = await self._req(f"/v0/connections/{params}")
+            result = self._req(f"/v0/connections/{params}")
             if not result:
                 return []
 
@@ -1041,7 +1017,7 @@ class TinyB:
         except Exception:
             return []
 
-    async def get_connector(
+    def get_connector(
         self,
         name_or_id: str,
         service: Optional[str] = None,
@@ -1049,14 +1025,14 @@ class TinyB:
         skip_bigquery: Optional[bool] = False,
     ) -> Optional[Dict[str, Any]]:
         return next(
-            (c for c in await self.connections(connector=service, skip_bigquery=skip_bigquery) if c[key] == name_or_id),
+            (c for c in self.connections(connector=service, skip_bigquery=skip_bigquery) if c[key] == name_or_id),
             None,
         )
 
-    async def get_connector_by_id(self, connector_id: Optional[str] = None):
-        return await self._req(f"/v0/connectors/{connector_id}")
+    def get_connector_by_id(self, connector_id: Optional[str] = None):
+        return self._req(f"/v0/connectors/{connector_id}")
 
-    async def get_snowflake_integration_query(
+    def get_snowflake_integration_query(
         self, role: str, stage: Optional[str], integration: Optional[str]
     ) -> Optional[Dict[str, Any]]:
         try:
@@ -1068,13 +1044,13 @@ class TinyB:
             if integration:
                 params["integration"] = integration
 
-            return await self._req(f"/v0/connectors/snowflake/instructions?{urlencode(params)}")
+            return self._req(f"/v0/connectors/snowflake/instructions?{urlencode(params)}")
         except Exception:
             return None
 
-    async def list_gcp_resources(self) -> List[Dict[str, Any]]:
+    def list_gcp_resources(self) -> List[Dict[str, Any]]:
         try:
-            resources = await self._req("/v0/connections/bigquery")
+            resources = self._req("/v0/connections/bigquery")
             if not resources:
                 return []
 
@@ -1082,7 +1058,7 @@ class TinyB:
         except Exception:
             return []
 
-    async def check_gcp_read_permissions(self) -> bool:
+    def check_gcp_read_permissions(self) -> bool:
         """Returns `True` if our service account (see `TinyB::get_gcp_service_account_details()`)
         has the proper permissions in GCP.
 
@@ -1092,17 +1068,17 @@ class TinyB:
         See https://gitlab.com/tinybird/analytics/-/issues/6485.
         """
         try:
-            items = await self.list_gcp_resources()
+            items = self.list_gcp_resources()
             if not items:
                 return False
             return len(items) > 0
         except Exception:
             return False
 
-    async def connector_delete(self, connection_id):
-        return await self._req(f"/v0/connectors/{connection_id}", method="DELETE")
+    def connector_delete(self, connection_id):
+        return self._req(f"/v0/connectors/{connection_id}", method="DELETE")
 
-    async def connection_create_snowflake(
+    def connection_create_snowflake(
         self,
         account_identifier: str,
         user: str,
@@ -1128,42 +1104,42 @@ class TinyB:
         if stage:
             params["stage"] = stage
 
-        return await self._req(f"/v0/connectors?{urlencode(params)}", method="POST", data="")
+        return self._req(f"/v0/connectors?{urlencode(params)}", method="POST", data="")
 
-    async def validate_snowflake_connection(self, account_identifier: str, user: str, password: str) -> bool:
+    def validate_snowflake_connection(self, account_identifier: str, user: str, password: str) -> bool:
         try:
-            roles = await self.get_snowflake_roles(account_identifier, user, password)
+            roles = self.get_snowflake_roles(account_identifier, user, password)
             if not roles:
                 return False
             return len(roles) > 0
         except Exception:
             return False
 
-    async def validate_preview_connection(self, service: str, params: Dict[str, Any]) -> bool:
+    def validate_preview_connection(self, service: str, params: Dict[str, Any]) -> bool:
         params = {"service": service, "dry_run": "true", **params}
         bucket_list = None
         try:
-            bucket_list = await self._req(f"/v0/connectors?{urlencode(params)}", method="POST", data="")
+            bucket_list = self._req(f"/v0/connectors?{urlencode(params)}", method="POST", data="")
             if not bucket_list:
                 return False
             return len(bucket_list) > 0
         except Exception:
             return False
 
-    async def preview_bucket(self, connector: str, bucket_uri: str):
+    def preview_bucket(self, connector: str, bucket_uri: str):
         params = {"bucket_uri": bucket_uri, "service": "s3", "summary": "true"}
-        return await self._req(f"/v0/connectors/{connector}/preview?{urlencode(params)}", method="GET")
+        return self._req(f"/v0/connectors/{connector}/preview?{urlencode(params)}", method="GET")
 
-    async def connection_create(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._req(f"/v0/connectors?{urlencode(params)}", method="POST", data="")
+    def connection_create(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        return self._req(f"/v0/connectors?{urlencode(params)}", method="POST", data="")
 
-    async def get_snowflake_roles(self, account_identifier: str, user: str, password: str) -> Optional[List[str]]:
+    def get_snowflake_roles(self, account_identifier: str, user: str, password: str) -> Optional[List[str]]:
         params = {"account": account_identifier, "username": user, "password": password}
 
-        response = await self._req(f"/v0/connectors/snowflake/roles?{urlencode(params)}", method="POST", data="")
+        response = self._req(f"/v0/connectors/snowflake/roles?{urlencode(params)}", method="POST", data="")
         return response["roles"]
 
-    async def get_snowflake_warehouses(
+    def get_snowflake_warehouses(
         self, account_identifier: str, user: str, password: str, role: str
     ) -> Optional[List[Dict[str, Any]]]:
         params = {
@@ -1173,48 +1149,48 @@ class TinyB:
             "role": role,
         }
 
-        response = await self._req(f"/v0/connectors/snowflake/warehouses?{urlencode(params)}", method="POST", data="")
+        response = self._req(f"/v0/connectors/snowflake/warehouses?{urlencode(params)}", method="POST", data="")
         return response["warehouses"]
 
-    async def check_aws_credentials(self) -> bool:
+    def check_aws_credentials(self) -> bool:
         try:
-            await self._req("/v0/integrations/s3/settings")
+            self._req("/v0/integrations/s3/settings")
             return True
         except Exception:
             return False
 
-    async def get_trust_policy(self, service: str, external_id_seed: Optional[str] = None) -> Dict[str, Any]:
+    def get_trust_policy(self, service: str, external_id_seed: Optional[str] = None) -> Dict[str, Any]:
         params = {}
         if external_id_seed:
             params["external_id_seed"] = external_id_seed
-        return await self._req(f"/v0/integrations/{service}/policies/trust-policy?{urlencode(params)}")
+        return self._req(f"/v0/integrations/{service}/policies/trust-policy?{urlencode(params)}")
 
-    async def get_access_write_policy(self, service: str, bucket: Optional[str] = None) -> Dict[str, Any]:
+    def get_access_write_policy(self, service: str, bucket: Optional[str] = None) -> Dict[str, Any]:
         params = {}
         if bucket:
             params["bucket"] = bucket
-        return await self._req(f"/v0/integrations/{service}/policies/write-access-policy?{urlencode(params)}")
+        return self._req(f"/v0/integrations/{service}/policies/write-access-policy?{urlencode(params)}")
 
-    async def get_access_read_policy(self, service: str, bucket: Optional[str] = None) -> Dict[str, Any]:
+    def get_access_read_policy(self, service: str, bucket: Optional[str] = None) -> Dict[str, Any]:
         params = {}
         if bucket:
             params["bucket"] = bucket
-        return await self._req(f"/v0/integrations/{service}/policies/read-access-policy?{urlencode(params)}")
+        return self._req(f"/v0/integrations/{service}/policies/read-access-policy?{urlencode(params)}")
 
-    async def sql_get_format(self, sql: str, with_clickhouse_format: bool = False) -> str:
+    def sql_get_format(self, sql: str, with_clickhouse_format: bool = False) -> str:
         try:
             if with_clickhouse_format:
                 from tinybird.sql_toolset import format_sql
 
                 return format_sql(sql)
             else:
-                return await self._sql_get_format_remote(sql, with_clickhouse_format)
+                return self._sql_get_format_remote(sql, with_clickhouse_format)
         except ModuleNotFoundError:
-            return await self._sql_get_format_remote(sql, with_clickhouse_format)
+            return self._sql_get_format_remote(sql, with_clickhouse_format)
 
-    async def _sql_get_format_remote(self, sql: str, with_clickhouse_format: bool = False) -> str:
+    def _sql_get_format_remote(self, sql: str, with_clickhouse_format: bool = False) -> str:
         params = {"with_clickhouse_format": "true" if with_clickhouse_format else "false"}
-        result = await self._req(f"/v0/sql_format?q={quote(sql, safe='')}&{urlencode(params)}")
+        result = self._req(f"/v0/sql_format?q={quote(sql, safe='')}&{urlencode(params)}")
         return result["q"]
 
     @staticmethod
@@ -1226,7 +1202,7 @@ class TinyB:
         )
         return [t[1] if t[0] == "" else f"{t[0]}.{t[1]}" for t in tables]
 
-    async def _sql_get_used_tables_remote(
+    def _sql_get_used_tables_remote(
         self, sql: str, raising: bool = False, is_copy: Optional[bool] = False
     ) -> List[str]:
         params = {
@@ -1235,15 +1211,15 @@ class TinyB:
             "table_functions": "false",
             "is_copy": "true" if is_copy else "false",
         }
-        result = await self._req("/v0/sql_tables", data=params, method="POST")
+        result = self._req("/v0/sql_tables", data=params, method="POST")
         return [t[1] if t[0] == "" else f"{t[0]}.{t[1]}" for t in result["tables"]]
 
     # Get used tables from a query. Does not include table functions
-    async def sql_get_used_tables(self, sql: str, raising: bool = False, is_copy: Optional[bool] = False) -> List[str]:
+    def sql_get_used_tables(self, sql: str, raising: bool = False, is_copy: Optional[bool] = False) -> List[str]:
         try:
             return self._sql_get_used_tables_local(sql, raising, is_copy)
         except ModuleNotFoundError:
-            return await self._sql_get_used_tables_remote(sql, raising, is_copy)
+            return self._sql_get_used_tables_remote(sql, raising, is_copy)
 
     @staticmethod
     def _replace_tables_local(q: str, replacements):
@@ -1251,60 +1227,58 @@ class TinyB:
 
         return replace_tables(q, replacements_to_tuples(replacements))
 
-    async def _replace_tables_remote(self, q: str, replacements):
+    def _replace_tables_remote(self, q: str, replacements):
         params = {
             "q": q,
             "replacements": json.dumps({k[1] if isinstance(k, tuple) else k: v for k, v in replacements.items()}),
         }
-        result = await self._req("/v0/sql_replace", data=params, method="POST")
+        result = self._req("/v0/sql_replace", data=params, method="POST")
         return result["query"]
 
-    async def replace_tables(self, q: str, replacements):
+    def replace_tables(self, q: str, replacements):
         try:
             return self._replace_tables_local(q, replacements)
         except ModuleNotFoundError:
-            return await self._replace_tables_remote(q, replacements)
+            return self._replace_tables_remote(q, replacements)
 
-    async def get_connection(self, **kwargs):
-        result = await self._req("/v0/connectors")
+    def get_connection(self, **kwargs):
+        result = self._req("/v0/connectors")
         return next((connector for connector in result["connectors"] if connector_equals(connector, kwargs)), None)
 
-    async def regions(self):
-        regions = await self._req("/v0/regions")
+    def regions(self):
+        regions = self._req("/v0/regions")
         return regions
 
-    async def datasource_query_copy(self, datasource_name: str, sql_query: str):
+    def datasource_query_copy(self, datasource_name: str, sql_query: str):
         params = {"copy_to": datasource_name}
-        return await self._req(f"/v0/sql_copy?{urlencode(params)}", data=sql_query, method="POST")
+        return self._req(f"/v0/sql_copy?{urlencode(params)}", data=sql_query, method="POST")
 
-    async def workspace_commit_update(self, workspace_id: str, commit: str):
-        return await self._req(
-            f"/v0/workspaces/{workspace_id}/releases/?commit={commit}&force=true", method="POST", data=""
-        )
+    def workspace_commit_update(self, workspace_id: str, commit: str):
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/?commit={commit}&force=true", method="POST", data="")
 
-    async def update_release_semver(self, workspace_id: str, semver: str, new_semver: str):
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?new_semver={new_semver}", method="PUT")
+    def update_release_semver(self, workspace_id: str, semver: str, new_semver: str):
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?new_semver={new_semver}", method="PUT")
 
-    async def release_new(self, workspace_id: str, semver: str, commit: str):
+    def release_new(self, workspace_id: str, semver: str, commit: str):
         params = {
             "commit": commit,
             "semver": semver,
         }
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/?{urlencode(params)}", method="POST", data="")
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/?{urlencode(params)}", method="POST", data="")
 
-    async def release_failed(self, workspace_id: str, semver: str):
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=failed", method="PUT")
+    def release_failed(self, workspace_id: str, semver: str):
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=failed", method="PUT")
 
-    async def release_preview(self, workspace_id: str, semver: str):
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=preview", method="PUT")
+    def release_preview(self, workspace_id: str, semver: str):
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=preview", method="PUT")
 
-    async def release_promote(self, workspace_id: str, semver: str):
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=live", method="PUT")
+    def release_promote(self, workspace_id: str, semver: str):
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=live", method="PUT")
 
-    async def release_rollback(self, workspace_id: str, semver: str):
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=rollback", method="PUT")
+    def release_rollback(self, workspace_id: str, semver: str):
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?status=rollback", method="PUT")
 
-    async def release_rm(
+    def release_rm(
         self,
         workspace_id: str,
         semver: str,
@@ -1315,29 +1289,29 @@ class TinyB:
         params = {"force": "true" if force else "false", "dry_run": "true" if dry_run else "false"}
         if confirmation:
             params["confirmation"] = confirmation
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?{urlencode(params)}", method="DELETE")
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/{semver}?{urlencode(params)}", method="DELETE")
 
-    async def release_oldest_rollback(
+    def release_oldest_rollback(
         self,
         workspace_id: str,
     ):
-        return await self._req(f"/v0/workspaces/{workspace_id}/releases/oldest-rollback", method="GET")
+        return self._req(f"/v0/workspaces/{workspace_id}/releases/oldest-rollback", method="GET")
 
-    async def token_list(self, match: Optional[str] = None):
-        tokens = await self.tokens()
+    def token_list(self, match: Optional[str] = None):
+        tokens = self.tokens()
         return [token for token in tokens if (not match or token["name"].find(match) != -1) and "token" in token]
 
-    async def token_delete(self, token_id: str):
-        return await self._req(f"/v0/tokens/{token_id}", method="DELETE")
+    def token_delete(self, token_id: str):
+        return self._req(f"/v0/tokens/{token_id}", method="DELETE")
 
-    async def token_refresh(self, token_id: str):
-        return await self._req(f"/v0/tokens/{token_id}/refresh", method="POST", data="")
+    def token_refresh(self, token_id: str):
+        return self._req(f"/v0/tokens/{token_id}/refresh", method="POST", data="")
 
-    async def token_get(self, token_id: str):
-        return await self._req(f"/v0/tokens/{token_id}", method="GET")
+    def token_get(self, token_id: str):
+        return self._req(f"/v0/tokens/{token_id}", method="GET")
 
-    async def token_scopes(self, token_id: str):
-        token = await self.token_get(token_id)
+    def token_scopes(self, token_id: str):
+        token = self.token_get(token_id)
         return token["scopes"]
 
     def _token_to_params(self, token: Dict[str, Any]) -> str:
@@ -1362,31 +1336,31 @@ class TinyB:
                     params += f"&scope={scope}"
         return params
 
-    async def token_create(self, token: Dict[str, Any]):
+    def token_create(self, token: Dict[str, Any]):
         params = self._token_to_params(token)
-        return await self._req(f"/v0/tokens?{params}", method="POST", data="")
+        return self._req(f"/v0/tokens?{params}", method="POST", data="")
 
-    async def create_jwt_token(self, name: str, expiration_time: int, scopes: List[Dict[str, Any]]):
+    def create_jwt_token(self, name: str, expiration_time: int, scopes: List[Dict[str, Any]]):
         url_params = {"name": name, "expiration_time": expiration_time}
         body = json.dumps({"scopes": scopes})
-        return await self._req(f"/v0/tokens?{urlencode(url_params)}", method="POST", data=body)
+        return self._req(f"/v0/tokens?{urlencode(url_params)}", method="POST", data=body)
 
-    async def token_update(self, token: Dict[str, Any]):
+    def token_update(self, token: Dict[str, Any]):
         name = token["name"]
         params = self._token_to_params(token)
-        return await self._req(f"/v0/tokens/{name}?{params}", method="PUT", data="")
+        return self._req(f"/v0/tokens/{name}?{params}", method="PUT", data="")
 
-    async def token_file(self, token_id: str):
-        return await self._req(f"/v0/tokens/{token_id}.token")
+    def token_file(self, token_id: str):
+        return self._req(f"/v0/tokens/{token_id}.token")
 
-    async def check_auth_login(self) -> Dict[str, Any]:
-        return await self._req("/v0/auth")
+    def check_auth_login(self) -> Dict[str, Any]:
+        return self._req("/v0/auth")
 
-    async def get_all_tags(self) -> Dict[str, Any]:
-        return await self._req("/v0/tags")
+    def get_all_tags(self) -> Dict[str, Any]:
+        return self._req("/v0/tags")
 
-    async def create_tag_with_resource(self, name: str, resource_id: str, resource_name: str, resource_type: str):
-        return await self._req(
+    def create_tag_with_resource(self, name: str, resource_id: str, resource_name: str, resource_type: str):
+        return self._req(
             "/v0/tags",
             method="POST",
             headers={"Content-Type": "application/json"},
@@ -1398,16 +1372,16 @@ class TinyB:
             ),
         )
 
-    async def create_tag(self, name: str):
-        return await self._req(
+    def create_tag(self, name: str):
+        return self._req(
             "/v0/tags",
             method="POST",
             headers={"Content-Type": "application/json"},
             data=json.dumps({"name": name}),
         )
 
-    async def update_tag(self, name: str, resources: List[Dict[str, Any]]):
-        await self._req(
+    def update_tag(self, name: str, resources: List[Dict[str, Any]]):
+        self._req(
             f"/v0/tags/{name}",
             method="PUT",
             headers={"Content-Type": "application/json"},
@@ -1418,5 +1392,5 @@ class TinyB:
             ),
         )
 
-    async def delete_tag(self, name: str):
-        await self._req(f"/v0/tags/{name}", method="DELETE")
+    def delete_tag(self, name: str):
+        self._req(f"/v0/tags/{name}", method="DELETE")