tinybird-cli 5.22.2.dev0__tar.gz → 5.22.3.dev0__tar.gz

{tinybird_cli-5.22.2.dev0 → tinybird_cli-5.22.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird_cli
-Version: 5.22.2.dev0
+Version: 5.22.3.dev0
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli
 Author: Tinybird
@@ -61,6 +61,11 @@ The Tinybird command-line tool allows you to use all the Tinybird functionality
 Changelog
 ----------
 
+5.22.2
+***********
+
+- `Fixed` tokens in existing datasource files not being updated when using `tb push -f`
+
 5.22.1
 ***********
 

{tinybird_cli-5.22.2.dev0 → tinybird_cli-5.22.3.dev0}/tinybird/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/cli'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '5.22.2.dev0'
-__revision__ = 'e1b50a6'
+__version__ = '5.22.3.dev0'
+__revision__ = '35eaae2'

{tinybird_cli-5.22.2.dev0 → tinybird_cli-5.22.3.dev0}/tinybird/context.py

@@ -11,7 +11,6 @@ hfi_workspace_data: ContextVar["HfiWorkspaceData"] = ContextVar("hfi_workspace_d
 table_id: ContextVar[str] = ContextVar("table_id")
 hfi_frequency: ContextVar[float] = ContextVar("hfi_frequency")
 hfi_frequency_gatherer: ContextVar[float] = ContextVar("hfi_frequency_gatherer")
-use_gatherer: ContextVar[bool] = ContextVar("use_gatherer")
 gatherer_allow_s3_backup_on_user_errors: ContextVar[bool] = ContextVar("gatherer_allow_s3_backup_on_user_errors")
 disable_template_security_validation: ContextVar[bool] = ContextVar("disable_template_security_validation")
 origin: ContextVar[str] = ContextVar("origin")

{tinybird_cli-5.22.2.dev0 → tinybird_cli-5.22.3.dev0}/tinybird/datafile_common.py

@@ -3515,6 +3515,10 @@ async def new_ds(
         except Exception as e:
             promote_error_message = str(e)
 
+    # Update token scopes when force-pushing an existing datasource
+    if ds.get("tokens"):
+        await manage_tokens()
+
     if alter_response and make_changes:
         # alter operation finished
         pass

{tinybird_cli-5.22.2.dev0 → tinybird_cli-5.22.3.dev0}/tinybird/sql_template.py

@@ -3,6 +3,7 @@ import builtins
 import linecache
 import logging
 import re
+from collections import deque
 from datetime import datetime
 from functools import lru_cache
 from io import StringIO
@@ -1580,8 +1581,6 @@ def get_var_names(t):
                     variable_names = [x for x in c.co_names if x not in _namespace and x not in reserved_vars]
                     v += list(map(lambda variable: {"line": line_number, "name": variable}, variable_names))
                 elif type(x).__name__ == "_ControlBlock":
-                    from io import StringIO
-
                     buffer = StringIO()
                     writer = CodeWriter(buffer, t)
                     x.generate(writer)
@@ -1598,6 +1597,11 @@ def get_var_names(t):
 
 
 def get_var_data(content, node_id=None):
+    """Extract variable data from a template expression.
+
+    Optimized to use a single AST traversal instead of two separate walks.
+    """
+
     def node_to_value(x):
         if type(x) in (ast.Bytes, ast.Str):
             return x.s
@@ -1648,84 +1652,6 @@ def get_var_data(content, node_id=None):
 
         return []
 
-    def _w(parsed):
-        vars = {}
-        for node in ast.walk(parsed):
-            if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
-                try:
-                    func = node.func.id
-                    # parse function args
-                    args = []
-                    for x in node.args:
-                        if type(x) == ast.Call:  # noqa: E721
-                            vars.update(_w(x))
-                        else:
-                            args.append(node_to_value(x))
-
-                    kwargs = {}
-                    for x in node.keywords:
-                        value = node_to_value(x.value)
-                        kwargs[x.arg] = value
-                        if x.arg == "default":
-                            kwargs["default"] = check_default_value(value)
-                    if func in VALID_CUSTOM_FUNCTION_NAMES:
-                        # Type definition here is set to 'String' because it comes from a
-                        # `defined(variable)` expression that does not contain any type hint.
-                        # It will be overriden in later definitions or left as is otherwise.
-                        # args[0] check is used to avoid adding unnamed parameters found in
-                        # templates like: `split_to_array('')`
-                        if args and isinstance(args[0], list):
-                            raise ValueError(f'"{args[0]}" can not be used as a variable name')
-                        if len(args) > 0 and args[0] not in vars and args[0]:
-                            vars[args[0]] = {
-                                "type": "String",
-                                "default": None,
-                                "used_in": "function_call",
-                            }
-                    elif func == "Array":
-                        if "default" not in kwargs:
-                            default = kwargs.get("default", args[2] if len(args) > 2 and args[2] else None)
-                            kwargs["default"] = check_default_value(default)
-                        if args:
-                            if isinstance(args[0], list):
-                                raise ValueError(f'"{args[0]}" can not be used as a variable name')
-                            vars[args[0]] = {
-                                "type": f"Array({args[1]})" if len(args) > 1 else "Array(String)",
-                                **kwargs,
-                            }
-                    elif func in parameter_types:
-                        # avoid variable names to be None
-                        if args and args[0] is not None:
-                            # if this is a cast use the function name to get the type
-                            if "default" not in kwargs:
-                                default = kwargs.get("default", args[1] if len(args) > 1 else None)
-                                kwargs["default"] = check_default_value(default)
-                            try:
-                                if isinstance(args[0], list):
-                                    raise ValueError(f'"{args[0]}" can not be used as a variable name')
-                                vars[args[0]] = {"type": func, **kwargs}
-                                if "default" in kwargs:
-                                    kwargs["default"] = check_default_value(kwargs["default"])
-                            except TypeError as e:
-                                logging.exception(f"pipe parsing problem {content} (node '{node_id}'):  {e}")
-                except ValueError:
-                    raise
-                except Exception as e:
-                    # if we find a problem parsing, let the parsing continue
-                    logging.exception(f"pipe parsing problem {content} (node: '{node_id}'):  {e}")
-            elif isinstance(node, ast.Name):
-                # when parent node is a call it means it's managed by the Call workflow (see above)
-                is_cast = (
-                    isinstance(node.parent, ast.Call)
-                    and isinstance(node.parent.func, ast.Name)
-                    and node.parent.func.id in parameter_types
-                )
-                is_reserved_name = node.id in reserved_vars or node.id in function_list or node.id in _namespace
-                if (not isinstance(node.parent, ast.Call) and not is_cast) and not is_reserved_name:
-                    vars[node.id] = {"type": "String", "default": None}
-
-        return vars
-
     def check_default_value(value):
         if isinstance(value, int):
             MAX_SAFE_INTEGER = 9007199254740991
@@ -1746,12 +1672,90 @@ def get_var_data(content, node_id=None):
             return parse_content(content, retries)
 
     parsed = parse_content(content)
+    vars = {}
+
+    # Single pass: traverse AST while tracking parent references
+    # Use FIFO order so children are visited in source order (matching ast.walk)
+    # because first-seen wins for duplicates like defined(a) and defined(a, ...) later.
+    queue = deque([(parsed, None)])  # (node, parent)
+    while queue:
+        node, parent = queue.popleft()
+
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            try:
+                func = node.func.id
+                # parse function args
+                args = []
+                for x in node.args:
+                    if type(x) == ast.Call:  # noqa: E721
+                        # Nested calls are traversed via `ast.iter_child_nodes` below.
+                        continue
+                    else:
+                        args.append(node_to_value(x))
+
+                kwargs = {}
+                for x in node.keywords:
+                    value = node_to_value(x.value)
+                    kwargs[x.arg] = value
+                    if x.arg == "default":
+                        kwargs["default"] = check_default_value(value)
+                if func in VALID_CUSTOM_FUNCTION_NAMES:
+                    # Type definition here is set to 'String' because it comes from a
+                    # `defined(variable)` expression that does not contain any type hint.
+                    # It will be overriden in later definitions or left as is otherwise.
+                    # args[0] check is used to avoid adding unnamed parameters found in
+                    # templates like: `split_to_array('')`
+                    if args and isinstance(args[0], list):
+                        raise ValueError(f'"{args[0]}" can not be used as a variable name')
+                    if len(args) > 0 and args[0] not in vars and args[0]:
+                        vars[args[0]] = {
+                            "type": "String",
+                            "default": None,
+                            "used_in": "function_call",
+                        }
+                elif func == "Array":
+                    if "default" not in kwargs:
+                        default = kwargs.get("default", args[2] if len(args) > 2 and args[2] else None)
+                        kwargs["default"] = check_default_value(default)
+                    if args:
+                        if isinstance(args[0], list):
+                            raise ValueError(f'"{args[0]}" can not be used as a variable name')
+                        vars[args[0]] = {
+                            "type": f"Array({args[1]})" if len(args) > 1 else "Array(String)",
+                            **kwargs,
+                        }
+                elif func in parameter_types:
+                    # avoid variable names to be None
+                    if args and args[0] is not None:
+                        # if this is a cast use the function name to get the type
+                        if "default" not in kwargs:
+                            default = kwargs.get("default", args[1] if len(args) > 1 else None)
+                            kwargs["default"] = check_default_value(default)
+                        try:
+                            if isinstance(args[0], list):
+                                raise ValueError(f'"{args[0]}" can not be used as a variable name')
+                            vars[args[0]] = {"type": func, **kwargs}
+                            if "default" in kwargs:
+                                kwargs["default"] = check_default_value(kwargs["default"])
+                        except TypeError as e:
+                            logging.exception(f"pipe parsing problem {content} (node '{node_id}'):  {e}")
+            except ValueError:
+                raise
+            except Exception as e:
+                # if we find a problem parsing, let the parsing continue
+                logging.exception(f"pipe parsing problem {content} (node: '{node_id}'):  {e}")
+        elif isinstance(node, ast.Name):
+            # when parent node is a call it means it's managed by the Call workflow (see above)
+            is_cast = (
+                isinstance(parent, ast.Call) and isinstance(parent.func, ast.Name) and parent.func.id in parameter_types
+            )
+            is_reserved_name = node.id in reserved_vars or node.id in function_list or node.id in _namespace
+            if (not isinstance(parent, ast.Call) and not is_cast) and not is_reserved_name:
+                vars[node.id] = {"type": "String", "default": None}
 
-    # calculate parents for each node for later checks
-    for node in ast.walk(parsed):
+        # Add children preserving source order so downstream precedence matches templates
         for child in ast.iter_child_nodes(node):
-            child.parent = node
-    vars = _w(parsed)
+            queue.append((child, node))
 
     return [dict(name=k, **v) for k, v in vars.items()]
 
@@ -1812,6 +1816,8 @@ def get_var_names_and_types(t, node_id=None):
     [{'name': 'symbol_id', 'type': 'Int128', 'description': 'Symbol Id', 'required': True, 'default': 11111}, {'name': 'user_id', 'type': 'Int256', 'description': 'User Id', 'default': 3555}]
     >>> get_var_names_and_types(Template("SELECT now() > {{DateTime64(timestamp, '2020-09-09 10:10:10.000')}}"))
     [{'name': 'timestamp', 'type': 'DateTime64', 'default': '2020-09-09 10:10:10.000'}]
+    >>> get_var_names_and_types(Template("select {{Int32(dup, 1)}} {{String(dup, 'last')}}"))
+    [{'name': 'dup', 'type': 'Int32', 'default': 1}, {'name': 'dup', 'type': 'String', 'default': 'last'}]
     >>> get_var_names_and_types(Template("SELECT * FROM filter_value WHERE symbol = {{Int64(symbol_id, 9223372036854775807)}}"))
     [{'name': 'symbol_id', 'type': 'Int64', 'default': '9223372036854775807'}]
     """

{tinybird_cli-5.22.2.dev0 → tinybird_cli-5.22.3.dev0}/tinybird/sql_toolset.py

@@ -1,12 +1,14 @@
 import copy
 import logging
 import re
+import threading
 from collections import defaultdict
 from datetime import datetime
 from functools import lru_cache
 from typing import FrozenSet, List, Optional, Set, Tuple, Union
 
 from chtoolset import query as chquery
+from lru import LRU
 from toposort import toposort
 
 from tinybird.ch_utils.constants import COPY_ENABLED_TABLE_FUNCTIONS, ENABLED_TABLE_FUNCTIONS
@@ -144,7 +146,135 @@ def format_where_for_mutation_command(where_clause: str) -> str:
     return f"DELETE WHERE {quoted_condition[1:-1]}"
 
 
-@lru_cache(maxsize=2**15)
+# Functions that take table/dictionary names as string literal arguments.
+# Normalizing these would cause incorrect cache hits since different table names
+# would map to the same cache key.
+# See: https://clickhouse.com/docs/en/sql-reference/functions/other-functions#joinget
+#      https://clickhouse.com/docs/en/sql-reference/functions/ext-dict-functions
+#      https://clickhouse.com/docs/en/sql-reference/table-functions/cluster
+#      https://clickhouse.com/docs/en/sql-reference/table-functions/remote
+_FUNCTIONS_WITH_TABLE_NAME_ARGS = re.compile(
+    r"\b(?:joinGet|joinGetOrNull|dictGet\w*|dictHas|dictIsIn|hasColumnInTable|remote|cluster|clusterAllReplicas)\s*\(",
+    re.IGNORECASE,
+)
+
+
+def _normalize_sql_for_cache(sql: str) -> str:
+    """Normalize SQL for cache key purposes.
+
+    Uses normalize_query_keep_names which replaces literal values with placeholders
+    while preserving table/column names, so queries with the same structure share
+    cache entries.
+
+    However, some functions like joinGet(), dictGet*, remote(), cluster(), and
+    clusterAllReplicas() take table/dictionary names as arguments. Normalizing these
+    would incorrectly map different tables to the same cache key, so we fall back to
+    using the original SQL for such queries.
+
+    >>> _normalize_sql_for_cache("SELECT * FROM events WHERE id = 'alice'")
+    'SELECT * FROM events WHERE id = ?'
+    >>> _normalize_sql_for_cache("SELECT * FROM events WHERE id = 123 AND name = 'bob'")
+    'SELECT * FROM events WHERE id = ? AND name = ?'
+    >>> _normalize_sql_for_cache("SELECT * FROM events")
+    'SELECT * FROM events'
+    >>> _normalize_sql_for_cache("SELECT joinGet('my_table', 'col', id) FROM t")
+    "SELECT joinGet('my_table', 'col', id) FROM t"
+    >>> _normalize_sql_for_cache("SELECT dictGet('my_dict', 'value', id) FROM t")
+    "SELECT dictGet('my_dict', 'value', id) FROM t"
+    >>> _normalize_sql_for_cache("SELECT * FROM remote('host', db, table)")
+    "SELECT * FROM remote('host', db, table)"
+    >>> _normalize_sql_for_cache("SELECT * FROM cluster('cluster_name', db, table)")
+    "SELECT * FROM cluster('cluster_name', db, table)"
+    >>> _normalize_sql_for_cache("not valid sql at all")
+    'not valid sql at all'
+    """
+    # Skip normalization for queries with functions that have table names as arguments
+    if _FUNCTIONS_WITH_TABLE_NAME_ARGS.search(sql):
+        return sql
+
+    try:
+        return chquery.normalize_query_keep_names(sql)
+    except Exception:
+        return sql
+
+
+# Cache for sql_get_used_tables using normalized SQL as key.
+# Uses lru-dict (C extension) for a fast LRU implementation.
+_sql_get_used_tables_cache: LRU = LRU(2**15)
+_sql_get_used_tables_cache_lock = threading.Lock()
+_sql_get_used_tables_cache_hits = 0
+_sql_get_used_tables_cache_misses = 0
+
+
+def sql_get_used_tables_cache_info() -> dict:
+    """Return cache statistics for sql_get_used_tables."""
+    with _sql_get_used_tables_cache_lock:
+        return {
+            "hits": _sql_get_used_tables_cache_hits,
+            "misses": _sql_get_used_tables_cache_misses,
+            "size": len(_sql_get_used_tables_cache),
+            "maxsize": _sql_get_used_tables_cache.get_size(),
+        }
+
+
+def sql_get_used_tables_cache_clear() -> None:
+    """Clear the sql_get_used_tables cache."""
+    global _sql_get_used_tables_cache_hits, _sql_get_used_tables_cache_misses
+    with _sql_get_used_tables_cache_lock:
+        _sql_get_used_tables_cache.clear()
+        _sql_get_used_tables_cache_hits = 0
+        _sql_get_used_tables_cache_misses = 0
+
+
+def _sql_get_used_tables_impl(
+    sql: str,
+    raising: bool,
+    default_database: str,
+    table_functions: bool,
+    function_allow_list: Optional[FrozenSet[str]],
+    function_deny_list: Optional[FrozenSet[str]],
+    settings_allow_list: Optional[FrozenSet[str]],
+    settings_deny_list: Optional[FrozenSet[str]],
+) -> tuple[List[Tuple[str, str, str]], bool]:
+    """Extract tables from SQL (uncached implementation).
+
+    Returns a tuple of (result, cacheable) where cacheable indicates whether the
+    result is safe to store in the cache.
+    """
+    try:
+        _function_allow_list = list() if function_allow_list is None else list(function_allow_list)
+        _function_deny_list = list() if function_deny_list is None else list(function_deny_list)
+        _settings_allow_list = list() if settings_allow_list is None else list(settings_allow_list)
+        _settings_deny_list = list() if settings_deny_list is None else list(settings_deny_list)
+
+        tables: List[Tuple[str, str, str]] = chquery.tables(
+            sql,
+            default_database=default_database,
+            function_allow_list=_function_allow_list,
+            function_deny_list=_function_deny_list,
+            query_settings_allow_list=_settings_allow_list,
+            query_settings_deny_list=_settings_deny_list,
+        )
+        if not table_functions:
+            tables = [(t[0], t[1], "") for t in tables if t[0] or t[1]]
+
+        return tables, True
+    except ValueError as e:
+        if raising:
+            msg = str(e)
+            if "is restricted. Contact support@tinybird.co" in msg:
+                raise InvalidFunction(msg=msg) from e
+            elif "Unknown function tb_secret" in msg:
+                raise InvalidFunction(msg="Unknown function tb_secret. Usage: {{tb_secret('secret_name')}}") from e
+            elif "Unknown function tb_var" in msg:
+                raise InvalidFunction(msg="Unknown function tb_var. Usage: {{tb_var('var_name')}}") from e
+            raise
+        # Do not cache this fallback result: the returned sql string can contain
+        # sensitive literal values, and the normalized cache key could collide
+        # across different queries.
+        return [(default_database, sql, "")], False
+
+
 def sql_get_used_tables_cached(
     sql: str,
     raising: bool = False,
@@ -152,10 +282,17 @@ def sql_get_used_tables_cached(
     table_functions: bool = True,
     function_allow_list: Optional[FrozenSet[str]] = None,
     function_deny_list: Optional[FrozenSet[str]] = None,
+    settings_allow_list: Optional[FrozenSet[str]] = None,
+    settings_deny_list: Optional[FrozenSet[str]] = None,
 ) -> List[Tuple[str, str, str]]:
     """More like: get used sql names
 
     Returns a list of tuples: (database_or_namespace, table_name, table_func).
+
+    Uses normalized SQL as cache key to improve hit ratio for templated queries.
+    The normalization replaces literal values with placeholders while preserving
+    table/column names, so queries with the same structure share cache entries.
+
     >>> sql_get_used_tables("SELECT 1 FROM the_table")
     [('', 'the_table', '')]
     >>> sql_get_used_tables("SELECT 1 FROM the_database.the_table")
@@ -173,30 +310,47 @@ def sql_get_used_tables_cached(
     >>> sql_get_used_tables("SELECT * FROM `d_d3926a`.`t_976af08ec4b547419e729c63e754b17b`", table_functions=False)
     [('d_d3926a', 't_976af08ec4b547419e729c63e754b17b', '')]
     """
-    try:
-        _function_allow_list = list() if function_allow_list is None else list(function_allow_list)
-        _function_deny_list = list() if function_deny_list is None else list(function_deny_list)
+    global _sql_get_used_tables_cache_hits, _sql_get_used_tables_cache_misses
+
+    # Build cache key using normalized SQL
+    normalized_sql = _normalize_sql_for_cache(sql)
+    cache_key = (
+        normalized_sql,
+        raising,
+        default_database,
+        table_functions,
+        function_allow_list,
+        function_deny_list,
+        settings_allow_list,
+        settings_deny_list,
+    )
 
-        tables: List[Tuple[str, str, str]] = chquery.tables(
-            sql,
-            default_database=default_database,
-            function_allow_list=_function_allow_list,
-            function_deny_list=_function_deny_list,
-        )
-        if not table_functions:
-            return [(t[0], t[1], "") for t in tables if t[0] or t[1]]
-        return tables
-    except ValueError as e:
-        if raising:
-            msg = str(e)
-            if "is restricted. Contact support@tinybird.co" in msg:
-                raise InvalidFunction(msg=msg) from e
-            elif "Unknown function tb_secret" in msg:
-                raise InvalidFunction(msg="Unknown function tb_secret. Usage: {{tb_secret('secret_name')}}") from e
-            elif "Unknown function tb_var" in msg:
-                raise InvalidFunction(msg="Unknown function tb_var. Usage: {{tb_var('var_name')}}") from e
-            raise
-        return [(default_database, sql, "")]
+    # Single lookup with hit/miss tracking
+    with _sql_get_used_tables_cache_lock:
+        cached_value = _sql_get_used_tables_cache.get(cache_key)
+        if cached_value is not None:
+            _sql_get_used_tables_cache_hits += 1
+            return cached_value
+        _sql_get_used_tables_cache_misses += 1
+
+    # Compute outside lock to avoid blocking other threads
+    result, cacheable = _sql_get_used_tables_impl(
+        sql,
+        raising,
+        default_database,
+        table_functions,
+        function_allow_list,
+        function_deny_list,
+        settings_allow_list,
+        settings_deny_list,
+    )
+
+    if cacheable:
+        # Store result in cache
+        with _sql_get_used_tables_cache_lock:
+            _sql_get_used_tables_cache.setdefault(cache_key, result)
+
+    return result
 
 
 def sql_get_used_tables(
@@ -206,6 +360,8 @@ def sql_get_used_tables(
     table_functions: bool = True,
     function_allow_list: Optional[FrozenSet[str]] = None,
     function_deny_list: Optional[FrozenSet[str]] = None,
+    settings_allow_list: Optional[FrozenSet[str]] = None,
+    settings_deny_list: Optional[FrozenSet[str]] = None,
 ) -> List[Tuple[str, str, str]]:
     """More like: get used sql names
 
@@ -213,7 +369,8 @@ def sql_get_used_tables(
     """
     function_allow_hashable_list = frozenset() if function_allow_list is None else function_allow_list
     function_deny_hashable_list = frozenset() if function_deny_list is None else function_deny_list
-
+    settings_allow_hashable_list = frozenset() if settings_allow_list is None else settings_allow_list
+    settings_deny_hashable_list = frozenset() if settings_deny_list is None else settings_deny_list
     return copy.copy(
         sql_get_used_tables_cached(
             sql,
@@ -222,6 +379,8 @@ def sql_get_used_tables(
             table_functions,
             function_allow_list=function_allow_hashable_list,
             function_deny_list=function_deny_hashable_list,
+            settings_allow_list=settings_allow_hashable_list,
+            settings_deny_list=settings_deny_hashable_list,
         )
     )
 
@@ -309,16 +468,18 @@ def replace_tables_chquery_cached(
     output_one_line: bool = False,
     timestamp: Optional[datetime] = None,
     function_allow_list: Optional[FrozenSet[str]] = None,
+    settings_allow_list: Optional[FrozenSet[str]] = None,
 ) -> str:
     replacements = dict(sorted_replacements) if sorted_replacements else {}
     _function_allow_list = list() if function_allow_list is None else list(function_allow_list)
-
+    _settings_allow_list = list() if settings_allow_list is None else list(settings_allow_list)
     return chquery.replace_tables(
         sql,
         replacements,
         default_database=default_database,
         one_line=output_one_line,
         function_allow_list=_function_allow_list,
+        query_settings_allow_list=_settings_allow_list,
     )
 
 
@@ -332,6 +493,7 @@ def replace_tables(
     output_one_line: bool = False,
     timestamp: Optional[datetime] = None,
     function_allow_list: Optional[FrozenSet[str]] = None,
+    settings_allow_list: Optional[FrozenSet[str]] = None,
     original_replacements: Optional[dict] = None,
 ) -> str:
     """
@@ -340,10 +502,16 @@ def replace_tables(
     It also validates the sql to verify it's valid and doesn't use unknown or prohibited functions
     """
     hashable_list = frozenset() if function_allow_list is None else function_allow_list
+    hashable_settings_list = frozenset() if settings_allow_list is None else settings_allow_list
     if not replacements:
         # Always call replace_tables to do validation and formatting
         return replace_tables_chquery_cached(
-            sql, None, output_one_line=output_one_line, timestamp=timestamp, function_allow_list=hashable_list
+            sql,
+            None,
+            output_one_line=output_one_line,
+            timestamp=timestamp,
+            function_allow_list=hashable_list,
+            settings_allow_list=hashable_settings_list,
         )
 
     _replaced_with = set()
@@ -366,6 +534,7 @@ def replace_tables(
         raising=True,
         table_functions=check_functions,
         function_allow_list=function_allow_list,
+        settings_allow_list=settings_allow_list,
     )
     seen_tables = set()
     table: Union[Tuple[str, str], Tuple[str, str, str]]
@@ -411,7 +580,12 @@ def replace_tables(
 
     if not deps_sorted:
         return replace_tables_chquery_cached(
-            sql, None, output_one_line=output_one_line, timestamp=timestamp, function_allow_list=hashable_list
+            sql,
+            None,
+            output_one_line=output_one_line,
+            timestamp=timestamp,
+            function_allow_list=hashable_list,
+            settings_allow_list=hashable_settings_list,
         )
 
     for current_deps in deps_sorted:
@@ -450,10 +624,16 @@ def replace_tables(
                 output_one_line=output_one_line,
                 timestamp=timestamp,
                 function_allow_list=hashable_list,
+                settings_allow_list=hashable_settings_list,
             )
         else:
             sql = replace_tables_chquery_cached(
-                sql, None, output_one_line=output_one_line, timestamp=timestamp, function_allow_list=hashable_list
+                sql,
+                None,
+                output_one_line=output_one_line,
+                timestamp=timestamp,
+                function_allow_list=hashable_list,
+                settings_allow_list=hashable_settings_list,
             )
 
     # Fix for empty database names in JOINs - remove empty backticks like ``.table_name

{tinybird_cli-5.22.2.dev0 → tinybird_cli-5.22.3.dev0}/tinybird_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird_cli
-Version: 5.22.2.dev0
+Version: 5.22.3.dev0
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli
 Author: Tinybird
@@ -61,6 +61,11 @@ The Tinybird command-line tool allows you to use all the Tinybird functionality
 Changelog
 ----------
 
+5.22.2
+***********
+
+- `Fixed` tokens in existing datasource files not being updated when using `tb push -f`
+
 5.22.1
 ***********