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

tinybird/tb/modules/config.py

@@ -256,9 +256,7 @@ class CLIConfig:
     def set_workspace_token(self, workspace_id: str, token: str) -> None:
         pass
 
-    async def get_workspace_token(
-        self, workspace_id: Optional[str] = None, host: Optional[str] = None
-    ) -> Optional[str]:
+    def get_workspace_token(self, workspace_id: Optional[str] = None, host: Optional[str] = None) -> Optional[str]:
         """Returns the token for the specific workspace on a host.
         - If no workspace passed, it uses the current active workspace.
         - If no host is passed, it uses the current one.
@@ -282,7 +280,7 @@ class CLIConfig:
 
         client: tbc.TinyB = self.get_client(token=self.get_user_token(), host=host)
 
-        info: Dict[str, Any] = await client.user_workspaces_and_branches(version="v1")
+        info: Dict[str, Any] = client.user_workspaces_and_branches(version="v1")
         workspaces: List[Dict[str, Any]] = info["workspaces"]
 
         result: Optional[str] = next(

tinybird/tb/modules/connection.py

@@ -15,7 +15,6 @@ from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import (
     DataConnectorType,
     _get_setting_value,
-    coro,
     echo_safe_humanfriendly_tables_format_smart_table,
     get_gcs_connection_name,
     get_gcs_svc_account_creds,
@@ -117,13 +116,12 @@ def connection(ctx: Context) -> None:
 @connection.command(name="ls")
 @click.option("--service", help="Filter by service")
 @click.pass_context
-@coro
-async def connection_ls(ctx: Context, service: Optional[DataConnectorType] = None) -> None:
+def connection_ls(ctx: Context, service: Optional[DataConnectorType] = None) -> None:
     """List connections."""
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     client: TinyB = obj["client"]
 
-    connections = await client.connections(connector=service, skip_bigquery=True)
+    connections = client.connections(connector=service, skip_bigquery=True)
     columns = []
     table = []
 
@@ -155,8 +153,7 @@ def connection_create(ctx: Context) -> None:
 
 @connection_create.command(name="s3", short_help="Creates a AWS S3 connection.")
 @click.pass_context
-@coro
-async def connection_create_s3(ctx: Context) -> None:
+def connection_create_s3(ctx: Context) -> None:
     """
     Creates a AWS S3 connection.
 
@@ -167,7 +164,7 @@ async def connection_create_s3(ctx: Context) -> None:
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     client: TinyB = obj["client"]
 
-    if obj["env"] == "local" and not await client.check_aws_credentials():
+    if obj["env"] == "local" and not client.check_aws_credentials():
         click.echo(
             FeedbackManager.error(
                 message="No AWS credentials found. Please run `tb local restart --use-aws-creds` to pass your credentials. "
@@ -194,7 +191,7 @@ async def connection_create_s3(ctx: Context) -> None:
     )
 
     connection_name = get_s3_connection_name(project.folder)
-    role_arn, region, bucket_name = await run_aws_iamrole_connection_flow(
+    role_arn, region, bucket_name = run_aws_iamrole_connection_flow(
         client,
         service=service,
         environment=obj["env"],
@@ -206,7 +203,7 @@ async def connection_create_s3(ctx: Context) -> None:
     if obj["env"] == "local":
         save_secret_to_env_file(project=project, name=secret_name, value=role_arn)
     else:
-        await client.create_secret(name=secret_name, value=role_arn)
+        client.create_secret(name=secret_name, value=role_arn)
 
     create_in_cloud = (
         click.confirm(FeedbackManager.prompt_connection_in_cloud_confirmation(), default=True)
@@ -223,7 +220,7 @@ async def connection_create_s3(ctx: Context) -> None:
             host=host,
             staging=False,
         )
-        prod_role_arn, _, _ = await production_aws_iamrole_only(
+        prod_role_arn, _, _ = production_aws_iamrole_only(
             prod_client,
             service=service,
             region=region,
@@ -232,9 +229,9 @@ async def connection_create_s3(ctx: Context) -> None:
             connection_name=connection_name,
             policy=access_type.lower(),
         )
-        await prod_client.create_secret(name=secret_name, value=prod_role_arn)
+        prod_client.create_secret(name=secret_name, value=prod_role_arn)
 
-    connection_file_path = await generate_aws_iamrole_connection_file_with_secret(
+    connection_file_path = generate_aws_iamrole_connection_file_with_secret(
         name=connection_name,
         service=service,
         role_arn_secret_name=secret_name,
@@ -260,8 +257,7 @@ async def connection_create_s3(ctx: Context) -> None:
 
 @connection_create.command(name="gcs", short_help="Creates a Google Cloud Storage connection.")
 @click.pass_context
-@coro
-async def connection_create_gcs(ctx: Context) -> None:
+def connection_create_gcs(ctx: Context) -> None:
     """
     Creates a Google Cloud Storage connection.
 
@@ -275,16 +271,16 @@ async def connection_create_gcs(ctx: Context) -> None:
     service = DataConnectorType.GCLOUD_STORAGE
     click.echo(FeedbackManager.prompt_gcs_connection_header())
     connection_name = get_gcs_connection_name(project.folder)
-    await run_gcp_svc_account_connection_flow(environment=obj["env"])
+    run_gcp_svc_account_connection_flow(environment=obj["env"])
     creds_json = get_gcs_svc_account_creds()
     unique_suffix = uuid.uuid4().hex[:8]  # Use first 8 chars of a UUID for brevity
     secret_name = f"gcs_svc_account_creds_{connection_name}_{unique_suffix}"
     if obj["env"] == "local":
         save_secret_to_env_file(project=project, name=secret_name, value=creds_json)
     else:
-        await client.create_secret(name=secret_name, value=creds_json)
+        client.create_secret(name=secret_name, value=creds_json)
 
-    connection_path = await generate_gcs_connection_file_with_secrets(
+    connection_path = generate_gcs_connection_file_with_secrets(
         name=connection_name,
         service=service,
         svc_account_creds=secret_name,
@@ -308,7 +304,7 @@ async def connection_create_gcs(ctx: Context) -> None:
         )
         creds_json = get_gcs_svc_account_creds()
         secret_name = f"gcs_svc_account_creds_{connection_name}_{unique_suffix}"
-        await prod_client.create_secret(name=secret_name, value=creds_json)
+        prod_client.create_secret(name=secret_name, value=creds_json)
 
     click.echo(
         FeedbackManager.prompt_gcs_success(
@@ -320,18 +316,17 @@ async def connection_create_gcs(ctx: Context) -> None:
 
 @connection_create.command(name="kafka", short_help="Creates a Kafka connection.")
 @click.pass_context
-@coro
-async def connection_create_kafka_cmd(ctx: Context) -> None:
+def connection_create_kafka_cmd(ctx: Context) -> None:
     """
     Creates a Kafka connection.
 
     \b
     $ tb connection create kafka
     """
-    await connection_create_kafka(ctx)
+    connection_create_kafka(ctx)
 
 
-async def connection_create_kafka(ctx: Context) -> Tuple[str, str, str, str, str, str, str, str, List[str]]:
+def connection_create_kafka(ctx: Context) -> Tuple[str, str, str, str, str, str, str, str, List[str]]:
     obj: Dict[str, Any] = ctx.ensure_object(dict)
     click.echo(FeedbackManager.gray(message="\n» Creating Kafka connection..."))
     project: Project = ctx.ensure_object(dict)["project"]
@@ -439,11 +434,11 @@ async def connection_create_kafka(ctx: Context) -> Tuple[str, str, str, str, str
             staging=False,
         )
         if tb_secret_bootstrap_servers:
-            await prod_client.create_secret(name=tb_secret_bootstrap_servers, value=bootstrap_servers)
+            prod_client.create_secret(name=tb_secret_bootstrap_servers, value=bootstrap_servers)
         if tb_secret_key:
-            await prod_client.create_secret(name=tb_secret_key, value=key)
+            prod_client.create_secret(name=tb_secret_key, value=key)
         if tb_secret_secret:
-            await prod_client.create_secret(name=tb_secret_secret, value=secret)
+            prod_client.create_secret(name=tb_secret_secret, value=secret)
         click.echo(FeedbackManager.success(message="✓ Secrets created!"))
 
     schema_registry_url = click.prompt(
@@ -471,7 +466,7 @@ async def connection_create_kafka(ctx: Context) -> Tuple[str, str, str, str, str
         raise CLIConnectionException(FeedbackManager.error(message="Invalid Kafka connection"))
 
     click.echo(FeedbackManager.success(message="✓ Connection is valid"))
-    await generate_kafka_connection_with_secrets(
+    generate_kafka_connection_with_secrets(
         name=name,
         bootstrap_servers=bootstrap_servers,
         tb_secret_bootstrap_servers=tb_secret_bootstrap_servers,

tinybird/tb/modules/copy.py

@@ -13,7 +13,7 @@ from click import Context
 from tinybird.datafile.common import get_name_version
 from tinybird.tb.client import AuthNoTokenException, TinyB
 from tinybird.tb.modules.cli import cli
-from tinybird.tb.modules.common import coro, echo_safe_humanfriendly_tables_format_smart_table, wait_job
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table, wait_job
 from tinybird.tb.modules.exceptions import CLIPipeException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
@@ -34,12 +34,11 @@ def copy(ctx):
     help="Force a type of the output",
 )
 @click.pass_context
-@coro
-async def copy_ls(ctx: Context, match: str, format_: str):
+def copy_ls(ctx: Context, match: str, format_: str):
     """List copy pipes"""
 
     client: TinyB = ctx.ensure_object(dict)["client"]
-    pipes = await client.pipes(dependencies=False, node_attrs="name", attrs="name,updated_at,type")
+    pipes = client.pipes(dependencies=False, node_attrs="name", attrs="name,updated_at,type")
     copies = [p for p in pipes if p.get("type") == "copy"]
     copies = sorted(copies, key=lambda p: p["updated_at"])
     columns = ["name", "updated at", "nodes"]
@@ -84,8 +83,7 @@ async def copy_ls(ctx: Context, match: str, format_: str):
     help="Key and value of the params you want the Copy pipe to be called with. For example: tb pipe copy run <my_copy_pipe> --param foo=bar",
 )
 @click.pass_context
-@coro
-async def copy_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: str, param: Optional[Tuple[str]]):
+def copy_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: str, param: Optional[Tuple[str]]):
     """Run an on-demand copy pipe"""
 
     params = dict(key_value.split("=") for key_value in param) if param else {}
@@ -93,18 +91,18 @@ async def copy_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: s
     client: TinyB = ctx.ensure_object(dict)["client"]
 
     try:
-        response = await client.pipe_run(pipe_name_or_id, "copy", params, mode)
+        response = client.pipe_run(pipe_name_or_id, "copy", params, mode)
         job_id = response["job"]["job_id"]
         job_url = response["job"]["job_url"]
         target_datasource_id = response["tags"]["copy_target_datasource"]
-        target_datasource = await client.get_datasource(target_datasource_id)
+        target_datasource = client.get_datasource(target_datasource_id)
         target_datasource_name = target_datasource["name"]
         click.echo(FeedbackManager.gray(message="Job URL: ") + FeedbackManager.info(message=f"{job_url}"))
         click.echo(FeedbackManager.success(message=f"✓ Copy to '{target_datasource_name}' job created"))
 
         if wait:
             click.echo("\n")
-            await wait_job(client, job_id, job_url, FeedbackManager.highlight(message="» Copying data"))
+            wait_job(client, job_id, job_url, FeedbackManager.highlight(message="» Copying data"))
             click.echo(FeedbackManager.success(message=f"✓ Data copied to '{target_datasource_name}'"))
 
     except AuthNoTokenException:

tinybird/tb/modules/create.py

@@ -13,7 +13,7 @@ from tinybird.prompts import claude_rules_prompt, create_prompt, readme_prompt,
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.cicd import init_cicd
 from tinybird.tb.modules.cli import cli
-from tinybird.tb.modules.common import _generate_datafile, coro, generate_datafile
+from tinybird.tb.modules.common import _generate_datafile, generate_datafile
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.datafile.fixture import persist_fixture
 from tinybird.tb.modules.exceptions import CLICreateException
@@ -42,8 +42,7 @@ from tinybird.tb.modules.project import Project
 @click.option("--folder", type=str, default=None, help="Folder to create the project in")
 @click.option("--agent", type=str, default="cursor", help="Agent to use for rules")
 @click.pass_context
-@coro
-async def create(
+def create(
     ctx: click.Context, data: Optional[str], prompt: Optional[str], rows: int, folder: Optional[str], agent: str
 ) -> None:
     """Initialize a new project."""
@@ -93,14 +92,14 @@ async def create(
         data_result: List[Path] = []
         if data:
             if urlparse(data).scheme in ("http", "https"):
-                data_result = await create_resources_from_url(data, project, ctx_config)
+                data_result = create_resources_from_url(data, project, ctx_config)
             else:
-                data_result = await create_resources_from_data(data, project, ctx_config)
+                data_result = create_resources_from_data(data, project, ctx_config)
             result.extend(data_result)
 
         prompt_result: List[Path] = []
         if prompt:
-            prompt_result = await create_resources_from_prompt(tb_client, user_token, prompt, project)
+            prompt_result = create_resources_from_prompt(tb_client, user_token, prompt, project)
             result.extend(prompt_result)
             readme_path = folder_path / "README.md"
             if readme_path.exists():
@@ -135,7 +134,7 @@ async def create(
         if not already_has_cicd(root_folder):
             click.echo(FeedbackManager.highlight(message="\n» Creating CI/CD files for GitHub and GitLab..."))
             init_git(root_folder)
-            await init_cicd(root_folder, data_project_dir=os.path.relpath(folder))
+            init_cicd(root_folder, data_project_dir=os.path.relpath(folder))
             click.echo(FeedbackManager.success(message="✓ Done!\n"))
             created_something = True
 
@@ -160,7 +159,7 @@ async def create(
                 for ds_path in [ds for ds in data_result if ds.suffix == ".datasource"]:
                     parsed_url = urlparse(data)
                     if parsed_url.scheme in ("http", "https"):
-                        response = requests.get(data)  # noqa: ASYNC210
+                        response = requests.get(data)
                         data_content = response.text
                         data_format = parsed_url.path.split(".")[-1]
                     else:
@@ -182,7 +181,7 @@ async def create(
                     datasource_content = datasource_path.read_text()
                     has_json_path = "`json:" in datasource_content
                     if has_json_path:
-                        mock_data = await create_mock_data(
+                        mock_data = create_mock_data(
                             datasource_name,
                             datasource_content,
                             rows,
@@ -291,7 +290,7 @@ def create_project_structure(folder: str):
             pass
 
 
-async def create_resources_from_prompt(
+def create_resources_from_prompt(
     tb_client: TinyB,
     user_token: str,
     prompt: str,
@@ -445,7 +444,7 @@ def generate_connection_file(name: str, content: str, folder: str, skip_feedback
     return f.relative_to(folder)
 
 
-async def generate_aws_iamrole_connection_file_with_secret(
+def generate_aws_iamrole_connection_file_with_secret(
     name: str, service: str, role_arn_secret_name: str, region: str, folder: str, with_default_secret: bool = False
 ) -> Path:
     if with_default_secret:
@@ -460,9 +459,7 @@ S3_REGION {region}
     return file_path
 
 
-async def generate_gcs_connection_file_with_secrets(
-    name: str, service: str, svc_account_creds: str, folder: str
-) -> Path:
+def generate_gcs_connection_file_with_secrets(name: str, service: str, svc_account_creds: str, folder: str) -> Path:
     content = f"""TYPE {service}
 GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON {{{{ tb_secret("{svc_account_creds}") }}}}
 """
@@ -538,20 +535,20 @@ def get_resources_xml(project: Project) -> str:
     return resources_xml
 
 
-async def create_resources_from_data(
+def create_resources_from_data(
     data: str,
     project: Project,
     config: Dict[str, Any],
     skip_pipes: bool = False,
 ) -> List[Path]:
-    local_client = await get_tinybird_local_client(config)
+    local_client = get_tinybird_local_client(config)
     folder_path = project.path
     path = folder_path / data
     if not path.exists():
         path = Path(data)
     result: List[Path] = []
     format = path.suffix.lstrip(".")
-    ds_file = await _generate_datafile(str(path), local_client, format=format, force=True, folder=project.folder)
+    ds_file = _generate_datafile(str(path), local_client, format=format, force=True, folder=project.folder)
     result.append(ds_file)
     name = ds_file.stem
     no_pipes = len(project.get_pipe_files()) == 0
@@ -570,13 +567,13 @@ TYPE ENDPOINT
     return result
 
 
-async def create_resources_from_url(
+def create_resources_from_url(
     url: str, project: Project, config: Dict[str, Any], skip_pipes: bool = False
 ) -> List[Path]:
     result: List[Path] = []
-    local_client = await get_tinybird_local_client(config)
+    local_client = get_tinybird_local_client(config)
     format = url.split(".")[-1]
-    ds_file = await _generate_datafile(url, local_client, format=format, force=True, folder=project.folder)
+    ds_file = _generate_datafile(url, local_client, format=format, force=True, folder=project.folder)
     result.append(ds_file)
     name = ds_file.stem
     no_pipes = len(project.get_pipe_files()) == 0
@@ -595,7 +592,7 @@ TYPE ENDPOINT
     return result
 
 
-async def generate_kafka_connection_with_secrets(
+def generate_kafka_connection_with_secrets(
     name: str,
     bootstrap_servers: str,
     key: str,