tinybird 4.6.6.dev0__tar.gz → 4.6.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 4.6.6.dev0
+Version: 4.6.7
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird
@@ -52,6 +52,18 @@ The Tinybird command-line tool allows you to use all the Tinybird functionality
 Changelog
 ----------
 
+4.6.7.
+*******
+
+- `Fixed` `tb login` now raises an actionable error when the CLI cannot complete the authentication.
+
+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}/tinybird/sql_template.py

@@ -1953,11 +1953,12 @@ def get_var_data(content, node_id=None):
     """
 
     def node_to_value(x):
-        if type(x) in (ast.Bytes, ast.Str):
-            return x.s
-        elif type(x) == ast.Num:  # noqa: E721
-            return x.n
-        elif type(x) == ast.NameConstant:  # noqa: E721
+        # ast.Constant supersedes the deprecated ast.Bytes/ast.Str/ast.Num/
+        # ast.NameConstant node classes. Those were aliases of ast.Constant
+        # since Python 3.8 (emitting DeprecationWarning on access in 3.12) and
+        # were removed in Python 3.14. The parser only ever produces
+        # ast.Constant nodes, so .value holds str/bytes/int/float/bool/None.
+        if type(x) == ast.Constant:  # noqa: E721
             return x.value
         elif type(x) == ast.Name:  # noqa: E721
             return x.id
@@ -1971,8 +1972,6 @@ def get_var_data(content, node_id=None):
             if not r:
                 r = node_to_value(x.right)
             return r
-        elif type(x) == ast.Constant:  # noqa: E721
-            return x.value
         elif type(x) == ast.UnaryOp and type(x.operand) == ast.Constant:  # noqa: E721
             if type(x.op) == ast.USub:  # noqa: E721
                 return x.operand.value * -1
@@ -1991,11 +1990,9 @@ def get_var_data(content, node_id=None):
             return []
 
         first_elem = x.elts[0]
-        if type(first_elem) in (ast.Bytes, ast.Str):
-            return [elem.s for elem in x.elts]
-        elif type(first_elem) == ast.Num:  # noqa: E721
-            return [elem.n for elem in x.elts]
-        elif type(first_elem) == ast.NameConstant or type(first_elem) == ast.Constant:  # noqa: E721
+        # See node_to_value: ast.Constant supersedes the deprecated
+        # ast.Bytes/ast.Str/ast.Num/ast.NameConstant (removed in 3.14).
+        if type(first_elem) == ast.Constant:  # noqa: E721
             return [elem.value for elem in x.elts]
         elif type(first_elem) == ast.Name:  # noqa: E721
             return [elem.id for elem in x.elts]

{tinybird-4.6.6.dev0 → tinybird-4.6.7}/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'
+__revision__ = '1177944'

{tinybird-4.6.6.dev0 → tinybird-4.6.7}/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}/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}/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):