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

tinybird/tb/modules/datafile/build.py

@@ -45,7 +45,7 @@ from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.project import Project
 
 
-async def folder_build(
+def folder_build(
     project: Project,
     tb_client: TinyB,
     filenames: Optional[List[str]] = None,
@@ -67,8 +67,8 @@ async def folder_build(
     fork = False
     release_created = False
     folder = str(project.path)
-    datasources: List[Dict[str, Any]] = await tb_client.datasources()
-    pipes: List[Dict[str, Any]] = await tb_client.pipes(dependencies=True)
+    datasources: List[Dict[str, Any]] = tb_client.datasources()
+    pipes: List[Dict[str, Any]] = tb_client.pipes(dependencies=True)
 
     existing_resources: List[str] = [x["name"] for x in datasources] + [x["name"] for x in pipes]
     remote_resource_names = [get_remote_resource_name_without_version(x) for x in existing_resources]
@@ -78,7 +78,7 @@ async def folder_build(
 
     # build graph to get new versions for all the files involved in the query
     # dependencies need to be processed always to get the versions
-    dependencies_graph = await build_graph(
+    dependencies_graph = build_graph(
         filenames,
         tb_client,
         dir_path=folder,
@@ -114,7 +114,7 @@ async def folder_build(
             return True
         return False
 
-    async def push(
+    def push(
         name: str,
         to_run: Dict[str, Dict[str, Any]],
         dry_run: bool,
@@ -136,7 +136,7 @@ async def folder_build(
                             )
                         )
                     else:
-                        if await name_matches_existing_resource(resource, name, tb_client):
+                        if name_matches_existing_resource(resource, name, tb_client):
                             if resource == "pipes":
                                 click.echo(FeedbackManager.error_pipe_cannot_be_pushed(name=name))
                             else:
@@ -156,7 +156,7 @@ async def folder_build(
                     extension = "pipe" if resource == "pipes" else "datasource"
                     click.echo(FeedbackManager.info_building_resource(name=f"{name}.{extension}", version=""))
                 else:
-                    if await name_matches_existing_resource(resource, name, tb_client):
+                    if name_matches_existing_resource(resource, name, tb_client):
                         if resource == "pipes":
                             click.echo(FeedbackManager.warning_pipe_cannot_be_pushed(name=name))
                         else:
@@ -164,7 +164,7 @@ async def folder_build(
                     else:
                         click.echo(FeedbackManager.warning_dry_name_already_exists(name=name))
 
-    async def push_files(
+    def push_files(
         dependency_graph: GraphDependencies,
         dry_run: bool = False,
     ):
@@ -205,7 +205,7 @@ async def folder_build(
                     error_msg = FeedbackManager.error_connector_require_post_release(connector=connector)
                     raise click.ClickException(error_msg)
 
-                await push(
+                push(
                     name,
                     resources_to_run_fork_downstream,
                     dry_run,
@@ -240,7 +240,7 @@ async def folder_build(
                 if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
                     continue
 
-                await push(
+                push(
                     name,
                     resources_to_run_fork_downstream,
                     dry_run,
@@ -258,7 +258,7 @@ async def folder_build(
                 if name in processed or is_materialized(resources_to_run_fork_downstream.get(name)):
                     continue
 
-                await push(
+                push(
                     name,
                     resources_to_run_fork_downstream,
                     dry_run,
@@ -276,7 +276,7 @@ async def folder_build(
                 if name in processed or not is_materialized(resources_to_run_fork_downstream.get(name)):
                     continue
 
-                await push(
+                push(
                     name,
                     resources_to_run_fork_downstream,
                     dry_run,
@@ -285,7 +285,7 @@ async def folder_build(
                 )
                 processed.add(name)
 
-    await push_files(dependencies_graph, dry_run)
+    push_files(dependencies_graph, dry_run)
 
     if not dry_run and not run_tests and verbose:
         click.echo(FeedbackManager.info_not_pushing_fixtures())
@@ -293,13 +293,13 @@ async def folder_build(
     return dependencies_graph.to_run
 
 
-async def name_matches_existing_resource(resource: str, name: str, tb_client: TinyB):
+def name_matches_existing_resource(resource: str, name: str, tb_client: TinyB):
     if resource == "datasources":
-        current_pipes: List[Dict[str, Any]] = await tb_client.pipes()
+        current_pipes: List[Dict[str, Any]] = tb_client.pipes()
         if name in [x["name"] for x in current_pipes]:
             return True
     else:
-        current_datasources: List[Dict[str, Any]] = await tb_client.datasources()
+        current_datasources: List[Dict[str, Any]] = tb_client.datasources()
         if name in [x["name"] for x in current_datasources]:
             return True
     return False
@@ -479,7 +479,7 @@ class GraphDependencies:
     all_resources: Dict[str, Dict[str, Any]]
 
 
-async def process(
+def process(
     filename: str,
     tb_client: TinyB,
     deps: List[str],
@@ -500,7 +500,7 @@ async def process(
     embedded_datasources = {} if embedded_datasources is None else embedded_datasources
 
     try:
-        res = await process_file(
+        res = process_file(
             filename,
             tb_client,
             skip_connectors=skip_connectors,
@@ -588,7 +588,7 @@ async def process(
     return os.path.basename(name), warnings
 
 
-async def get_processed(
+def get_processed(
     filenames: Iterable[str],
     changed: Optional[Dict[str, Any]] = None,
     verbose: bool = False,
@@ -619,7 +619,7 @@ async def get_processed(
             if resource in changed and (not changed[resource] or changed[resource] in ["shared", "remote"]):
                 continue
         if os.path.isdir(filename):
-            await get_processed(
+            get_processed(
                 filenames=get_project_filenames(filename),
                 changed=changed,
                 verbose=verbose,
@@ -646,7 +646,7 @@ async def get_processed(
             if tb_client is None:
                 raise ValueError("tb_client cannot be None")
 
-            name, warnings = await process(
+            name, warnings = process(
                 filename=filename,
                 tb_client=tb_client,
                 deps=deps_list,
@@ -676,7 +676,7 @@ async def get_processed(
                     )
 
 
-async def build_graph(
+def build_graph(
     filenames: Iterable[str],
     tb_client: TinyB,
     dir_path: Optional[str] = None,
@@ -711,7 +711,7 @@ async def build_graph(
     # When using fork-downstream or --only-changes, we need to generate all the graph of all the resources and their dependencies
     # This way we can add more resources into the to_run dictionary if needed.
     if process_dependencies and only_changes:
-        all_dependencies_graph = await build_graph(
+        all_dependencies_graph = build_graph(
             get_project_filenames(dir_path),
             tb_client,
             dir_path=dir_path,
@@ -729,7 +729,7 @@ async def build_graph(
 
     processed: Set[str] = set()
 
-    await get_processed(
+    get_processed(
         filenames=filenames,
         changed=changed,
         verbose=verbose,
@@ -781,7 +781,7 @@ async def build_graph(
                                 click.echo(FeedbackManager.info_skipping_resource(resource=processed_filename))
                                 continue
                             click.echo(FeedbackManager.info_processing_file(filename=processed_filename))
-                        await process(
+                        process(
                             filename=str(f),
                             tb_client=tb_client,
                             deps=deps,
@@ -800,7 +800,7 @@ async def build_graph(
     return GraphDependencies(dep_map, to_run, all_dep_map, all_resources)
 
 
-async def process_file(
+def process_file(
     filename: str,
     tb_client: TinyB,
     skip_connectors: bool = False,
@@ -821,7 +821,7 @@ async def process_file(
                 params[f"engine_{k}"] = v
         return params
 
-    async def get_kafka_params(node: Dict[str, Any]):
+    def get_kafka_params(node: Dict[str, Any]):
         params = {key: value for key, value in node.items() if key.startswith("kafka")}
 
         if not skip_connectors:
@@ -837,7 +837,7 @@ async def process_file(
                     "kafka_sasl_mechanism": params.get("kafka_sasl_mechanism", None),
                 }
 
-                connector = await tb_client.get_connection(**connector_params)
+                connector = tb_client.get_connection(**connector_params)
                 if not connector:
                     click.echo(
                         FeedbackManager.info_creating_kafka_connection(connection_name=params["kafka_connection_name"])
@@ -851,7 +851,7 @@ async def process_file(
                     if not all(required_params):
                         raise click.ClickException(FeedbackManager.error_unknown_kafka_connection(datasource=name))
 
-                    connector = await tb_client.connection_create_kafka(**connector_params)
+                    connector = tb_client.connection_create_kafka(**connector_params)
             except Exception as e:
                 raise click.ClickException(
                     FeedbackManager.error_connection_create(
@@ -870,7 +870,7 @@ async def process_file(
 
         return params
 
-    async def get_import_params(datasource: Dict[str, Any], node: Dict[str, Any]) -> Dict[str, Any]:
+    def get_import_params(datasource: Dict[str, Any], node: Dict[str, Any]) -> Dict[str, Any]:
         params: Dict[str, Any] = {key: value for key, value in node.items() if key.startswith("import_")}
 
         if len(params) == 0 or skip_connectors:
@@ -879,7 +879,7 @@ async def process_file(
         service: Optional[str] = node.get("import_service", None)
 
         if service and service.lower() == "bigquery":
-            if not await tb_client.check_gcp_read_permissions():
+            if not tb_client.check_gcp_read_permissions():
                 raise click.ClickException(FeedbackManager.error_unknown_bq_connection(datasource=datasource["name"]))
 
             # Bigquery doesn't have a datalink, so we can stop here
@@ -895,7 +895,7 @@ async def process_file(
         if not connector_id:
             assert isinstance(connector_name, str)
 
-            connector: Optional[Dict[str, Any]] = await tb_client.get_connector(connector_name, service)
+            connector: Optional[Dict[str, Any]] = tb_client.get_connector(connector_name, service)
 
             if not connector:
                 raise Exception(
@@ -952,13 +952,13 @@ async def process_file(
             if x["default_value"] and x["default_value"].lower().startswith("materialized"):
                 # turn expression to a select query to sql_get_used_tables can get the used tables
                 q = "select " + x["default_value"][len("materialized") :]
-                tables = await tb_client.sql_get_used_tables(q)
+                tables = tb_client.sql_get_used_tables(q)
                 # materialized columns expressions could have joins so we need to add them as a dep
                 deps += tables
                 # generate replacements and replace the query
                 replacements = {t: t for t in tables}
 
-                replaced_results = await tb_client.replace_tables(q, replacements)
+                replaced_results = tb_client.replace_tables(q, replacements)
                 x["default_value"] = replaced_results.replace("SELECT", "materialized", 1)
             if x.get("jsonpath", None):
                 _format = "ndjson"
@@ -996,7 +996,7 @@ async def process_file(
         if "import_service" in node or "import_connection_name" in node:
             VALID_SERVICES: Tuple[str, ...] = ("bigquery", "snowflake", "s3", "s3_iamrole", "gcs", "dynamodb")
 
-            import_params = await get_import_params(params, node)
+            import_params = get_import_params(params, node)
 
             service = import_params.get("import_service", None)
             if service and service not in VALID_SERVICES:
@@ -1022,7 +1022,7 @@ async def process_file(
                     period: int = DEFAULT_CRON_PERIOD
 
                     if current_ws is not None:
-                        workspaces = (await tb_client.user_workspaces(version="v1")).get("workspaces", [])
+                        workspaces = (tb_client.user_workspaces(version="v1")).get("workspaces", [])
                         workspace_rate_limits: Dict[str, Dict[str, int]] = next(
                             (w.get("rate_limits", {}) for w in workspaces if w["id"] == current_ws["id"]), {}
                         )
@@ -1074,7 +1074,7 @@ async def process_file(
                     params[replacement] = value
 
         if "kafka_connection_name" in node:
-            kafka_params = await get_kafka_params(node)
+            kafka_params = get_kafka_params(node)
             params.update(kafka_params)
             del params["format"]
 
@@ -1139,7 +1139,7 @@ async def process_file(
                 sql_rendered = sql
 
             try:
-                dependencies = await tb_client.sql_get_used_tables(sql_rendered, raising=True, is_copy=is_copy)
+                dependencies = tb_client.sql_get_used_tables(sql_rendered, raising=True, is_copy=is_copy)
                 deps += [t for t in dependencies if t not in [n["name"] for n in doc.nodes]]
 
             except Exception as e:
@@ -1166,7 +1166,7 @@ async def process_file(
 
             replacements = {x: x for x in deps if x not in [n["name"] for n in doc.nodes]}
 
-            # FIXME: Ideally we should use await tb_client.replace_tables(sql, replacements)
+            # FIXME: Ideally we should use tb_client.replace_tables(sql, replacements)
             for old, new in replacements.items():
                 sql = re.sub("([\t \\n']+|^)" + old + "([\t \\n'\\)]+|$)", "\\1" + new + "\\2", sql)
 

tinybird/tb/modules/datafile/build_common.py

@@ -6,7 +6,7 @@ from tinybird.tb.client import DoesNotExistException, TinyB
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
-async def update_tags(resource_id: str, resource_name: str, resource_type: str, tags: List[str], tb_client: TinyB):
+def update_tags(resource_id: str, resource_name: str, resource_type: str, tags: List[str], tb_client: TinyB):
     def get_tags_for_resource(all_tags: dict, resource_id: str, resource_name: str) -> List[str]:
         tag_names = []
 
@@ -30,7 +30,7 @@ async def update_tags(resource_id: str, resource_name: str, resource_type: str,
         return tags_to_add, tags_to_remove
 
     try:
-        all_tags = await tb_client.get_all_tags()
+        all_tags = tb_client.get_all_tags()
     except Exception as e:
         raise Exception(FeedbackManager.error_getting_tags(error=str(e)))
 
@@ -47,7 +47,7 @@ async def update_tags(resource_id: str, resource_name: str, resource_type: str,
         if not tag:
             # Create new tag
             try:
-                await tb_client.create_tag_with_resource(
+                tb_client.create_tag_with_resource(
                     name=tag_name,
                     resource_id=resource_id,
                     resource_name=resource_name,
@@ -60,7 +60,7 @@ async def update_tags(resource_id: str, resource_name: str, resource_type: str,
             resources = tag.get("resources", [])
             resources.append({"id": resource_id, "name": resource_name, "type": resource_type})
             try:
-                await tb_client.update_tag(tag.get("name", tag_name), resources)
+                tb_client.update_tag(tag.get("name", tag_name), resources)
             except Exception as e:
                 raise Exception(FeedbackManager.error_updating_tag(error=str(e)))
 
@@ -72,12 +72,12 @@ async def update_tags(resource_id: str, resource_name: str, resource_type: str,
             resources = tag.get("resources", [])
             resources = [resource for resource in resources if resource.get("name") != resource_name]
             try:
-                await tb_client.update_tag(tag.get("name", tag_name), resources)
+                tb_client.update_tag(tag.get("name", tag_name), resources)
             except Exception as e:
                 raise Exception(FeedbackManager.error_updating_tag(error=str(e)))
 
 
-async def update_tags_in_resource(rs: Dict[str, Any], resource_type: str, client: TinyB):
+def update_tags_in_resource(rs: Dict[str, Any], resource_type: str, client: TinyB):
     filtering_tags = rs.get("filtering_tags", [])
 
     if not filtering_tags:
@@ -89,7 +89,7 @@ async def update_tags_in_resource(rs: Dict[str, Any], resource_type: str, client
     if resource_type == "datasource":
         ds_name = rs["params"]["name"]
         try:
-            persisted_ds = await client.get_datasource(ds_name)
+            persisted_ds = client.get_datasource(ds_name)
             resource_id = persisted_ds.get("id", "")
             resource_name = persisted_ds.get("name", "")
         except DoesNotExistException:
@@ -99,7 +99,7 @@ async def update_tags_in_resource(rs: Dict[str, Any], resource_type: str, client
     elif resource_type == "pipe":
         pipe_name = rs["name"]
         try:
-            persisted_pipe = await client.pipe(pipe_name)
+            persisted_pipe = client.pipe(pipe_name)
             resource_id = persisted_pipe.get("id", "")
             resource_name = persisted_pipe.get("name", "")
         except DoesNotExistException:
@@ -107,7 +107,7 @@ async def update_tags_in_resource(rs: Dict[str, Any], resource_type: str, client
 
     if resource_id and resource_name:
         try:
-            await update_tags(
+            update_tags(
                 resource_id=resource_id,
                 resource_name=resource_name,
                 resource_type=resource_type,

tinybird/tb/modules/datafile/build_datasource.py

@@ -10,7 +10,7 @@ from tinybird.tb.client import DoesNotExistException, TinyB
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
-async def new_ds(
+def new_ds(
     ds: Dict[str, Any],
     client: TinyB,
     user_token: Optional[str],
@@ -25,26 +25,26 @@ async def new_ds(
 ):
     ds_name = ds["params"]["name"]
 
-    async def manage_tokens():
+    def manage_tokens():
         # search for token with specified name and adds it if not found or adds permissions to it
         t = None
         for tk in ds["tokens"]:
             token_name = tk["token_name"]
-            t = await client.get_token_by_name(token_name)
+            t = client.get_token_by_name(token_name)
             if not t:
                 token_name = tk["token_name"]
                 # DS == token_origin.Origins.DATASOURCE
-                await client.create_token(token_name, [f"DATASOURCES:{tk['permissions']}:{ds_name}"], "DS", ds_name)
+                client.create_token(token_name, [f"DATASOURCES:{tk['permissions']}:{ds_name}"], "DS", ds_name)
             else:
                 scopes = [f"DATASOURCES:{tk['permissions']}:{ds_name}"]
                 for x in t["scopes"]:
                     sc = x["type"] if "resource" not in x else f"{x['type']}:{x['resource']}"
                     scopes.append(sc)
-                await client.alter_tokens(token_name, scopes)
+                client.alter_tokens(token_name, scopes)
 
     datasource_exists = False
     try:
-        existing_ds = await client.get_datasource(ds_name)
+        existing_ds = client.get_datasource(ds_name)
         datasource_exists = True
     except DoesNotExistException:
         datasource_exists = False
@@ -81,25 +81,25 @@ async def new_ds(
                 if extension not in valid_formats:
                     raise Exception(FeedbackManager.error_format(extension=extension, valid_formats=valid_formats))
                 params["format"] = extension
-            datasource_response = await client.datasource_create_from_definition(params)
+            datasource_response = client.datasource_create_from_definition(params)
             datasource = datasource_response.get("datasource", {})
 
             if datasource.get("service") == "dynamodb":
                 job_id = datasource_response.get("import_id", None)
                 if job_id:
-                    jobs = await client.jobs(status=("waiting", "working"))
+                    jobs = client.jobs(status=("waiting", "working"))
                     job_url = next((job["job_url"] for job in jobs if job["id"] == job_id), None)
                     if job_url:
                         click.echo(FeedbackManager.success_dynamodb_initial_load(job_url=job_url))
 
             if ds.get("tokens"):
-                await manage_tokens()
+                manage_tokens()
 
             if ds.get("shared_with") and not build:
                 if not user_token:
                     click.echo(FeedbackManager.info_skipping_shared_with_entry())
                 else:
-                    await share_and_unshare_datasource(
+                    share_and_unshare_datasource(
                         client,
                         datasource,
                         user_token,
@@ -110,7 +110,7 @@ async def new_ds(
             if is_vendor and user_token and local_ws and current_ws:
                 user_client: TinyB = deepcopy(client)
                 user_client.token = user_token
-                await user_client.datasource_share(
+                user_client.datasource_share(
                     datasource_id=datasource.get("id", ""),
                     current_workspace_id=current_ws.get("id", ""),
                     destination_workspace_id=local_ws.get("id", ""),
@@ -127,7 +127,7 @@ async def new_ds(
         if not user_token:
             click.echo(FeedbackManager.info_skipping_shared_with_entry())
         else:
-            await share_and_unshare_datasource(
+            share_and_unshare_datasource(
                 client,
                 existing_ds,
                 user_token,
@@ -169,7 +169,7 @@ async def new_ds(
             or new_ttl
             or ((new_indices is not None) and (not fork_downstream or not fork))
         ):
-            alter_response = await client.alter_datasource(
+            alter_response = client.alter_datasource(
                 ds_name,
                 new_schema=new_schema,
                 description=new_description,
@@ -198,7 +198,7 @@ async def new_ds(
             make_changes = click.prompt(FeedbackManager.info_ask_for_alter_confirmation()).lower() == "y"
 
         if make_changes:
-            await client.alter_datasource(
+            client.alter_datasource(
                 ds_name,
                 new_schema=new_schema,
                 description=new_description,
@@ -224,7 +224,7 @@ async def new_ds(
 
         try:
             click.echo(FeedbackManager.info_update_datasource(datasource=ds_name, params=params))
-            await client.update_datasource(ds_name, params)
+            client.update_datasource(ds_name, params)
             click.echo(FeedbackManager.success_update_datasource(datasource=ds_name, params=params))
             make_changes = True
             alter_response = True
@@ -256,7 +256,7 @@ async def new_ds(
             if not connector_id:
                 return
 
-            current_connector = await client.get_connector_by_id(existing_ds.get("connector", ""))
+            current_connector = client.get_connector_by_id(existing_ds.get("connector", ""))
             if not current_connector:
                 return
 
@@ -292,7 +292,7 @@ async def new_ds(
         }
 
         try:
-            await client.update_datasource(ds_name, connector_data)
+            client.update_datasource(ds_name, connector_data)
             click.echo(FeedbackManager.success_promoting_datasource(datasource=ds_name))
             return
         except Exception as e:
@@ -309,7 +309,7 @@ async def new_ds(
             and click.prompt(FeedbackManager.info_ask_for_datasource_confirmation()) == ds_name
         ):  # TODO move to CLI
             try:
-                await client.datasource_delete(ds_name)
+                client.datasource_delete(ds_name)
                 click.echo(FeedbackManager.success_delete_datasource(datasource=ds_name))
             except Exception:
                 raise click.ClickException(FeedbackManager.error_removing_datasource(datasource=ds_name))
@@ -329,7 +329,7 @@ async def new_ds(
                 click.echo(FeedbackManager.warning_datasource_already_exists(datasource=ds_name))
 
 
-async def share_and_unshare_datasource(
+def share_and_unshare_datasource(
     client: TinyB,
     datasource: Dict[str, Any],
     user_token: str,
@@ -346,9 +346,9 @@ async def share_and_unshare_datasource(
     if current_ws:
         # Force to get all the workspaces the user can access
         workspace = current_ws
-        workspaces = (await client.user_workspaces(version="v1")).get("workspaces", [])
+        workspaces = (client.user_workspaces(version="v1")).get("workspaces", [])
     else:
-        workspace = await client.user_workspace_branches(version="v1")
+        workspace = client.user_workspace_branches(version="v1")
         workspaces = workspace.get("workspaces", [])
 
     if workspace.get("is_branch", False):
@@ -366,7 +366,7 @@ async def share_and_unshare_datasource(
                     f"Unable to share datasource with the workspace {workspace_to_share}. Review that you have the admin permissions on this workspace"
                 )
 
-            await user_client.datasource_share(
+            user_client.datasource_share(
                 datasource_id=datasource_id,
                 current_workspace_id=workspace.get("id", ""),
                 destination_workspace_id=w.get("id", ""),
@@ -387,7 +387,7 @@ async def share_and_unshare_datasource(
         workspaces_need_to_unshare = [w for w in shared_with if w not in defined_to_share_with]
 
         for w in workspaces_need_to_share:
-            await user_client.datasource_share(
+            user_client.datasource_share(
                 datasource_id=datasource_id,
                 current_workspace_id=workspace.get("id", ""),
                 destination_workspace_id=w.get("id", ""),
@@ -397,7 +397,7 @@ async def share_and_unshare_datasource(
             )
 
         for w in workspaces_need_to_unshare:
-            await user_client.datasource_unshare(
+            user_client.datasource_unshare(
                 datasource_id=datasource_id,
                 current_workspace_id=workspace.get("id", ""),
                 destination_workspace_id=w.get("id", ""),

tinybird/tb/modules/datafile/build_pipe.py

@@ -13,7 +13,7 @@ from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
-async def new_pipe(
+def new_pipe(
     p,
     config: CLIConfig,
     tb_client: TinyB,
@@ -53,7 +53,7 @@ async def new_pipe(
     cli_params["ignore_sql_errors"] = "true" if ignore_sql_errors else "false"
     cli_params["workspace_id"] = config.get("id", None)
 
-    r: requests.Response = await requests_get(f"{host}/v0/playgrounds?{urlencode(cli_params)}", headers=headers)
+    r: requests.Response = requests_get(f"{host}/v0/playgrounds?{urlencode(cli_params)}", headers=headers)
     current_pipe = None
     pipe_exists = False
     playgrounds_response = r.json() if r.status_code == 200 else None
@@ -104,7 +104,7 @@ async def new_pipe(
         body["name"] = p["name"] + "__tb__playground"
 
         if pipe_exists and current_pipe:
-            data = await user_client._req(
+            data = user_client._req(
                 f"/v0/playgrounds/{current_pipe['id']}?{urlencode(params)}",
                 method="PUT",
                 headers=post_headers,
@@ -112,7 +112,7 @@ async def new_pipe(
             )
 
         else:
-            data = await user_client._req(
+            data = user_client._req(
                 f"/v0/playgrounds?{urlencode(params)}",
                 method="POST",
                 headers=post_headers,
@@ -126,23 +126,21 @@ async def new_pipe(
         t = None
         for tk in p["tokens"]:
             token_name = tk["token_name"]
-            t = await tb_client.get_token_by_name(token_name)
+            t = tb_client.get_token_by_name(token_name)
             if t:
                 scopes = [f"PIPES:{tk['permissions']}:{p['name']}"]
                 for x in t["scopes"]:
                     sc = x["type"] if "resource" not in x else f"{x['type']}:{x['resource']}"
                     scopes.append(sc)
                 try:
-                    r = await tb_client.alter_tokens(token_name, scopes)
+                    r = tb_client.alter_tokens(token_name, scopes)
                     token = r["token"]  # type: ignore
                 except Exception as e:
                     raise click.ClickException(FeedbackManager.error_creating_pipe(error=e))
             else:
                 token_name = tk["token_name"]
                 try:
-                    r = await tb_client.create_token(
-                        token_name, [f"PIPES:{tk['permissions']}:{p['name']}"], "P", p["name"]
-                    )
+                    r = tb_client.create_token(token_name, [f"PIPES:{tk['permissions']}:{p['name']}"], "P", p["name"])
                     token = r["token"]  # type: ignore
                 except Exception as e:
                     raise click.ClickException(FeedbackManager.error_creating_pipe(error=e))
@@ -156,7 +154,7 @@ async def new_pipe(
                 "q": "",
                 "token": token,
             }
-            endpoint_url = await tb_client._req(f"/examples/query.http?{urlencode(example_params)}")
+            endpoint_url = tb_client._req(f"/examples/query.http?{urlencode(example_params)}")
             if endpoint_url:
                 endpoint_url = endpoint_url.replace("http://localhost:8001", host)
                 click.echo(f"""** => Test endpoint with:\n** $ curl {endpoint_url}""")
@@ -164,12 +162,12 @@ async def new_pipe(
             pass
 
 
-async def get_token_from_main_branch(branch_tb_client: TinyB) -> Optional[str]:
+def get_token_from_main_branch(branch_tb_client: TinyB) -> Optional[str]:
     token_from_main_branch = None
-    current_workspace = await branch_tb_client.workspace_info(version="v1")
+    current_workspace = branch_tb_client.workspace_info(version="v1")
     # current workspace is a branch
     if current_workspace.get("main"):
-        response = await branch_tb_client.user_workspaces(version="v1")
+        response = branch_tb_client.user_workspaces(version="v1")
         workspaces = response["workspaces"]
         prod_workspace = next(
             (workspace for workspace in workspaces if workspace["id"] == current_workspace["main"]), None