tinybird 4.6.6.dev0__tar.gz → 4.6.7.dev0__tar.gz

{tinybird-4.6.6.dev0 → tinybird-4.6.7.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 4.6.6.dev0
+Version: 4.6.7.dev0
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird
@@ -52,6 +52,13 @@ The Tinybird command-line tool allows you to use all the Tinybird functionality
 Changelog
 ----------
 
+4.6.6
+*******
+
+- `Fixed` `tb local` now starts the Tinybird Local container using the host's native architecture (``linux/arm64`` on Apple Silicon, ``linux/amd64`` elsewhere) instead of always forcing ``linux/amd64``, so it no longer runs under emulation on arm64 machines.
+- `Added` ``TB_LOCAL_IMAGE_PLATFORM`` environment variable to override the auto-detected image platform (e.g. ``linux/amd64`` to run the amd64 image emulated on an arm64 host, or to run a locally built single-arch image that does not match the host).
+- `Fixed` `tb local start` new-version detection now normalizes Docker Hub image digests and no longer pulls when the registry is unreachable.
+
 4.6.5
 *******
 

{tinybird-4.6.6.dev0 → tinybird-4.6.7.dev0}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/forward/commands'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '4.6.6.dev0'
-__revision__ = '939e465'
+__version__ = '4.6.7.dev0'
+__revision__ = 'd3cbd87'

{tinybird-4.6.6.dev0 → tinybird-4.6.7.dev0}/tinybird/tb/modules/build.py

@@ -1,22 +1,15 @@
-from copy import deepcopy
 from functools import partial
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
-from urllib.parse import urlencode
+from typing import Any, Callable, Dict, Optional
 
 import click
 
-from tinybird.datafile.exceptions import ParseException
-from tinybird.datafile.parse_datasource import parse_datasource
-from tinybird.datafile.parse_pipe import parse_pipe
 from tinybird.tb.client import TinyB
 from tinybird.tb.config import CLOUD_HOSTS
 from tinybird.tb.modules.build_common import process
 from tinybird.tb.modules.cli import cli, get_current_git_branch
-from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.project import Project
-from tinybird.tb.modules.query_output import print_table_formatted
 from tinybird.tb.modules.watch import watch_project
 
 
@@ -182,41 +175,3 @@ def is_endpoint(f: Path) -> bool:
 
 def is_pipe(f: Path) -> bool:
     return f.suffix == ".pipe" and not is_vendor(f)
-
-
-def check_filenames(filenames: List[str]):
-    parser_matrix = {".pipe": parse_pipe, ".datasource": parse_datasource}
-    incl_suffix = ".incl"
-
-    for filename in filenames:
-        file_suffix = Path(filename).suffix
-        if file_suffix == incl_suffix:
-            continue
-
-        parser = parser_matrix.get(file_suffix)
-        if not parser:
-            raise ParseException(FeedbackManager.error_unsupported_datafile(extension=file_suffix))
-
-        parser(filename)
-
-
-def build_and_print_resource(config: CLIConfig, tb_client: TinyB, filename: str):
-    resource_path = Path(filename)
-    name = resource_path.stem
-    playground_name = name if filename.endswith(".pipe") else None
-    user_client = deepcopy(tb_client)
-    user_client.token = config.get_user_token() or ""
-    cli_params = {}
-    cli_params["workspace_id"] = config.get("id", None)
-    data = user_client._req(f"/v0/playgrounds?{urlencode(cli_params)}")
-    playgrounds = data["playgrounds"]
-    playground = next((p for p in playgrounds if p["name"] == (f"{playground_name}" + "__tb__playground")), None)
-    if not playground:
-        return
-    playground_id = playground["id"]
-    last_node = playground["nodes"][-1]
-    if not last_node:
-        return
-    node_sql = last_node["sql"]
-    res = tb_client.query(f"{node_sql} FORMAT JSON", playground=playground_id)
-    print_table_formatted(res, name)

{tinybird-4.6.6.dev0 → tinybird-4.6.7.dev0}/tinybird/tb/modules/config.py

@@ -197,9 +197,6 @@ class CLIConfig:
         netloc: str = url_info.netloc.decode() if isinstance(url_info.netloc, bytes) else url_info.netloc
         self["host"] = f"{scheme}://{netloc}"
 
-    def set_cwd(self, cwd: str) -> None:
-        self["cwd"] = cwd
-
     def get_host(self, use_defaults_if_needed: bool = False) -> Optional[str]:
         result: Optional[str] = self.get("host", None)
         if result:

{tinybird-4.6.6.dev0 → tinybird-4.6.7.dev0}/tinybird/tb/modules/datafile/playground.py

@@ -9,7 +9,6 @@ from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
 
 import click
-from toposort import toposort
 
 from tinybird.datafile.common import (
     DEFAULT_CRON_PERIOD,
@@ -27,7 +26,7 @@ from tinybird.datafile.common import (
     get_project_filenames,
     pp,
 )
-from tinybird.datafile.exceptions import AlreadyExistsException, IncludeFileNotFoundException
+from tinybird.datafile.exceptions import IncludeFileNotFoundException
 from tinybird.datafile.parse_datasource import parse_datasource
 from tinybird.datafile.parse_pipe import parse_pipe
 from tinybird.sql import parse_table_structure, schema_to_sql_columns
@@ -35,339 +34,12 @@ from tinybird.sql_template import get_used_tables_in_template, render_sql_templa
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.common import get_ca_pem_content
 from tinybird.tb.modules.config import CLIConfig
-from tinybird.tb.modules.datafile.build_datasource import is_datasource
 from tinybird.tb.modules.datafile.build_pipe import (
     get_target_materialized_data_source_name,
-    is_endpoint,
     is_endpoint_with_no_dependencies,
-    is_materialized,
     new_pipe,
 )
 from tinybird.tb.modules.feedback_manager import FeedbackManager, get_cli_name
-from tinybird.tb.modules.project import Project
-
-
-def folder_playground(
-    project: Project,
-    config: CLIConfig,
-    tb_client: TinyB,
-    filenames: Optional[List[str]] = None,
-    is_internal: bool = False,
-    current_ws: Optional[Dict[str, Any]] = None,
-    local_ws: Optional[Dict[str, Any]] = None,
-):
-    build = True
-    dry_run = False
-    force = True
-    only_changes = True
-    debug = False
-    run_tests = False
-    verbose = False
-    raise_on_exists = False
-    fork_downstream = True
-    fork = False
-    release_created = False
-    folder = str(project.path)
-    datasources: List[Dict[str, Any]] = tb_client.datasources()
-    pipes: List[Dict[str, Any]] = tb_client.pipes(dependencies=True)
-    build = True
-    dry_run = False
-    force = True
-    only_changes = True
-    debug = False
-    check = True
-    populate = False
-    populate_subset = None
-    populate_condition = None
-    tests_to_run = 0
-    override_datasource = False
-    skip_confirmation = True
-    wait = False
-    unlink_on_populate_error = False
-    only_response_times = False
-    run_tests = False
-    verbose = False
-    as_standard = False
-    raise_on_exists = False
-    fork_downstream = True
-    fork = False
-    release_created = False
-    tests_relative_change = 0.01
-    tests_sample_by_params = 0
-    tests_filter_by = None
-    tests_failfast = False
-    tests_ignore_order = False
-    tests_validate_processed_bytes = False
-    tests_check_requests_from_branch = False
-    user_token = None
-    ignore_sql_errors = False
-    is_vendor = False
-    current_ws = current_ws or local_ws
-
-    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]
-
-    if not filenames:
-        filenames = get_project_filenames(folder)
-
-    # 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 = build_graph(
-        filenames,
-        tb_client,
-        dir_path=folder,
-        process_dependencies=True,
-        skip_connectors=True,
-        vendor_paths=[],
-        current_ws=current_ws,
-        only_changes=only_changes,
-        fork_downstream=fork_downstream,
-        is_internal=is_internal,
-        build=build,
-    )
-
-    if debug:
-        pp.pprint(dependencies_graph.to_run)
-
-    def should_push_file(
-        name: str,
-        remote_resource_names: List[str],
-        force: bool,
-        run_tests: bool,
-    ) -> bool:
-        """
-        Function to know if we need to run a file or not
-        """
-        if name not in remote_resource_names:
-            return True
-        # When we need to try to push a file when it doesn't exist and the version is different that the existing one
-        resource_full_name = name
-        if resource_full_name not in existing_resources:
-            return True
-        return force or run_tests
-
-    def push(
-        name: str,
-        to_run: Dict[str, Dict[str, Any]],
-        dry_run: bool,
-        fork_downstream: Optional[bool] = False,
-        fork: Optional[bool] = False,
-    ):
-        if name in to_run:
-            resource = to_run[name]["resource"]
-            if resource == "datasources":
-                return
-            if not dry_run:
-                if should_push_file(name, remote_resource_names, force, run_tests):
-                    click.echo(FeedbackManager.info_processing_new_resource(name=name, version=""))
-                    try:
-                        exec_file(
-                            to_run[name],
-                            config,
-                            tb_client,
-                            force,
-                            check,
-                            debug and verbose,
-                            populate,
-                            populate_subset,
-                            populate_condition,
-                            unlink_on_populate_error,
-                            wait,
-                            user_token,
-                            override_datasource,
-                            ignore_sql_errors,
-                            skip_confirmation,
-                            only_response_times,
-                            run_tests,
-                            as_standard,
-                            tests_to_run,
-                            tests_relative_change,
-                            tests_sample_by_params,
-                            tests_filter_by,
-                            tests_failfast,
-                            tests_ignore_order,
-                            tests_validate_processed_bytes,
-                            tests_check_requests_from_branch,
-                            current_ws,
-                            local_ws,
-                            fork_downstream,
-                            fork,
-                            build,
-                            is_vendor,
-                        )
-                        if not run_tests:
-                            click.echo(
-                                FeedbackManager.success_create(
-                                    name=(
-                                        name
-                                        if to_run[name]["version"] is None
-                                        else f"{name}__v{to_run[name]['version']}"
-                                    )
-                                )
-                            )
-                    except Exception as e:
-                        filename = to_run[name]["filename"]
-                        exception = FeedbackManager.error_push_file_exception(
-                            filename=filename,
-                            error=e,
-                        )
-                        raise click.ClickException(exception)
-                elif raise_on_exists:
-                    raise AlreadyExistsException(
-                        FeedbackManager.warning_name_already_exists(
-                            name=name if to_run[name]["version"] is None else f"{name}__v{to_run[name]['version']}"
-                        )
-                    )
-                elif name_matches_existing_resource(resource, name, tb_client):
-                    if resource == "pipes":
-                        click.echo(FeedbackManager.error_pipe_cannot_be_pushed(name=name))
-                    else:
-                        click.echo(FeedbackManager.error_datasource_cannot_be_pushed(name=name))
-                else:
-                    click.echo(
-                        FeedbackManager.warning_name_already_exists(
-                            name=(name if to_run[name]["version"] is None else f"{name}__v{to_run[name]['version']}")
-                        )
-                    )
-            if dry_run:
-                if should_push_file(name, remote_resource_names, force, run_tests):
-                    extension = "pipe" if resource == "pipes" else "datasource"
-                    click.echo(FeedbackManager.info_building_resource(name=f"{name}.{extension}", version=""))
-                elif name_matches_existing_resource(resource, name, tb_client):
-                    if resource == "pipes":
-                        click.echo(FeedbackManager.warning_pipe_cannot_be_pushed(name=name))
-                    else:
-                        click.echo(FeedbackManager.warning_datasource_cannot_be_pushed(name=name))
-                else:
-                    click.echo(FeedbackManager.warning_dry_name_already_exists(name=name))
-
-    def push_files(
-        dependency_graph: GraphDependencies,
-        dry_run: bool = False,
-    ):
-        endpoints_dep_map = dict()
-        processed = set()
-
-        resources_to_run = dependency_graph.to_run
-
-        # This will generate the graph from right to left and will fill the gaps of the dependencies
-        # If we have a graph like this:
-        # A -> B -> C
-        # If we only modify A, the normal dependencies graph will only contain a node like _{A => B}
-        # But we need a graph that contains A, B and C and the dependencies between them to deploy them in the right order
-        dependencies_graph_fork_downstream, resources_to_run_fork_downstream = generate_forkdownstream_graph(
-            dependency_graph.all_dep_map,
-            dependency_graph.all_resources,
-            resources_to_run,
-            list(dependency_graph.dep_map.keys()),
-        )
-
-        # First, we will deploy the datasources that need to be deployed.
-        # We need to deploy the datasources from left to right as some datasources might have MV that depend on the column types of previous datasources. Ex: `test_change_column_type_landing_datasource` test
-        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-
-        groups.reverse()
-        for group in groups:
-            for name in group:
-                if name in processed or not is_datasource(resources_to_run_fork_downstream[name]):
-                    continue
-
-                # If we are trying to modify a Kafka or CDK datasource, we need to inform the user that the resource needs to be post-released
-                kafka_connection_name = (
-                    resources_to_run_fork_downstream[name].get("params", {}).get("kafka_connection_name")
-                )
-                service = resources_to_run_fork_downstream[name].get("params", {}).get("import_service")
-                if release_created and (kafka_connection_name or service):
-                    connector = "Kafka" if kafka_connection_name else service
-                    error_msg = FeedbackManager.error_connector_require_post_release(connector=connector)
-                    raise click.ClickException(error_msg)
-
-                push(
-                    name,
-                    resources_to_run_fork_downstream,
-                    dry_run,
-                    fork_downstream,
-                    fork,
-                )
-                processed.add(name)
-
-        # Now, we will create a map of all the endpoints and there dependencies
-        # We are using the forkdownstream graph to get the dependencies of the endpoints as the normal dependencies graph only contains the resources that are going to be deployed
-        # But does not include the missing gaps
-        # If we have ENDPOINT_A ----> MV_PIPE_B -----> DATASOURCE_B ------> ENDPOINT_C
-        # Where endpoint A is being used in the MV_PIPE_B, if we only modify the endpoint A
-        # The dependencies graph will only contain the endpoint A and the MV_PIPE_B, but not the DATASOURCE_B and the ENDPOINT_C
-        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-        for group in groups:
-            for name in group:
-                if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
-                    continue
-
-                endpoints_dep_map[name] = dependencies_graph_fork_downstream[name]
-
-        # Now that we have the dependencies of the endpoints, we need to check that the resources has not been deployed yet and only care about the endpoints that depend on endpoints
-        groups = [group for group in toposort(endpoints_dep_map)]
-
-        # As we have used the forkdownstream graph to get the dependencies of the endpoints, we have all the dependencies of the endpoints
-        # But we need to deploy the endpoints and the dependencies of the endpoints from left to right
-        # So we need to reverse the groups
-        groups.reverse()
-        for group in groups:
-            for name in group:
-                if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
-                    continue
-
-                push(
-                    name,
-                    resources_to_run_fork_downstream,
-                    dry_run,
-                    fork_downstream,
-                    fork,
-                )
-                processed.add(name)
-
-        # Now we should have the endpoints and datasources deployed, we can deploy the rest of the pipes (copy & sinks)
-        # We need to rely on the forkdownstream graph as it contains all the modified pipes as well as the dependencies of the pipes
-        # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
-        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-        for group in groups:
-            for name in group:
-                if name in processed or is_materialized(resources_to_run_fork_downstream.get(name)):
-                    continue
-
-                push(
-                    name,
-                    resources_to_run_fork_downstream,
-                    dry_run,
-                    fork_downstream,
-                    fork,
-                )
-                processed.add(name)
-
-        # Finally, we need to deploy the materialized views from right to left.
-        # We need to rely on the forkdownstream graph as it contains all the modified materialized views as well as the dependencies of the materialized views
-        # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
-        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-        for group in groups:
-            for name in group:
-                if name in processed or not is_materialized(resources_to_run_fork_downstream.get(name)):
-                    continue
-
-                push(
-                    name,
-                    resources_to_run_fork_downstream,
-                    dry_run,
-                    fork_downstream,
-                    fork,
-                )
-                processed.add(name)
-
-    push_files(dependencies_graph, dry_run)
-
-    if not dry_run and not run_tests and verbose:
-        click.echo(FeedbackManager.info_not_pushing_fixtures())
-
-    return dependencies_graph.to_run
 
 
 def name_matches_existing_resource(resource: str, name: str, tb_client: TinyB):

{tinybird-4.6.6.dev0 → tinybird-4.6.7.dev0}/tinybird/tb/modules/local_common.py

@@ -2,6 +2,7 @@ import hashlib
 import json
 import logging
 import os
+import platform
 import re
 import subprocess
 import threading
@@ -13,6 +14,7 @@ import boto3
 import click
 import requests
 from docker.client import DockerClient
+from docker.errors import ImageNotFound
 from docker.models.containers import Container
 
 import docker
@@ -39,6 +41,11 @@ _PATTERN_MESSAGE = re.compile(r'message="([^"]*)"')
 
 TB_IMAGE_NAME = "tinybirdco/tinybird-local:latest"
 TB_CONTAINER_NAME = "tinybird-local"
+
+# Docker Hub registry hostnames that Docker may prepend to a repository name in
+# RepoDigests (e.g. ``docker.io/tinybirdco/tinybird-local@sha256:…``). They all
+# refer to the same registry, so we strip them before comparing repositories.
+_DOCKER_HUB_REGISTRY_PREFIXES = ("docker.io/", "index.docker.io/", "registry-1.docker.io/")
 TB_LOCAL_PORT = int(os.getenv("TB_LOCAL_PORT", 7181))
 TB_LOCAL_CLICKHOUSE_INTERFACE_PORT = int(os.getenv("TB_LOCAL_CLICKHOUSE_INTERFACE_PORT", 7182))
 TB_LOCAL_HOST = _PATTERN_HTTP_PREFIX.sub("", os.getenv("TB_LOCAL_HOST", "localhost"))
@@ -270,6 +277,107 @@ def get_local_tokens(silent: bool = False) -> Dict[str, str]:
         )
 
 
+def get_local_image_platform() -> str:
+    """Return the Docker platform for the Tinybird Local image matching the host.
+
+    Tinybird Local is published as a multi-arch image, so we select the native
+    architecture to avoid emulating linux/amd64 on arm64 hosts (e.g. Apple
+    Silicon). Defaults to linux/amd64 for unknown architectures.
+
+    ``TB_LOCAL_IMAGE_PLATFORM`` overrides the auto-detected platform. This is an
+    escape hatch for running a single-arch image that does not match the host
+    (e.g. deliberately running the amd64 image emulated on an arm64 Mac, or when
+    a locally built image only provides one architecture).
+    """
+    override = os.getenv("TB_LOCAL_IMAGE_PLATFORM")
+    if override:
+        return override
+    machine = platform.machine().lower()
+    if machine in ("arm64", "aarch64"):
+        return "linux/arm64"
+    return "linux/amd64"
+
+
+def _normalize_repo(name: str) -> str:
+    """Strip the Docker Hub registry host from a repository name so digests
+    recorded as ``docker.io/tinybirdco/tinybird-local`` and
+    ``tinybirdco/tinybird-local`` compare equal."""
+    for prefix in _DOCKER_HUB_REGISTRY_PREFIXES:
+        if name.startswith(prefix):
+            return name[len(prefix) :]
+    return name
+
+
+def _remote_manifest_digests(docker_client: DockerClient, image_name: str) -> set[str]:
+    remote_image = docker_client.images.get_registry_data(image_name)
+    remote_digests: set[str] = set()
+    if isinstance(remote_image.id, str):
+        remote_digests.add(remote_image.id)
+
+    attrs = remote_image.attrs if isinstance(remote_image.attrs, dict) else {}
+    descriptor = attrs.get("Descriptor", {})
+    if isinstance(descriptor, dict):
+        descriptor_digest = descriptor.get("digest")
+        if isinstance(descriptor_digest, str):
+            remote_digests.add(descriptor_digest)
+
+    return remote_digests
+
+
+def is_new_local_image_available(docker_client: DockerClient, check_new_version: bool = True) -> tuple[bool, bool]:
+    """Decide whether to pull the Tinybird Local image before starting it.
+
+    Returns ``(show_prompt, pull_required)``.
+
+    Two local-only checks always run, even with ``check_new_version=False`` (the
+    ``--skip-new-version`` / prompt-to-start paths), because they decide whether
+    the cached image is *usable* at all:
+    - image missing -> pull it;
+    - wrong platform cached -> re-pull. An arm64 user who pulled ``:latest`` with
+      the old (amd64-forcing) CLI has the tag cached as ``linux/amd64``; we must
+      replace it with the native image instead of running it emulated.
+
+    Only when ``check_new_version`` is set do we make the registry round-trip to
+    detect a newer published image. Docker Engine exposes the tag's registry
+    digest through ``get_registry_data``; we compare that digest with the
+    normalized local ``RepoDigests`` for this image.
+
+    We fail safe everywhere: if the registry is unreachable or the local image
+    cannot be inspected we keep what is there. A locally built image (no matching
+    registry digest) will prompt; developers use ``--skip-new-version`` for that.
+    """
+    try:
+        local_image = docker_client.images.get(TB_IMAGE_NAME)
+    except ImageNotFound:
+        return False, True  # nothing local yet, we must pull
+    except Exception:
+        return False, False  # cannot inspect locally, keep whatever is there
+
+    local_platform = f"{local_image.attrs.get('Os', '')}/{local_image.attrs.get('Architecture', '')}"
+    if local_platform != get_local_image_platform():
+        return False, True  # wrong platform cached, re-pull the native image
+
+    if not check_new_version:
+        return False, False  # cached image is usable; don't touch the registry
+
+    repo = _PATTERN_TAG_SUFFIX.sub("", TB_IMAGE_NAME)
+    local_digests = {
+        repo_digest.split("@", 1)[1]
+        for repo_digest in (local_image.attrs.get("RepoDigests") or [])
+        if "@" in repo_digest and _normalize_repo(repo_digest.split("@", 1)[0]) == repo
+    }
+
+    try:
+        remote_digests = _remote_manifest_digests(docker_client, TB_IMAGE_NAME)
+    except Exception:
+        return False, False  # registry unreachable, keep the local image
+
+    if not remote_digests:
+        return False, False  # registry metadata unavailable, keep the local image
+
+    return local_digests.isdisjoint(remote_digests), False
+
+
 def start_tinybird_local(
     docker_client: DockerClient,
     use_aws_creds: bool,
@@ -280,29 +388,23 @@ def start_tinybird_local(
     watch: bool = False,
 ) -> None:
     """Start the Tinybird container."""
-    pull_show_prompt = False
-    pull_required = False
-
-    if not skip_new_version:
-        try:
-            local_image = docker_client.images.get(TB_IMAGE_NAME)
-            local_image_id = local_image.attrs["RepoDigests"][0].split("@")[1]
-            remote_image = docker_client.images.get_registry_data(TB_IMAGE_NAME)
-            pull_show_prompt = local_image_id != remote_image.id
-        except Exception:
-            pull_show_prompt = False
-            pull_required = True
+    # Always honors a forced pull (missing / wrong-platform image) even when the
+    # new-version check is skipped, so an arm64 host never keeps running the
+    # emulated amd64 image.
+    pull_show_prompt, pull_required = is_new_local_image_available(
+        docker_client, check_new_version=not skip_new_version
+    )
 
-        if pull_show_prompt and click.confirm(
-            FeedbackManager.warning(message="△ New version detected, download? [y/N]:"),
-            show_default=False,
-            prompt_suffix="",
-        ):
-            click.echo(FeedbackManager.info(message="* Downloading latest version of Tinybird Local..."))
-            pull_required = True
+    if pull_show_prompt and click.confirm(
+        FeedbackManager.warning(message="△ New version detected, download? [y/N]:"),
+        show_default=False,
+        prompt_suffix="",
+    ):
+        click.echo(FeedbackManager.info(message="* Downloading latest version of Tinybird Local..."))
+        pull_required = True
 
-        if pull_required:
-            docker_client.images.pull(TB_IMAGE_NAME, platform="linux/amd64")
+    if pull_required:
+        docker_client.images.pull(TB_IMAGE_NAME, platform=get_local_image_platform())
 
     environment = {}
     if use_aws_creds:
@@ -334,7 +436,7 @@ def start_tinybird_local(
             detach=True,
             ports={"7181/tcp": TB_LOCAL_PORT, "7182/tcp": TB_LOCAL_CLICKHOUSE_INTERFACE_PORT},
             remove=False,
-            platform="linux/amd64",
+            platform=get_local_image_platform(),
             environment=environment,
             volumes=volumes,
         )