tinybird 0.0.1.dev97__py3-none-any.whl → 0.0.1.dev98__py3-none-any.whl

tinybird/client.py

@@ -714,8 +714,8 @@ class TinyB:
     async def job_cancel(self, job_id: str):
         return await self._req(f"/v0/jobs/{job_id}/cancel", method="POST", data=b"")
 
-    async def user_workspaces(self):
-        data = await self._req("/v0/user/workspaces/?with_environments=false")
+    async def user_workspaces(self, version: str = "v0"):
+        data = await 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}"
@@ -725,16 +725,16 @@ 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):
-        return await self._req("/v0/user/workspaces/?with_environments=true")
+    async def user_workspaces_and_branches(self, version: str = "v0"):
+        return await self._req(f"/{version}/user/workspaces/?with_environments=true")
 
-    async def user_workspaces_with_organization(self):
+    async def user_workspaces_with_organization(self, version: str = "v0"):
         return await self._req(
-            "/v0/user/workspaces/?with_environments=false&with_organization=true&with_members_and_owner=false"
+            f"/{version}/user/workspaces/?with_environments=false&with_organization=true&with_members_and_owner=false"
         )
 
-    async def user_workspace_branches(self):
-        return await self._req("/v0/user/workspaces/?with_environments=true&only_environments=true")
+    async def user_workspace_branches(self, version: str = "v0"):
+        return await self._req(f"/{version}/user/workspaces/?with_environments=true&only_environments=true")
 
     async def branches(self):
         return await self._req("/v0/environments")
@@ -747,8 +747,9 @@ class TinyB:
         name: str,
         template: Optional[str],
         assign_to_organization_id: Optional[str] = None,
+        version: str = "v0",
     ):
-        url = f"/v0/workspaces?name={name}"
+        url = f"/{version}/workspaces?name={name}"
         if template:
             url += f"&starter_kit={template}"
         if assign_to_organization_id:
@@ -884,8 +885,8 @@ class TinyB:
         params = {"with_token": "true" if with_token else "false"}
         return await self._req(f"/v0/workspaces/{workspace_id}?{urlencode(params)}")
 
-    async def workspace_info(self) -> Dict[str, Any]:
-        return await self._req("/v0/workspace")
+    async def workspace_info(self, version: str = "v0") -> Dict[str, Any]:
+        return await self._req(f"/{version}/workspace")
 
     async def organization(self, organization_id: str):
         return await self._req(f"/v0/organizations/{organization_id}")
@@ -906,6 +907,21 @@ class TinyB:
             data=json.dumps({"workspace_ids": ",".join(workspace_ids)}),
         )
 
+    async 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")
+
+    async def infra_list(self, organization_id: str) -> List[Dict[str, Any]]:
+        data = await 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")
+
     async def wait_for_job(
         self,
         job_id: str,

tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/cli/introduction.html'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev97'
-__revision__ = 'b9f9a1e'
+__version__ = '0.0.1.dev98'
+__revision__ = 'f7b04b3'

tinybird/tb/modules/cli.py

@@ -121,7 +121,7 @@ async def cli(
     # If they have passed a token or host as parameter and it's different that record in .tinyb, refresh the workspace id
     if token or host:
         try:
-            workspace = await client.workspace_info()
+            workspace = await client.workspace_info(version="v1")
             config["id"] = workspace.get("id", "")
             config["name"] = workspace.get("name", "")
         # If we can not get this info, we continue with the id on the file
@@ -236,7 +236,7 @@ async def diff(
     else:
         config = CLIConfig.get_project_config()
 
-        response = await client.user_workspaces_and_branches()
+        response = await client.user_workspaces_and_branches(version="v1")
         ws_client = None
         for workspace in response["workspaces"]:
             if config["id"] == workspace["id"]:

tinybird/tb/modules/common.py

@@ -198,7 +198,7 @@ def generate_datafile(
 
 async def get_current_workspace(config: CLIConfig) -> Optional[Dict[str, Any]]:
     client = config.get_client()
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches()).get("workspaces", [])
+    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches(version="v1")).get("workspaces", [])
     return _get_current_workspace_common(workspaces, config["id"])
 
 
@@ -213,7 +213,7 @@ def _get_current_workspace_common(
 
 
 async def get_current_environment(client, config):
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches()).get("workspaces", [])
+    workspaces: List[Dict[str, Any]] = (await client.user_workspaces_and_branches(version="v1")).get("workspaces", [])
     return next((workspace for workspace in workspaces if workspace["id"] == config["id"]), None)
 
 
@@ -700,7 +700,9 @@ async def create_workspace_non_interactive(
         user_client: TinyB = deepcopy(client)
         user_client.token = user_token
 
-        created_workspace = await user_client.create_workspace(workspace_name, starterkit, organization_id)
+        created_workspace = await user_client.create_workspace(
+            workspace_name, starterkit, organization_id, version="v1"
+        )
         if organization_id and organization_name:
             click.echo(
                 FeedbackManager.success_workspace_created_with_organization(
@@ -1210,7 +1212,7 @@ def _get_setting_value(connection, setting, sensitive_settings):
 
 async def switch_workspace(config: CLIConfig, workspace_name_or_id: str) -> None:
     try:
-        response = await config.get_client().user_workspaces()
+        response = await config.get_client().user_workspaces(version="v1")
         workspaces = response["workspaces"]
 
         workspace = next(
@@ -1436,7 +1438,7 @@ async def try_update_config_with_remote(
         return True
 
     try:
-        response = await config.get_client().workspace_info()
+        response = await config.get_client().workspace_info(version="v1")
     except AuthException:
         if raise_on_errors:
             raise CLIAuthException(FeedbackManager.error_invalid_token_for_host(host=config.get_host()))
@@ -1606,7 +1608,7 @@ async def wait_job_no_ui(
 
 
 async def get_current_main_workspace(config: CLIConfig) -> Optional[Dict[str, Any]]:
-    current_workspace = await config.get_client().user_workspaces_and_branches()
+    current_workspace = await config.get_client().user_workspaces_and_branches(version="v1")
     return _get_current_main_workspace_common(current_workspace, config.get("id", current_workspace["id"]))
 
 
@@ -1988,7 +1990,7 @@ async def get_organizations_by_user(config: CLIConfig, user_token: str) -> List[
 
     try:
         user_client = config.get_client(token=user_token)
-        user_workspaces = await user_client.user_workspaces_with_organization()
+        user_workspaces = await user_client.user_workspaces_with_organization(version="v1")
         admin_org_id = user_workspaces.get("organization_id")
         seen_org_ids = set()
 
@@ -2105,7 +2107,7 @@ async def create_organization_and_add_workspaces(
         raise CLIWorkspaceException(FeedbackManager.error_organization_creation(error=str(e)))
 
     # Add existing orphan workspaces to the organization - this is only needed for backwards compatibility
-    user_workspaces = await client.user_workspaces_with_organization()
+    user_workspaces = await client.user_workspaces_with_organization(version="v1")
     workspaces_to_migrate = []
     for workspace in user_workspaces["workspaces"]:
         if workspace.get("organization") is None and workspace.get("role") == "admin":

tinybird/tb/modules/config.py

@@ -279,7 +279,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()
+        info: Dict[str, Any] = await client.user_workspaces_and_branches(version="v1")
         workspaces: List[Dict[str, Any]] = info["workspaces"]
 
         result: Optional[str] = next(

tinybird/tb/modules/datafile/build.py

@@ -1015,7 +1015,7 @@ async def process_file(
                     period: int = DEFAULT_CRON_PERIOD
 
                     if current_ws is not None:
-                        workspaces = (await tb_client.user_workspaces()).get("workspaces", [])
+                        workspaces = (await 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"]), {}
                         )

tinybird/tb/modules/datafile/build_datasource.py

@@ -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()).get("workspaces", [])
+        workspaces = (await client.user_workspaces(version="v1")).get("workspaces", [])
     else:
-        workspace = await client.user_workspace_branches()
+        workspace = await client.user_workspace_branches(version="v1")
         workspaces = workspace.get("workspaces", [])
 
     if workspace.get("is_branch", False):

tinybird/tb/modules/datafile/build_pipe.py

@@ -166,10 +166,10 @@ async def new_pipe(
 
 async 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()
+    current_workspace = await branch_tb_client.workspace_info(version="v1")
     # current workspace is a branch
     if current_workspace.get("main"):
-        response = await branch_tb_client.user_workspaces()
+        response = await 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

tinybird/tb/modules/datafile/playground.py

@@ -1172,7 +1172,7 @@ async def process_file(
                     period: int = DEFAULT_CRON_PERIOD
 
                     if current_ws is not None:
-                        workspaces = (await tb_client.user_workspaces()).get("workspaces", [])
+                        workspaces = (await 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"]), {}
                         )

tinybird/tb/modules/infra.py

@@ -1,10 +1,17 @@
+import json
+import uuid
 from pathlib import Path
 from typing import Optional
 
 import click
 from click import Context
 
-from tinybird.tb.modules.cli import cli
+from tinybird.client import TinyB
+from tinybird.syncasync import async_to_sync
+from tinybird.tb.modules.cli import CLIException, cli
+from tinybird.tb.modules.common import coro, echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 from .common import CONTEXT_SETTINGS
 
@@ -51,13 +58,12 @@ spec:
     name: tinybird
 ---
 apiVersion: apps/v1
-kind: Deployment
+kind: StatefulSet
 metadata:
   name: tinybird
   namespace:  %(namespace)s
-  labels:
-    name: tinybird
 spec:
+  serviceName: "tinybird"
   replicas: 1
   selector:
     matchLabels:
@@ -76,6 +82,21 @@ spec:
             - name: http
               containerPort: 7181
               protocol: TCP
+          env:
+            - name: TB_INFRA_TOKEN
+              value: "%(infra_token)s"
+          volumeMounts:
+          - name: clickhouse-data
+            mountPath: /var/lib/clickhouse
+  volumeClaimTemplates:
+  - metadata:
+      name: clickhouse-data
+    spec:
+      accessModes: [ "ReadWriteOnce" ]
+      resources:
+        requests:
+          storage: 100Gi
+      storageClassName: %(storage_class)s
 """
 
 TERRAFORM_FIRST_TEMPLATE = """
@@ -161,13 +182,8 @@ def infra(ctx: Context) -> None:
     """Infra commands."""
 
 
-@infra.command(name="ls", hidden=True)
-@click.pass_context
-async def infra_ls(ctx: Context) -> None:
-    """List infra"""
-
-
 @infra.command(name="init")
+@click.option("--name", type=str, help="Name for identifying the self-managed infrastructure in Tinybird")
 @click.option("--provider", default="aws", type=str, help="Infrastructure provider (aws, gcp, azure)")
 @click.option("--region", type=str, help="AWS region (for AWS provider)")
 @click.option("--domain", type=str, help="Route53 domain name (for AWS provider)")
@@ -186,11 +202,13 @@ async def infra_ls(ctx: Context) -> None:
 @click.pass_context
 def infra_init(
     ctx: Context,
+    name: str,
     provider: str,
     region: Optional[str] = None,
     domain: Optional[str] = None,
     namespace: Optional[str] = None,
     dns_record: Optional[str] = None,
+    storage_class: Optional[str] = None,
     auto_apply_terraform: bool = False,
     auto_apply_dns: bool = False,
     auto_apply_kubectl: bool = False,
@@ -209,11 +227,69 @@ def infra_init(
     infra_dir.mkdir(exist_ok=True)
     yaml_path = infra_dir / "k8s.yaml"
     tf_path = infra_dir / "main.tf"
+    config_path = infra_dir / "config.json"
+
+    # Load existing configuration if available
+    config = {}
+    if config_path.exists():
+        try:
+            with open(config_path, "r") as f:
+                config = json.load(f)
+            click.echo("Loaded existing configuration from config.json")
+        except json.JSONDecodeError:
+            click.echo("Warning: Could not parse existing config.json, will create a new one")
+
+    # Generate a random ID for default values
+    random_id = str(uuid.uuid4())[:8]
+
+    # Get or prompt for configuration values
+    name = name or click.prompt("Enter name", type=str)
+    region = region or config.get("region") or click.prompt("Enter aws region", default="us-east-1", type=str)
+    domain = domain or config.get("domain") or click.prompt("Enter route 53 domain name", type=str)
+    namespace = (
+        namespace
+        or config.get("namespace")
+        or click.prompt("Enter namespace name", default=f"tinybird-{random_id}", type=str)
+    )
+    dns_record = (
+        dns_record
+        or config.get("dns_record")
+        or click.prompt("Enter DNS record name (without domain)", default=f"tinybird-{random_id}", type=str)
+    )
+    storage_class = config.get("storage_class") or click.prompt(
+        "Enter storage class", default="gp3-encrypted", type=str
+    )
+
+    # Save configuration
+    config = {
+        "provider": provider,
+        "region": region,
+        "domain": domain,
+        "namespace": namespace,
+        "dns_record": dns_record,
+        "storage_class": storage_class,
+    }
 
-    # Write the Terraform template
-    region = region or click.prompt("Enter aws region", default="us-east-1", type=str)
-    domain = domain or click.prompt("Enter route 53 domain name", type=str)
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+    click.echo(f"Configuration saved to {config_path}")
+
+    client: TinyB = ctx.obj["client"]
+    cli_config = CLIConfig.get_project_config()
+    user_client = cli_config.get_client(token=cli_config.get_user_token() or "")
+    user_workspaces = async_to_sync(user_client.user_workspaces_with_organization)()
+    admin_org_id = user_workspaces.get("organization_id")
+    infras = async_to_sync(client.infra_list)(organization_id=admin_org_id)
+    infra = next((infra for infra in infras if infra["name"] == name), None)
+    if not infra:
+        click.echo(FeedbackManager.highlight(message=f"\n» Creating infrastructure '{name}' in Tinybird..."))
+        host = f"https://{dns_record}.{domain}"
+        infra = async_to_sync(client.infra_create)(organization_id=admin_org_id, name=name, host=host)
+
+    infra_token = infra["token"]
 
+    # Write the Terraform template
     terraform_content = TERRAFORM_FIRST_TEMPLATE % {"aws_region": region, "domain": domain}
 
     with open(tf_path, "w") as f:
@@ -222,9 +298,7 @@ def infra_init(
     click.echo(f"Creating Terraform configuration in {tf_path}")
 
     # Apply Terraform configuration if user confirms
-    if not skip_terraform and (
-        auto_apply_terraform or click.confirm("Would you like to apply the Terraform configuration now?")
-    ):
+    if not skip_terraform:
         import subprocess
 
         # Initialize Terraform
@@ -236,272 +310,384 @@ def infra_init(
             click.echo(init_result.stderr)
             return
 
-        click.echo(init_result.stdout)
-
-        # Apply Terraform configuration
-        click.echo("\nApplying Terraform configuration...\n")
-        apply_result = subprocess.run(
-            ["terraform", "-chdir=infra", "apply", "-auto-approve"], capture_output=True, text=True
-        )
+        # Run terraform plan first
+        click.echo("\nRunning Terraform plan...\n")
+        plan_result = subprocess.run(["terraform", "-chdir=infra", "plan"], capture_output=True, text=True)
 
-        if apply_result.returncode != 0:
-            click.echo("Terraform apply failed:")
-            click.echo(apply_result.stderr)
+        if plan_result.returncode != 0:
+            click.echo("Terraform plan failed:")
+            click.echo(plan_result.stderr)
             return
 
-        click.echo(apply_result.stdout)
+        click.echo(plan_result.stdout)
 
-        # Get the certificate ARN output
-        output_result = subprocess.run(
-            ["terraform", "-chdir=infra", "output", "certificate_arn"], capture_output=True, text=True
-        )
+        # Apply Terraform configuration if user confirms
+        if auto_apply_terraform or click.confirm("Would you like to apply the Terraform configuration now?"):
+            click.echo("\nApplying Terraform configuration...\n")
+            apply_result = subprocess.run(
+                ["terraform", "-chdir=infra", "apply", "-auto-approve"], capture_output=True, text=True
+            )
 
-        if output_result.returncode == 0:
-            cert_arn = output_result.stdout.strip().replace('"', "")
-
-            namespace = namespace or click.prompt("Enter namespace name", default="tinybird", type=str)
-            new_content = K8S_YML % {"namespace": namespace, "cert_arn": cert_arn}
-
-            with open(yaml_path, "w") as f:
-                f.write(new_content.lstrip())
-
-            click.echo(f"Created Kubernetes configuration with certificate ARN in {yaml_path}")
-
-            # Prompt to apply the k8s configuration
-            if not skip_kubectl and (
-                auto_apply_kubectl or click.confirm("Would you like to apply the Kubernetes configuration now?")
-            ):
-                import subprocess
-
-                # Get current kubectl context
-                current_context_result = subprocess.run(
-                    ["kubectl", "config", "current-context"], capture_output=True, text=True
-                )
-
-                current_context = (
-                    current_context_result.stdout.strip() if current_context_result.returncode == 0 else "unknown"
-                )
-
-                # Get available contexts
-                contexts_result = subprocess.run(
-                    ["kubectl", "config", "get-contexts", "-o", "name"], capture_output=True, text=True
-                )
-
-                if contexts_result.returncode != 0:
-                    click.echo("Failed to get kubectl contexts:")
-                    click.echo(contexts_result.stderr)
-                    return
-
-                available_contexts = [
-                    context.strip() for context in contexts_result.stdout.splitlines() if context.strip()
-                ]
-
-                if not available_contexts:
-                    click.echo("No kubectl contexts found. Please configure kubectl first.")
-                    return
-
-                # Prompt user to select a context
-                if len(available_contexts) == 1:
-                    selected_context = available_contexts[0]
-                    click.echo(f"Using the only available kubectl context: {selected_context}")
-                else:
-                    click.echo("\nAvailable kubectl contexts:")
-                    for i, context in enumerate(available_contexts):
-                        marker = " (current)" if context == current_context else ""
-                        click.echo(f"  {i + 1}. {context}{marker}")
-
-                    click.echo("")
-                    default_index = (
-                        available_contexts.index(current_context) + 1 if current_context in available_contexts else 1
-                    )
+            if apply_result.returncode != 0:
+                click.echo("Terraform apply failed:")
+                click.echo(apply_result.stderr)
+                return
 
-                    selected_index = click.prompt(
-                        "Select kubectl context number to apply configuration",
-                        type=click.IntRange(1, len(available_contexts)),
-                        default=default_index,
-                    )
+            click.echo(apply_result.stdout)
 
-                    selected_context = available_contexts[selected_index - 1]
-                    click.echo(f"Selected context: {selected_context}")
-
-                # Apply the configuration to the selected context
-                click.echo(f"Applying Kubernetes configuration to context '{selected_context}'...")
-                apply_result = subprocess.run(
-                    ["kubectl", "--context", selected_context, "apply", "-f", str(yaml_path)],
-                    capture_output=True,
-                    text=True,
-                )
-
-                if apply_result.returncode != 0:
-                    click.echo("Failed to apply Kubernetes configuration:")
-                    click.echo(apply_result.stderr)
-                else:
-                    click.echo("Kubernetes configuration applied successfully:")
-                    click.echo(apply_result.stdout)
-
-                    # Get the namespace from the applied configuration
-                    namespace = None
-                    with open(yaml_path, "r") as f:
-                        for line in f:
-                            if "namespace:" in line and not namespace:
-                                namespace = line.split("namespace:")[1].strip()
-                                break
-
-                    if not namespace:
-                        namespace = "tinybird"  # Default namespace
-
-                    click.echo(f"\nWaiting for load balancer to be provisioned in namespace '{namespace}'...")
-
-                    # Wait for the load balancer to get an external IP
-                    max_attempts = 30
-                    attempt = 0
-                    external_ip = None
-
-                    while attempt < max_attempts and not external_ip:
-                        attempt += 1
-
-                        # Get the service details
-                        get_service_result = subprocess.run(
-                            [
-                                "kubectl",
-                                "--context",
-                                selected_context,
-                                "-n",
-                                namespace,
-                                "get",
-                                "service",
-                                "tinybird",
-                                "-o",
-                                "jsonpath='{.status.loadBalancer.ingress[0].hostname}'",
-                            ],
-                            capture_output=True,
-                            text=True,
-                        )
+            # Get the certificate ARN output
+            output_result = subprocess.run(
+                ["terraform", "-chdir=infra", "output", "certificate_arn"], capture_output=True, text=True
+            )
 
-                        if get_service_result.returncode == 0:
-                            potential_ip = get_service_result.stdout.strip().replace("'", "")
-                            if potential_ip and potential_ip != "":
-                                external_ip = potential_ip
-                                break
+            if output_result.returncode == 0:
+                cert_arn = output_result.stdout.strip().replace('"', "")
 
-                        click.echo(
-                            f"Attempt {attempt}/{max_attempts}: Load balancer not ready yet, waiting 10 seconds..."
-                        )
-                        import time
+                new_content = K8S_YML % {
+                    "namespace": namespace,
+                    "cert_arn": cert_arn,
+                    "storage_class": storage_class,
+                    "infra_token": infra_token,
+                }
 
-                        time.sleep(10)
+                with open(yaml_path, "w") as f:
+                    f.write(new_content.lstrip())
 
-                    if external_ip:
-                        click.echo("\n✅ Load balancer provisioned successfully!")
+                click.echo(f"Created Kubernetes configuration with certificate ARN in {yaml_path}")
 
-                        # Update the Terraform configuration with the load balancer DNS
-                        if not skip_dns and domain and tf_path.exists():
-                            click.echo("\nUpdating Terraform configuration with load balancer DNS...")
+                # Prompt to apply the k8s configuration
+                if not skip_kubectl and (
+                    auto_apply_kubectl or click.confirm("Would you like to apply the Kubernetes configuration now?")
+                ):
+                    import subprocess
 
-                            with open(tf_path, "r") as f:
-                                tf_content = f.read()
+                    # Get current kubectl context
+                    current_context_result = subprocess.run(
+                        ["kubectl", "config", "current-context"], capture_output=True, text=True
+                    )
 
-                            # Check if the Route 53 record already exists in the file
-                            if 'resource "aws_route53_record" "tinybird"' not in tf_content:
-                                # Get the DNS record name
-                                dns_record = dns_record or click.prompt(
-                                    "Enter DNS record name (without domain)", default="tinybird", type=str
-                                )
+                    current_context = (
+                        current_context_result.stdout.strip() if current_context_result.returncode == 0 else "unknown"
+                    )
 
-                                # Create the full DNS name
-                                full_dns_name = f"{dns_record}.{domain}"
+                    # Get available contexts
+                    contexts_result = subprocess.run(
+                        ["kubectl", "config", "get-contexts", "-o", "name"], capture_output=True, text=True
+                    )
 
-                                # Use in the Terraform template
-                                route53_record = TERRAFORM_SECOND_TEMPLATE % {
-                                    "external_ip": external_ip,
-                                    "full_dns_name": full_dns_name,
-                                }
+                    if contexts_result.returncode != 0:
+                        click.echo("Failed to get kubectl contexts:")
+                        click.echo(contexts_result.stderr)
+                        return
+
+                    available_contexts = [
+                        context.strip() for context in contexts_result.stdout.splitlines() if context.strip()
+                    ]
+
+                    if not available_contexts:
+                        click.echo("No kubectl contexts found. Please configure kubectl first.")
+                        return
+
+                    # Prompt user to select a context
+                    if len(available_contexts) == 1:
+                        selected_context = available_contexts[0]
+                        click.echo(f"Using the only available kubectl context: {selected_context}")
+                    else:
+                        click.echo("\nAvailable kubectl contexts:")
+                        for i, context in enumerate(available_contexts):
+                            marker = " (current)" if context == current_context else ""
+                            click.echo(f"  {i + 1}. {context}{marker}")
+
+                        click.echo("")
+                        default_index = (
+                            available_contexts.index(current_context) + 1
+                            if current_context in available_contexts
+                            else 1
+                        )
 
-                                # Append the Route 53 record to the Terraform file
-                                with open(tf_path, "a") as f:
-                                    f.write(route53_record.lstrip())
+                        selected_index = click.prompt(
+                            "Select kubectl context number to apply configuration",
+                            type=click.IntRange(1, len(available_contexts)),
+                            default=default_index,
+                        )
 
-                                click.echo("Added Route 53 record to Terraform configuration")
-                            else:
-                                # Update the existing Route 53 record
-                                updated_tf = tf_content.replace(
-                                    'records = ["LOAD_BALANCER_DNS_PLACEHOLDER"]', f'records = ["{external_ip}"]'
-                                )
+                        selected_context = available_contexts[selected_index - 1]
+                        click.echo(f"Selected context: {selected_context}")
 
-                                # Also handle case where there might be another placeholder or old value
-                                import re
+                    # Apply the configuration to the selected context
+                    click.echo(f"Applying Kubernetes configuration to context '{selected_context}'...")
+                    apply_result = subprocess.run(
+                        ["kubectl", "--context", selected_context, "apply", "-f", str(yaml_path)],
+                        capture_output=True,
+                        text=True,
+                    )
 
-                                pattern = r'records\s*=\s*\[\s*"[^"]*"\s*\]'
-                                updated_tf = re.sub(pattern, f'records = ["{external_ip}"]', updated_tf)
+                    if apply_result.returncode != 0:
+                        click.echo("Failed to apply Kubernetes configuration:")
+                        click.echo(apply_result.stderr)
+                    else:
+                        click.echo("Kubernetes configuration applied successfully:")
+                        click.echo(apply_result.stdout)
+
+                        # Get the namespace from the applied configuration
+                        namespace = None
+                        with open(yaml_path, "r") as f:
+                            for line in f:
+                                if "namespace:" in line and not namespace:
+                                    namespace = line.split("namespace:")[1].strip()
+                                    break
+
+                        if not namespace:
+                            namespace = "tinybird"  # Default namespace
+
+                        click.echo(f"\nWaiting for load balancer to be provisioned in namespace '{namespace}'...")
+
+                        # Wait for the load balancer to get an external IP
+                        max_attempts = 30
+                        attempt = 0
+                        external_ip = None
+
+                        while attempt < max_attempts and not external_ip:
+                            attempt += 1
+
+                            # Get the service details
+                            get_service_result = subprocess.run(
+                                [
+                                    "kubectl",
+                                    "--context",
+                                    selected_context,
+                                    "-n",
+                                    namespace,
+                                    "get",
+                                    "service",
+                                    "tinybird",
+                                    "-o",
+                                    "jsonpath='{.status.loadBalancer.ingress[0].hostname}'",
+                                ],
+                                capture_output=True,
+                                text=True,
+                            )
+
+                            if get_service_result.returncode == 0:
+                                potential_ip = get_service_result.stdout.strip().replace("'", "")
+                                if potential_ip and potential_ip != "":
+                                    external_ip = potential_ip
+                                    break
+
+                            click.echo(
+                                f"Attempt {attempt}/{max_attempts}: Load balancer not ready yet, waiting 10 seconds..."
+                            )
+                            import time
+
+                            time.sleep(10)
+
+                        if external_ip:
+                            click.echo("\nLoad balancer provisioned successfully.")
+
+                            # Update the Terraform configuration with the load balancer DNS
+                            if not skip_dns and domain and tf_path.exists():
+                                click.echo("\nUpdating Terraform configuration with load balancer DNS...")
+
+                                with open(tf_path, "r") as f:
+                                    tf_content = f.read()
+
+                                # Check if the Route 53 record already exists in the file
+                                if 'resource "aws_route53_record" "tinybird"' not in tf_content:
+                                    # Create the full DNS name
+                                    full_dns_name = f"{dns_record}.{domain}"
+
+                                    # Use in the Terraform template
+                                    route53_record = TERRAFORM_SECOND_TEMPLATE % {
+                                        "external_ip": external_ip,
+                                        "full_dns_name": full_dns_name,
+                                    }
+
+                                    # Append the Route 53 record to the Terraform file
+                                    with open(tf_path, "a") as f:
+                                        f.write(route53_record.lstrip())
+
+                                    click.echo("Added Route 53 record to Terraform configuration")
+                                else:
+                                    # Update the existing Route 53 record
+                                    updated_tf = tf_content.replace(
+                                        'records = ["LOAD_BALANCER_DNS_PLACEHOLDER"]', f'records = ["{external_ip}"]'
+                                    )
+
+                                    # Also handle case where there might be another placeholder or old value
+                                    import re
+
+                                    pattern = r'records\s*=\s*\[\s*"[^"]*"\s*\]'
+                                    updated_tf = re.sub(pattern, f'records = ["{external_ip}"]', updated_tf)
 
-                                with open(tf_path, "w") as f:
-                                    f.write(updated_tf.lstrip())
+                                    with open(tf_path, "w") as f:
+                                        f.write(updated_tf.lstrip())
 
-                                click.echo("Updated existing Route 53 record in Terraform configuration")
+                                    click.echo("Updated existing Route 53 record in Terraform configuration")
 
-                            # Apply the updated Terraform configuration
-                            if not skip_dns and (
-                                auto_apply_dns
-                                or click.confirm("Would you like to create the DNS record in Route 53 now?")
-                            ):
-                                click.echo("Applying updated Terraform configuration...")
-                                apply_result = subprocess.run(
-                                    ["terraform", "-chdir=infra", "apply", "-auto-approve"],
-                                    capture_output=True,
-                                    text=True,
+                                # Run terraform plan for DNS changes
+                                click.echo("\nRunning Terraform plan for DNS changes...\n")
+                                plan_result = subprocess.run(
+                                    ["terraform", "-chdir=infra", "plan"], capture_output=True, text=True
                                 )
 
-                                if apply_result.returncode != 0:
-                                    click.echo("Failed to create DNS record:")
-                                    click.echo(apply_result.stderr)
+                                if plan_result.returncode != 0:
+                                    click.echo("Terraform plan for DNS changes failed:")
+                                    click.echo(plan_result.stderr)
                                 else:
-                                    click.echo(apply_result.stdout)
-                                    click.echo("DNS record created successfully!")
-
-                                    # Get the DNS name from Terraform output
-                                    dns_output = subprocess.run(
-                                        ["terraform", "-chdir=infra", "output", "tinybird_dns"],
-                                        capture_output=True,
-                                        text=True,
-                                    )
-
-                                    if dns_output.returncode == 0:
-                                        dns_name = dns_output.stdout.strip().replace('"', "")
-                                        click.echo("\nDNS record created successfully!")
-                                        click.echo(
-                                            "\nWaiting up to 5 minutes for HTTPS endpoint to become available..."
+                                    click.echo(plan_result.stdout)
+
+                                    # Apply the updated Terraform configuration
+                                    if not skip_dns and (
+                                        auto_apply_dns
+                                        or click.confirm("Would you like to create the DNS record in Route 53 now?")
+                                    ):
+                                        click.echo("Applying updated Terraform configuration...")
+                                        apply_result = subprocess.run(
+                                            ["terraform", "-chdir=infra", "apply", "-auto-approve"],
+                                            capture_output=True,
+                                            text=True,
                                         )
 
-                                        import time
-
-                                        import requests
+                                        if apply_result.returncode != 0:
+                                            click.echo("Failed to create DNS record:")
+                                            click.echo(apply_result.stderr)
+                                        else:
+                                            click.echo(apply_result.stdout)
+                                            click.echo("DNS record created successfully!")
+
+                                            # Get the DNS name from Terraform output
+                                            dns_output = subprocess.run(
+                                                ["terraform", "-chdir=infra", "output", "tinybird_dns"],
+                                                capture_output=True,
+                                                text=True,
+                                            )
+
+                                            if dns_output.returncode == 0:
+                                                dns_name = dns_output.stdout.strip().replace('"', "")
+                                                click.echo("\nDNS record created successfully!")
+                                                click.echo(
+                                                    "\nWaiting up to 5 minutes for HTTPS endpoint to become available..."
+                                                )
 
-                                        max_attempts = 30  # 30 attempts * 10 seconds = 5 minutes
-                                        attempt = 0
-                                        while attempt < max_attempts:
-                                            attempt += 1
-                                            try:
-                                                response = requests.get(
-                                                    f"https://{dns_name}", allow_redirects=False, timeout=5
+                                                import time
+
+                                                import requests
+
+                                                max_attempts = 30  # 30 attempts * 10 seconds = 5 minutes
+                                                attempt = 0
+                                                while attempt < max_attempts:
+                                                    attempt += 1
+                                                    try:
+                                                        response = requests.get(
+                                                            f"https://{dns_name}", allow_redirects=False, timeout=5
+                                                        )
+                                                        response.raise_for_status()
+                                                        click.echo("\n✅ HTTPS endpoint is now accessible!")
+                                                        break
+                                                    except requests.RequestException:
+                                                        if attempt == max_attempts:
+                                                            click.echo(
+                                                                "\n⚠️  HTTPS endpoint not accessible after 5 minutes"
+                                                            )
+                                                            click.echo(
+                                                                "  This might be due to DNS propagation or the Load Balancer provisioning delays"
+                                                            )
+                                                            click.echo(
+                                                                "  Please try accessing the URL manually in a few minutes"
+                                                            )
+                                                        else:
+                                                            click.echo(
+                                                                f"Attempt {attempt}/{max_attempts}: Not ready yet, waiting 10 seconds..."
+                                                            )
+                                                            time.sleep(10)
+                                            else:
+                                                click.echo(
+                                                    f"\nYour Tinybird instance should be available at: https://tinybird.{domain}"
                                                 )
-                                                response.raise_for_status()
-                                                click.echo("\n✅ HTTPS endpoint is now accessible!")
-                                                break
-                                            except requests.RequestException:
-                                                if attempt == max_attempts:
-                                                    click.echo("\n⚠️  HTTPS endpoint not accessible after 5 minutes")
-                                                    click.echo(
-                                                        "  This might be due to DNS propagation or the Load Balancer provisioning delays"
-                                                    )
-                                                    click.echo(
-                                                        "  Please try accessing the URL manually in a few minutes"
-                                                    )
-                                                else:
-                                                    click.echo(
-                                                        f"Attempt {attempt}/{max_attempts}: Not ready yet, waiting 10 seconds..."
-                                                    )
-                                                    time.sleep(10)
-                                    else:
-                                        click.echo(
-                                            f"\nYour Tinybird instance should be available at: https://tinybird.{domain}"
-                                        )
+
+    # Print a summary with the endpoint URL
+    click.echo("\n" + "=" * 60)
+    click.echo("DEPLOYMENT SUMMARY".center(60))
+    click.echo("=" * 60)
+
+    if not skip_kubectl and external_ip:
+        click.echo(f"✅ Load balancer provisioned: {external_ip}")
+
+    if not skip_dns and not skip_terraform and domain:
+        # Try to get the DNS name from Terraform output
+        dns_output = subprocess.run(
+            ["terraform", "-chdir=infra", "output", "tinybird_dns"], capture_output=True, text=True
+        )
+
+        if dns_output.returncode == 0:
+            dns_name = dns_output.stdout.strip().replace('"', "")
+            click.echo(f"✅ DNS record created: {dns_name}")
+            click.echo(f"\n🔗 Tinybird is available at: https://{dns_name}")
+        else:
+            # Fallback to constructed DNS name
+            full_dns_name = f"{dns_record}.{domain}"
+            click.echo(f"✅ DNS record created: {full_dns_name}")
+            click.echo(f"\n🔗 Tinybird is available at: https://{full_dns_name}")
+    elif not skip_kubectl and external_ip:
+        click.echo(f"\n🔗 Tinybird is available at: https://{external_ip}")
+        if domain:
+            click.echo(f"\n📝 Consider creating a DNS record: {dns_record}.{domain} → {external_ip}")
+
+    click.echo(
+        "\n📌 Note: It may take a few minutes for DNS to propagate and the HTTPS certificate to be fully provisioned."
+    )
+    click.echo("=" * 60)
+
+
+@infra.command(name="rm")
+@click.argument("name")
+@click.pass_context
+@coro
+async def infra_rm(ctx: click.Context, name: str):
+    """Delete an infrastructure from Tinybird"""
+    try:
+        click.echo(FeedbackManager.highlight(message=f"\n» Deleting infrastructure '{name}' from Tinybird..."))
+        client: TinyB = ctx.ensure_object(dict)["client"]
+        user_workspaces = await client.user_workspaces_with_organization()
+        admin_org_id = user_workspaces.get("organization_id")
+        if not admin_org_id:
+            raise CLIException("No organization associated to this workspace")
+        infras = await client.infra_list(admin_org_id)
+        infra_id = next((infra["id"] for infra in infras if infra["name"] == name), None)
+        if not infra_id:
+            raise CLIException(f"Infrastructure '{name}' not found")
+        await client.infra_delete(infra_id, admin_org_id)
+        click.echo(FeedbackManager.success(message=f"\n✓ Infrastructure '{name}' deleted"))
+    except Exception as e:
+        click.echo(FeedbackManager.error(message=f"✗ Error: {e}"))
+
+
+@infra.command(name="ls")
+@click.pass_context
+@coro
+async def infra_ls(ctx: click.Context):
+    """List self-managed infrastructures"""
+
+    client: TinyB = ctx.ensure_object(dict)["client"]
+    config = CLIConfig.get_project_config()
+    user_client = config.get_client(token=config.get_user_token() or "")
+    user_workspaces = await user_client.user_workspaces_with_organization()
+    admin_org_id = user_workspaces.get("organization_id")
+    infras = await client.infra_list(organization_id=admin_org_id)
+    columns = [
+        "name",
+        "host",
+    ]
+    table_human_readable = []
+    table_machine_readable = []
+
+    for infra in infras:
+        name = infra["name"]
+        host = infra["host"]
+
+        table_human_readable.append((name, host))
+        table_machine_readable.append({"name": name, "host": host})
+
+    click.echo(FeedbackManager.info(message="\n** Infras:"))
+    echo_safe_humanfriendly_tables_format_smart_table(table_human_readable, column_names=columns)
+    click.echo("\n")

tinybird/tb/modules/local_common.py

@@ -49,7 +49,7 @@ async def get_tinybird_local_config(config_obj: Dict[str, Any], build: bool = Fa
         logging.debug(f"Workspace used for build: {ws_name}")
 
         user_workspaces = requests.get(
-            f"{TB_LOCAL_HOST}/v0/user/workspaces?with_organization=true&token={admin_token}"
+            f"{TB_LOCAL_HOST}/v1/user/workspaces?with_organization=true&token={admin_token}"
         ).json()
         user_org_id = user_workspaces.get("organization_id", {})
         local_workspaces = user_workspaces.get("workspaces", [])
@@ -57,8 +57,10 @@ async def get_tinybird_local_config(config_obj: Dict[str, Any], build: bool = Fa
         ws = next((ws for ws in local_workspaces if ws["name"] == ws_name), None)
 
         if not ws:
-            await user_client.create_workspace(ws_name, template=None, assign_to_organization_id=user_org_id)
-            user_workspaces = requests.get(f"{TB_LOCAL_HOST}/v0/user/workspaces?token={admin_token}").json()
+            await user_client.create_workspace(
+                ws_name, template=None, assign_to_organization_id=user_org_id, version="v1"
+            )
+            user_workspaces = requests.get(f"{TB_LOCAL_HOST}/v1/user/workspaces?token={admin_token}").json()
             ws = next((ws for ws in user_workspaces["workspaces"] if ws["name"] == ws_name), None)
             if not ws:
                 raise AuthNoTokenException()

tinybird/tb/modules/login.py

@@ -43,10 +43,12 @@ class AuthHandler(http.server.SimpleHTTPRequestHandler):
                 const searchParams = new URLSearchParams(window.location.search);
                 const code = searchParams.get('code');
                 const workspace = searchParams.get('workspace');
+                const region = searchParams.get('region');
+                const provider = searchParams.get('provider');
                 const host = "{auth_host}";
                 fetch('/?code=' + code, {{method: 'POST'}})
                     .then(() => {{
-                        window.location.href = host + "/cli-login?workspace=" + workspace;
+                        window.location.href = host + "/" + provider + "/" + region + "/cli-login?workspace=" + workspace;
                     }});
             </script>
         </body>
@@ -114,9 +116,6 @@ async def login(host: str, auth_host: str, workspace: str):
     auth_event = threading.Event()
     auth_code: list[str] = []  # Using a list to store the code, as it's mutable
 
-    if auth_host == "https://cloud.tinybird.co" and "wadus" in host:
-        auth_host = "https://cloud-wadus.tinybird.co"
-
     def auth_callback(code):
         auth_code.append(code)
         auth_event.set()
@@ -132,6 +131,7 @@ async def login(host: str, auth_host: str, workspace: str):
     callback_url = f"http://localhost:{AUTH_SERVER_PORT}"
     params = {
         "redirect_uri": callback_url,
+        "apiHost": host,
     }
 
     if workspace:
@@ -147,15 +147,14 @@ async def login(host: str, auth_host: str, workspace: str):
         response = requests.get(  # noqa: ASYNC210
             f"{auth_host}/api/cli-login?{urlencode(params)}",
         )
-
         data = response.json()
         cli_config = CLIConfig.get_project_config()
         cli_config.set_token(data.get("workspace_token", ""))
         cli_config.set_token_for_host(data.get("workspace_token", ""), host)
         cli_config.set_user_token(data.get("user_token", ""))
-        cli_config.set_host(host)
+        cli_config.set_host(host or data.get("api_host", ""))
 
-        ws = await cli_config.get_client(token=data.get("workspace_token", "")).workspace_info()
+        ws = await cli_config.get_client(token=data.get("workspace_token", ""), host=host).workspace_info(version="v1")
         for k in ("id", "name", "user_email", "user_id", "scope"):
             if k in ws:
                 cli_config[k] = ws[k]

tinybird/tb/modules/workspace.py

@@ -47,7 +47,7 @@ async def workspace_ls(ctx: Context) -> None:
     config = CLIConfig.get_project_config()
     client: TinyB = ctx.ensure_object(dict)["client"]
 
-    response = await client.user_workspaces()
+    response = await client.user_workspaces(version="v1")
 
     current_main_workspace = await get_current_main_workspace(config)
     if not current_main_workspace:
@@ -184,7 +184,7 @@ async def delete_workspace(
 
     user_token = await get_user_token(config, user_token)
 
-    workspaces = (await client.user_workspaces()).get("workspaces", [])
+    workspaces = (await client.user_workspaces(version="v1")).get("workspaces", [])
     workspace_to_delete = next(
         (
             workspace

{tinybird-0.0.1.dev97.dist-info → tinybird-0.0.1.dev98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev97
+Version: 0.0.1.dev98
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird

{tinybird-0.0.1.dev97.dist-info → tinybird-0.0.1.dev98.dist-info}/RECORD

@@ -1,5 +1,5 @@
 tinybird/__cli__.py,sha256=esPl5QDTzuQgHe5FuxWLm-fURFigGGwjnYLh9GuWUw4,232
-tinybird/client.py,sha256=B6FaylxfcalxJTjiMgaS1Iyn9aBRsDaphwhC5VKeK6M,54179
+tinybird/client.py,sha256=GeWkyx6kLSVIBxmSg4k4pCzz_jYZMW0SdbSvhjvHvs0,55059
 tinybird/config.py,sha256=5UP_UZ2Qtlm5aOH5W7SbtN8r7X-8u3-r853joKqU5zs,6072
 tinybird/connectors.py,sha256=7Gjms7b5MAaBFGi3xytsJurCylprONpFcYrzp4Fw2Rc,15241
 tinybird/context.py,sha256=FfqYfrGX_I7PKGTQo93utaKPDNVYWelg4Hsp3evX5wM,1291
@@ -15,14 +15,14 @@ tinybird/syncasync.py,sha256=IPnOx6lMbf9SNddN1eBtssg8vCLHMt76SuZ6YNYm-Yk,27761
 tinybird/tornado_template.py,sha256=jjNVDMnkYFWXflmT8KU_Ssbo5vR8KQq3EJMk5vYgXRw,41959
 tinybird/ch_utils/constants.py,sha256=aYvg2C_WxYWsnqPdZB1ZFoIr8ZY-XjUXYyHKE9Ansj0,3890
 tinybird/ch_utils/engine.py,sha256=BZuPM7MFS7vaEKK5tOMR2bwSAgJudPrJt27uVEwZmTY,40512
-tinybird/tb/__cli__.py,sha256=KVP7US6Bpei_ANpSVqmgz52rKQ0r3TIK097B6JHXYYU,251
+tinybird/tb/__cli__.py,sha256=KrzvGHoHoPrkwZ1uV5MMRrnjT-DSbzgO2X8_c_LNVJI,251
 tinybird/tb/cli.py,sha256=H_HaZhkimKgkryYXpBjHfY9Qtg-ZORiONU3psDNpzDk,1135
 tinybird/tb/modules/auth.py,sha256=L1IatO2arRSzys3t8px8xVt8uPWUL5EVD0sFzAV_uVU,9022
 tinybird/tb/modules/build.py,sha256=h5drdmDFX8NHts9dA2Zepao7KSgMAl3DZGyFufVZP78,11085
 tinybird/tb/modules/cicd.py,sha256=ldjswh70j0lQpReZGb6YbOcSIVYhrMUQFdJTfAfownU,5671
-tinybird/tb/modules/cli.py,sha256=j6j9CKx4YnsRTLYdE47K8ilkoj-Xf9lq7Wm2LVgQ6Lc,17888
-tinybird/tb/modules/common.py,sha256=EU33c_HKU8yCrj4qfbDTHFZwHEpzZ5vBmZcPxqT15DQ,81307
-tinybird/tb/modules/config.py,sha256=BVZg-4f_R3vJTwCChXY2AXaH67SRk62xoP_IymquosI,11404
+tinybird/tb/modules/cli.py,sha256=9VrTDe6HlarG8h6wn_u7PgaRTCMZ4Hi_qiE3U2KHo2k,17912
+tinybird/tb/modules/common.py,sha256=QhSPoLKz3J892z3qi0BBEOxLKmBU6f0MK7pmKIFIkVk,81427
+tinybird/tb/modules/config.py,sha256=FqdLpLaKpYubqw3xkB4EX06ufZYDgGRxONR_9i-y-KE,11416
 tinybird/tb/modules/connection.py,sha256=WKeDxbTpSsQ1PUmsT730g3S5RT2PtR5mPpVEanD1nbM,3933
 tinybird/tb/modules/copy.py,sha256=MAVqKip8_QhOYq99U_XuqSO6hCLJEh5sFtbhcXtI3SI,5802
 tinybird/tb/modules/create.py,sha256=VvY5C0GNM_j3ZPK4ba8yq3cephJ356PaAsBWR-zoPXs,14054
@@ -32,13 +32,13 @@ tinybird/tb/modules/endpoint.py,sha256=EhVoGAXsFz-83Fiwj1gI-I73iRRvL49d0W81un7hv
 tinybird/tb/modules/exceptions.py,sha256=4A2sSjCEqKUMqpP3WI00zouCWW4uLaghXXLZBSw04mY,3363
 tinybird/tb/modules/feedback_manager.py,sha256=7nNiOx7OMebiheLED1r0d75SbuXCNxyBmF4e20rCBNc,69511
 tinybird/tb/modules/fmt.py,sha256=qpf9APqKTKL2uphNgdbj4OMVyLkAxZn6dn4eHF99L5g,3553
-tinybird/tb/modules/infra.py,sha256=TeeCcJQ_9fm_sDfZnZ8E2UaEOKaBzRHGm5KMKL01O48,20375
+tinybird/tb/modules/infra.py,sha256=dJcPYN_hpcLpygl4IcAANeP7fUgziwMGqYadWd9IT5g,29105
 tinybird/tb/modules/job.py,sha256=956Pj8BEEsiD2GZsV9RKKVM3I_CveOLgS82lykO5ukk,2963
 tinybird/tb/modules/llm.py,sha256=AC0VSphTOM2t-v1_3NLvNN_FIbgMo4dTyMqIv5nniPo,835
 tinybird/tb/modules/llm_utils.py,sha256=nS9r4FAElJw8yXtmdYrx-rtI2zXR8qXfi1QqUDCfxvg,3469
 tinybird/tb/modules/local.py,sha256=revEEYP-Oq5nqURgmZmc0kt1_tEjM31dyUtcH5YbOuc,5842
-tinybird/tb/modules/local_common.py,sha256=Uty8vhn4FxRASqcMldpbadKcDiOeLx4PK01Nk_SbAsY,3144
-tinybird/tb/modules/login.py,sha256=NB-evr7b00ChKPulX7c8YLN3EX6cr0CwALN0wroAq3o,6147
+tinybird/tb/modules/local_common.py,sha256=RN5OEncHdq7ua4AZ--WgKtaFuEsLvIhq_ROHJadRXXA,3188
+tinybird/tb/modules/login.py,sha256=CF6OjTuXvnD5WMpouEvSyEaMf0XTe0VE0s_y3QtyImg,6252
 tinybird/tb/modules/logout.py,sha256=ULooy1cDBD02-r7voZmhV7udA0ML5tVuflJyShrh56Y,1022
 tinybird/tb/modules/materialization.py,sha256=r8Q9HXcYEmfrEzP4WpiasCKDJdSkTPaAKJtZMoJKhi8,5749
 tinybird/tb/modules/mock.py,sha256=9VKlp2bO2NsRgqF03SrFv_8OvAoHeRcOU89TiBRFfqY,3891
@@ -55,12 +55,12 @@ tinybird/tb/modules/telemetry.py,sha256=Hh2Io8ZPROSunbOLuMvuIFU4TqwWPmQTqal4WS09
 tinybird/tb/modules/test.py,sha256=FUU-drY8mdjNoKsw16O5ZqvYvZqzycrZBEpSwbhGDUE,11456
 tinybird/tb/modules/token.py,sha256=OhqLFpCHVfYeBCxJ0n7n2qoho9E9eGcUfHgL7R1MUVQ,13485
 tinybird/tb/modules/watch.py,sha256=poNJOUNDESDNn80H2dHvE6X6pIu-t9MZFi59_TxVN2U,8822
-tinybird/tb/modules/workspace.py,sha256=SYkEULv_Gg8FhnAnZspengzyT5N4w0wjsvWWZ3vy3Ho,7753
+tinybird/tb/modules/workspace.py,sha256=QAUihOnzao-Nyk2QM2Rhopp4oTwNh7vlKt0a52avg_E,7777
 tinybird/tb/modules/workspace_members.py,sha256=Vb5XEaKmkfONyfg2MS5EcpwolMvv7GLwFS5m2EuobT8,8726
-tinybird/tb/modules/datafile/build.py,sha256=seGFSvmgyRrAM1-icsKBkuog3WccfGUYFTPT-xoA5W8,50940
+tinybird/tb/modules/datafile/build.py,sha256=jhfIJ2xt0N13XsLPe3iMQIyCPApHS13_Df2LfISYtT8,50952
 tinybird/tb/modules/datafile/build_common.py,sha256=rT7VJ5mnQ68R_8US91DAtkusfvjWuG_NObOzNgtN_ko,4562
-tinybird/tb/modules/datafile/build_datasource.py,sha256=VjxaKKLZhPYt3XHOyMmfoqEAWAPI5D78T-8FOaN77MY,17355
-tinybird/tb/modules/datafile/build_pipe.py,sha256=Tf49kZmXub45qGcePFfqGO7p-FH5eYM46DtVI3AQJEc,11358
+tinybird/tb/modules/datafile/build_datasource.py,sha256=CCU3eQ8Rax9RgHHfbAXDRL6rQ49N35h_GDQnGrUUUzA,17379
+tinybird/tb/modules/datafile/build_pipe.py,sha256=w-Wd08gZYAEcak9FdBijVfIU2_Wn_PPdgAZddPpoGTo,11382
 tinybird/tb/modules/datafile/common.py,sha256=i9Gvhz3JiR58MRBcYZDwqTqamQOj-46TnHU8Hm8bqmg,81399
 tinybird/tb/modules/datafile/diff.py,sha256=-0J7PsBO64T7LOZSkZ4ZFHHCPvT7cKItnJkbz2PkndU,6754
 tinybird/tb/modules/datafile/exceptions.py,sha256=8rw2umdZjtby85QbuRKFO5ETz_eRHwUY5l7eHsy1wnI,556
@@ -71,7 +71,7 @@ tinybird/tb/modules/datafile/format_pipe.py,sha256=58iSTrJ5lg-IsbpX8TQumQTuZ6UIo
 tinybird/tb/modules/datafile/parse_datasource.py,sha256=BNof0FnaIVZUG5ORFtZSw-gUmWID4o2ZQLVgfVIuHRI,1566
 tinybird/tb/modules/datafile/parse_pipe.py,sha256=tBjh3-I0iq7JdtB84RPYFrUlUOF2ZYWgQ_mwW5SPgmI,3467
 tinybird/tb/modules/datafile/pipe_checker.py,sha256=LnDLGIHLJ3N7qHb2ptEbPr8CoczNfGwpjOY8EMdxfHQ,24649
-tinybird/tb/modules/datafile/playground.py,sha256=mVQNSLCXpBhupI3iJqRDdE7BJtkr8JjVhHxav3pYV2E,56533
+tinybird/tb/modules/datafile/playground.py,sha256=7yblQh3jlNfdY0ySSCBrXTK6mE9e0TFI-TbaGGV-qBE,56545
 tinybird/tb/modules/datafile/pull.py,sha256=vcjMUbjnZ9XQMGmL33J3ElpbXBTat8Yzp-haeDggZd4,5967
 tinybird/tb/modules/tinyunit/tinyunit.py,sha256=GlDgEXc6TDO3ODxgfATAL2fvbKy-b_CzqoeDrApRm0g,11715
 tinybird/tb/modules/tinyunit/tinyunit_lib.py,sha256=hGh1ZaXC1af7rKnX7222urkj0QJMhMWclqMy59dOqwE,1922
@@ -81,8 +81,8 @@ tinybird/tb_cli_modules/config.py,sha256=IsgdtFRnUrkY8-Zo32lmk6O7u3bHie1QCxLwgp4
 tinybird/tb_cli_modules/exceptions.py,sha256=pmucP4kTF4irIt7dXiG-FcnI-o3mvDusPmch1L8RCWk,3367
 tinybird/tb_cli_modules/regions.py,sha256=QjsL5H6Kg-qr0aYVLrvb1STeJ5Sx_sjvbOYO0LrEGMk,166
 tinybird/tb_cli_modules/telemetry.py,sha256=Hh2Io8ZPROSunbOLuMvuIFU4TqwWPmQTqal4WS09K1A,10449
-tinybird-0.0.1.dev97.dist-info/METADATA,sha256=X_CuA20-AXiKabm9zZMTQ4AeKz-WZh_2oX_swM7gFck,2585
-tinybird-0.0.1.dev97.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-tinybird-0.0.1.dev97.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
-tinybird-0.0.1.dev97.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
-tinybird-0.0.1.dev97.dist-info/RECORD,,
+tinybird-0.0.1.dev98.dist-info/METADATA,sha256=FgjtduxdgJ497kEb9unG91uWspOt1H0qdXCnnjExEms,2585
+tinybird-0.0.1.dev98.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tinybird-0.0.1.dev98.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
+tinybird-0.0.1.dev98.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
+tinybird-0.0.1.dev98.dist-info/RECORD,,