snowflake-cli 3.2.1__py3-none-any.whl → 3.3.0__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "3.2.1"
+VERSION = "3.3.0"

snowflake/cli/_app/constants.py

@@ -17,3 +17,7 @@ from __future__ import annotations
 from typing import Literal
 
 PARAM_APPLICATION_NAME: Literal["snowcli"] = "snowcli"
+
+# This is also defined on server side. Changing this parameter would require
+# a change in https://github.com/snowflakedb/snowflake
+INTERNAL_APPLICATION_NAME: Literal["SNOWFLAKE_CLI"] = "SNOWFLAKE_CLI"

snowflake/cli/_app/snow_connector.py

@@ -21,7 +21,9 @@ from typing import Dict, Optional
 
 import snowflake.connector
 from click.exceptions import ClickException
+from snowflake.cli.__about__ import VERSION
 from snowflake.cli._app.constants import (
+    INTERNAL_APPLICATION_NAME,
     PARAM_APPLICATION_NAME,
 )
 from snowflake.cli._app.secret import SecretType
@@ -35,6 +37,7 @@ from snowflake.cli.api.exceptions import (
     InvalidConnectionConfiguration,
     SnowflakeConnectionError,
 )
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import SnowflakeConnection
 from snowflake.connector.errors import DatabaseError, ForbiddenError
@@ -150,6 +153,8 @@ def connect_to_snowflake(
 
     _update_connection_application_name(connection_parameters)
 
+    _update_internal_application_info(connection_parameters)
+
     try:
         # Whatever output is generated when creating connection,
         # we don't want it in our output. This is particularly important
@@ -238,6 +243,13 @@ def _update_connection_application_name(connection_parameters: Dict):
     connection_parameters.update(connection_application_params)
 
 
+def _update_internal_application_info(connection_parameters: Dict):
+    """Update internal application data if ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID is enabled."""
+    if FeatureFlag.ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID.is_enabled():
+        connection_parameters["internal_application_name"] = INTERNAL_APPLICATION_NAME
+        connection_parameters["internal_application_version"] = VERSION
+
+
 def _load_pem_from_file(private_key_file: str) -> SecretType:
     with SecurePath(private_key_file).open(
         "rb", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB

snowflake/cli/_app/telemetry.py

@@ -67,6 +67,10 @@ class CLITelemetryField(Enum):
     CONFIG_FEATURE_FLAGS = "config_feature_flags"
     # Metrics
     COUNTERS = "counters"
+    SPANS = "spans"
+    COMPLETED_SPANS = "completed_spans"
+    NUM_SPANS_PAST_DEPTH_LIMIT = "num_spans_past_depth_limit"
+    NUM_SPANS_PAST_TOTAL_LIMIT = "num_spans_past_total_limit"
     # Information
     EVENT = "event"
     ERROR_MSG = "error_msg"
@@ -129,9 +133,12 @@ def _get_command_metrics() -> TelemetryDict:
     cli_context = get_cli_context()
 
     return {
-        CLITelemetryField.COUNTERS: {
-            **cli_context.metrics.counters,
-        }
+        CLITelemetryField.COUNTERS: cli_context.metrics.counters,
+        CLITelemetryField.SPANS: {
+            CLITelemetryField.COMPLETED_SPANS.value: cli_context.metrics.completed_spans,
+            CLITelemetryField.NUM_SPANS_PAST_DEPTH_LIMIT.value: cli_context.metrics.num_spans_past_depth_limit,
+            CLITelemetryField.NUM_SPANS_PAST_TOTAL_LIMIT.value: cli_context.metrics.num_spans_past_total_limit,
+        },
     }
 
 

snowflake/cli/_plugins/connection/util.py

@@ -19,7 +19,6 @@ import logging
 import os
 from enum import Enum
 from functools import lru_cache
-from textwrap import dedent
 from typing import Any, Dict, Optional
 
 from click.exceptions import ClickException
@@ -57,11 +56,12 @@ class UIParameter(Enum):
     NA_ENFORCE_MANDATORY_FILTERS = (
         "ENFORCE_MANDATORY_FILTERS_FOR_SAME_ACCOUNT_INSTALLATION"
     )
+    NA_FEATURE_RELEASE_CHANNELS = "FEATURE_RELEASE_CHANNELS"
 
 
 def get_ui_parameter(
     conn: SnowflakeConnection, parameter: UIParameter, default: Any
-) -> str:
+) -> Any:
     """
     Returns the value of a single UI parameter.
     If the parameter is not found, the default value is returned.
@@ -77,21 +77,19 @@ def get_ui_parameters(conn: SnowflakeConnection) -> Dict[UIParameter, Any]:
     Returns the UI parameters from the SYSTEM$BOOTSTRAP_DATA_REQUEST function
     """
 
-    parameters_to_fetch = sorted([param.value for param in UIParameter])
+    parameters_to_fetch = [param.value for param in UIParameter]
 
-    query = dedent(
-        f"""
-        select value['value']::string as PARAM_VALUE, value['name']::string as PARAM_NAME from table(flatten(
-            input => parse_json(SYSTEM$BOOTSTRAP_DATA_REQUEST()),
-            path => 'clientParamsInfo'
-        )) where value['name'] in ('{"', '".join(parameters_to_fetch)}');
-        """
-    )
+    # Parsing of the Json and the filtering is happening here in Snowflake CLI
+    # in order to avoid requiring a warehouse in Snowflake
+    query = "call system$bootstrap_data_request('CLIENT_PARAMS_INFO')"
+    *_, cursor = conn.execute_string(query)
 
-    *_, cursor = conn.execute_string(query, cursor_class=DictCursor)
+    json_map = json.loads(cursor.fetchone()[0])
 
     return {
-        UIParameter(row["PARAM_NAME"]): row["PARAM_VALUE"] for row in cursor.fetchall()
+        UIParameter(row["name"]): row["value"]
+        for row in json_map["clientParamsInfo"]
+        if row["name"] in parameters_to_fetch
     }
 
 
@@ -103,12 +101,7 @@ def is_regionless_redirect(conn: SnowflakeConnection) -> bool:
     assume it's regionless, as this is true for most production deployments.
     """
     try:
-        return (
-            get_ui_parameter(
-                conn, UIParameter.NA_ENABLE_REGIONLESS_REDIRECT, "true"
-            ).lower()
-            == "true"
-        )
+        return get_ui_parameter(conn, UIParameter.NA_ENABLE_REGIONLESS_REDIRECT, True)
     except:
         log.warning(
             "Cannot determine regionless redirect; assuming True.", exc_info=True

snowflake/cli/_plugins/helpers/commands.py

@@ -14,17 +14,30 @@
 
 from __future__ import annotations
 
+import logging
+from pathlib import Path
+from typing import Any, List, Optional
+
 import typer
 import yaml
 from click import ClickException
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.output.types import MessageResult
+from snowflake.cli.api.config import (
+    ConnectionConfig,
+    add_connection_to_proper_file,
+    get_all_connections,
+    set_config_value,
+)
+from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.output.types import CommandResult, MessageResult
 from snowflake.cli.api.project.definition_conversion import (
     convert_project_definition_to_v2,
 )
 from snowflake.cli.api.project.definition_manager import DefinitionManager
 from snowflake.cli.api.secure_path import SecurePath
 
+log = logging.getLogger(__name__)
+
 app = SnowTyperFactory(
     name="helpers",
     help="Helper commands.",
@@ -88,3 +101,196 @@ def v1_to_v2(
             width=float("inf"),  # Don't break lines
         )
     return MessageResult("Project definition migrated to version 2.")
+
+
+@app.command(name="import-snowsql-connections", requires_connection=False)
+def import_snowsql_connections(
+    custom_snowsql_config_files: Optional[List[Path]] = typer.Option(
+        None,
+        "--snowsql-config-file",
+        help="Specifies file paths to custom SnowSQL configuration. The option can be used multiple times to specify more than 1 file.",
+        dir_okay=False,
+        exists=True,
+    ),
+    default_cli_connection_name: str = typer.Option(
+        "default",
+        "--default-connection-name",
+        help="Specifies the name which will be given in Snowflake CLI to the default connection imported from SnowSQL.",
+    ),
+    **options,
+) -> CommandResult:
+    """Import your existing connections from your SnowSQL configuration."""
+
+    snowsql_config_files: list[Path] = custom_snowsql_config_files or [
+        Path("/etc/snowsql.cnf"),
+        Path("/etc/snowflake/snowsql.cnf"),
+        Path("/usr/local/etc/snowsql.cnf"),
+        Path.home() / Path(".snowsql.cnf"),
+        Path.home() / Path(".snowsql/config"),
+    ]
+    snowsql_config_secure_paths: list[SecurePath] = [
+        SecurePath(p) for p in snowsql_config_files
+    ]
+
+    all_imported_connections = _read_all_connections_from_snowsql(
+        default_cli_connection_name, snowsql_config_secure_paths
+    )
+    _validate_and_save_connections_imported_from_snowsql(
+        default_cli_connection_name, all_imported_connections
+    )
+    return MessageResult(
+        "Connections successfully imported from SnowSQL to Snowflake CLI."
+    )
+
+
+def _read_all_connections_from_snowsql(
+    default_cli_connection_name: str, snowsql_config_files: List[SecurePath]
+) -> dict[str, dict]:
+    import configparser
+
+    imported_default_connection: dict[str, Any] = {}
+    imported_named_connections: dict[str, dict] = {}
+
+    for file in snowsql_config_files:
+        if not file.exists():
+            cli_console.step(
+                f"SnowSQL config file [{str(file.path)}] does not exist. Skipping."
+            )
+            continue
+
+        cli_console.step(f"Trying to read connections from [{str(file.path)}].")
+        snowsql_config = configparser.ConfigParser()
+        snowsql_config.read(file.path)
+
+        if "connections" in snowsql_config and snowsql_config.items("connections"):
+            cli_console.step(
+                f"Reading SnowSQL's default connection configuration from [{str(file.path)}]"
+            )
+            snowsql_default_connection = snowsql_config.items("connections")
+            imported_default_connection.update(
+                _convert_connection_from_snowsql_config_section(
+                    snowsql_default_connection
+                )
+            )
+
+        other_snowsql_connection_section_names = [
+            section_name
+            for section_name in snowsql_config.sections()
+            if section_name.startswith("connections.")
+        ]
+        for snowsql_connection_section_name in other_snowsql_connection_section_names:
+            cli_console.step(
+                f"Reading SnowSQL's connection configuration [{snowsql_connection_section_name}] from [{str(file.path)}]"
+            )
+            snowsql_named_connection = snowsql_config.items(
+                snowsql_connection_section_name
+            )
+            if not snowsql_named_connection:
+                cli_console.step(
+                    f"Empty connection configuration [{snowsql_connection_section_name}] in [{str(file.path)}]. Skipping."
+                )
+                continue
+
+            connection_name = snowsql_connection_section_name.removeprefix(
+                "connections."
+            )
+            imported_named_conenction = _convert_connection_from_snowsql_config_section(
+                snowsql_named_connection
+            )
+            if connection_name in imported_named_connections:
+                imported_named_connections[connection_name].update(
+                    imported_named_conenction
+                )
+            else:
+                imported_named_connections[connection_name] = imported_named_conenction
+
+    def imported_default_connection_as_named_connection():
+        name = _validate_imported_default_connection_name(
+            default_cli_connection_name, imported_named_connections
+        )
+        return {name: imported_default_connection}
+
+    named_default_connection = (
+        imported_default_connection_as_named_connection()
+        if imported_default_connection
+        else {}
+    )
+
+    return imported_named_connections | named_default_connection
+
+
+def _validate_imported_default_connection_name(
+    name_candidate: str, other_snowsql_connections: dict[str, dict]
+) -> str:
+    if name_candidate in other_snowsql_connections:
+        new_name_candidate = typer.prompt(
+            f"Chosen default connection name '{name_candidate}' is already taken by other connection being imported from SnowSQL. Please choose a different name for your default connection"
+        )
+        return _validate_imported_default_connection_name(
+            new_name_candidate, other_snowsql_connections
+        )
+    else:
+        return name_candidate
+
+
+def _convert_connection_from_snowsql_config_section(
+    snowsql_connection: list[tuple[str, Any]]
+) -> dict[str, Any]:
+    from ast import literal_eval
+
+    key_names_replacements = {
+        "accountname": "account",
+        "username": "user",
+        "databasename": "database",
+        "dbname": "database",
+        "schemaname": "schema",
+        "warehousename": "warehouse",
+        "rolename": "role",
+        "private_key_path": "private_key_file",
+    }
+
+    def parse_value(value: Any):
+        try:
+            parsed_value = literal_eval(value)
+        except Exception:
+            parsed_value = value
+        return parsed_value
+
+    cli_connection: dict[str, Any] = {}
+    for key, value in snowsql_connection:
+        cli_key = key_names_replacements.get(key, key)
+        cli_value = parse_value(value)
+        cli_connection[cli_key] = cli_value
+    return cli_connection
+
+
+def _validate_and_save_connections_imported_from_snowsql(
+    default_cli_connection_name: str, all_imported_connections: dict[str, Any]
+):
+    existing_cli_connection_names: set[str] = set(get_all_connections().keys())
+    imported_connections_to_save: dict[str, Any] = {}
+    for (
+        imported_connection_name,
+        imported_connection,
+    ) in all_imported_connections.items():
+        if imported_connection_name in existing_cli_connection_names:
+            override_cli_connection = typer.confirm(
+                f"Connection '{imported_connection_name}' already exists in Snowflake CLI, do you want to use SnowSQL definition and override existing connection in Snowflake CLI?"
+            )
+            if not override_cli_connection:
+                continue
+        imported_connections_to_save[imported_connection_name] = imported_connection
+
+    for name, connection in imported_connections_to_save.items():
+        cli_console.step(f"Saving [{name}] connection in Snowflake CLI's config.")
+        add_connection_to_proper_file(name, ConnectionConfig.from_dict(connection))
+
+    if default_cli_connection_name in imported_connections_to_save:
+        cli_console.step(
+            f"Setting [{default_cli_connection_name}] connection as Snowflake CLI's default connection."
+        )
+        set_config_value(
+            section=None,
+            key="default_connection_name",
+            value=default_cli_connection_name,
+        )

snowflake/cli/_plugins/nativeapp/artifacts.py

@@ -22,6 +22,7 @@ from textwrap import dedent
 from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union
 
 from click.exceptions import ClickException
+from snowflake.cli.api.cli_global_context import span
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.util import to_identifier
@@ -649,6 +650,7 @@ def resolve_without_follow(path: Path) -> Path:
     return Path(os.path.abspath(path))
 
 
+@span("bundle")
 def build_bundle(
     project_root: Path,
     deploy_root: Path,
@@ -775,12 +777,16 @@ def find_version_info_in_manifest_file(
     label: Optional[str] = None
 
     version_info = manifest_content.get("version", None)
-    if version_info:
-        if name_field in version_info:
+    if version_info is not None:
+        if not isinstance(version_info, dict):
+            raise ClickException(
+                "Error occurred while reading manifest.yml. Received unexpected version format."
+            )
+        if version_info.get(name_field) is not None:
             version_name = to_identifier(str(version_info[name_field]))
-        if patch_field in version_info:
+        if version_info.get(patch_field) is not None:
             patch_number = int(version_info[patch_field])
-        if label_field in version_info:
+        if version_info.get(label_field) is not None:
             label = str(version_info[label_field])
 
     return VersionInfo(version_name, patch_number, label)

snowflake/cli/_plugins/nativeapp/codegen/compiler.py

@@ -33,7 +33,6 @@ from snowflake.cli._plugins.nativeapp.codegen.snowpark.python_processor import (
 from snowflake.cli._plugins.nativeapp.codegen.templates.templates_processor import (
     TemplatesProcessor,
 )
-from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.metrics import CLICounterField
@@ -41,15 +40,7 @@ from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import (
     ProcessorMapping,
 )
 
-SNOWPARK_PROCESSOR = "snowpark"
-NA_SETUP_PROCESSOR = "native app setup"
-TEMPLATES_PROCESSOR = "templates"
-
-_REGISTERED_PROCESSORS_BY_NAME = {
-    SNOWPARK_PROCESSOR: SnowparkAnnotationProcessor,
-    NA_SETUP_PROCESSOR: NativeAppSetupProcessor,
-    TEMPLATES_PROCESSOR: TemplatesProcessor,
-}
+ProcessorClassType = type[ArtifactProcessor]
 
 
 class NativeAppCompiler:
@@ -66,10 +57,28 @@ class NativeAppCompiler:
         bundle_ctx: BundleContext,
     ):
         self._assert_absolute_paths(bundle_ctx)
+        self._processor_classes_by_name: Dict[str, ProcessorClassType] = {}
         self._bundle_ctx = bundle_ctx
         # dictionary of all processors created and shared between different artifact objects.
         self.cached_processors: Dict[str, ArtifactProcessor] = {}
 
+        self.register(SnowparkAnnotationProcessor)
+        self.register(NativeAppSetupProcessor)
+        self.register(TemplatesProcessor)
+
+    def register(self, processor_cls: ProcessorClassType):
+        """
+        Registers a processor class to enable.
+        """
+
+        name = getattr(processor_cls, "NAME", None)
+        assert name is not None
+
+        if name in self._processor_classes_by_name:
+            raise ValueError(f"Processor {name} is already registered")
+
+        self._processor_classes_by_name[str(name)] = processor_cls
+
     @staticmethod
     def _assert_absolute_paths(bundle_ctx: BundleContext):
         for name in ["Project", "Deploy", "Bundle", "Generated"]:
@@ -88,7 +97,10 @@ class NativeAppCompiler:
         if not self._should_invoke_processors():
             return
 
-        with cc.phase("Invoking artifact processors"):
+        with (
+            cc.phase("Invoking artifact processors"),
+            get_cli_context().metrics.span("artifact_processors"),
+        ):
             if self._bundle_ctx.generated_root.exists():
                 raise ClickException(
                     f"Path {self._bundle_ctx.generated_root} already exists. Please choose a different name for your generated directory in the project definition file."
@@ -125,8 +137,8 @@ class NativeAppCompiler:
         if current_processor is not None:
             return current_processor
 
-        processor_factory = _REGISTERED_PROCESSORS_BY_NAME.get(processor_name)
-        if processor_factory is None:
+        processor_cls = self._processor_classes_by_name.get(processor_name)
+        if processor_cls is None:
             # No registered processor with the specified name
             return None
 
@@ -138,7 +150,7 @@ class NativeAppCompiler:
         processor_ctx.generated_root = (
             self._bundle_ctx.generated_root / processor_subdirectory
         )
-        current_processor = processor_factory(processor_ctx)
+        current_processor = processor_cls(processor_ctx)
         self.cached_processors[processor_name] = current_processor
 
         return current_processor
@@ -151,6 +163,18 @@ class NativeAppCompiler:
         return False
 
     def _is_enabled(self, processor: ProcessorMapping) -> bool:
-        if processor.name.lower() == NA_SETUP_PROCESSOR:
-            return FeatureFlag.ENABLE_NATIVE_APP_PYTHON_SETUP.is_enabled()
-        return True
+        """
+        Determines is a process is enabled. All processors are considered enabled
+        unless they are explicitly disabled, typically via a feature flag.
+        """
+        processor_name = processor.name.lower()
+        processor_cls = self._processor_classes_by_name.get(processor_name)
+        if processor_cls is None:
+            # Unknown processor, consider it enabled, even though trying to
+            # invoke it later will raise an exception
+            return True
+
+        # if the processor class defines a static method named "is_enabled", then
+        # call it. Otherwise, it's considered enabled by default.
+        is_enabled_fn = getattr(processor_cls, "is_enabled", lambda: True)
+        return is_enabled_fn()

snowflake/cli/_plugins/nativeapp/codegen/setup/native_app_setup_processor.py

@@ -36,6 +36,7 @@ from snowflake.cli._plugins.nativeapp.codegen.sandbox import (
     SandboxEnvBuilder,
     execute_script_in_sandbox,
 )
+from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.stage.diff import to_stage_path
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import (
@@ -74,9 +75,15 @@ def safe_set(d: dict, *keys: str, **kwargs) -> None:
 
 
 class NativeAppSetupProcessor(ArtifactProcessor):
+    NAME = "native app setup"
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+    @staticmethod
+    def is_enabled() -> bool:
+        return FeatureFlag.ENABLE_NATIVE_APP_PYTHON_SETUP.is_enabled()
+
     def process(
         self,
         artifact_to_process: PathMapping,

snowflake/cli/_plugins/nativeapp/codegen/snowpark/python_processor.py

@@ -48,7 +48,7 @@ from snowflake.cli._plugins.nativeapp.codegen.snowpark.models import (
     NativeAppExtensionFunction,
 )
 from snowflake.cli._plugins.stage.diff import to_stage_path
-from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.cli_global_context import get_cli_context, span
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import (
@@ -164,9 +164,12 @@ class SnowparkAnnotationProcessor(ArtifactProcessor):
     and generate SQL code for creation of extension functions based on those discovered objects.
     """
 
+    NAME = "snowpark"
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+    @span("snowpark_processor")
     def process(
         self,
         artifact_to_process: PathMapping,

snowflake/cli/_plugins/nativeapp/codegen/templates/templates_processor.py

@@ -23,7 +23,7 @@ from snowflake.cli._plugins.nativeapp.codegen.artifact_processor import (
     ArtifactProcessor,
 )
 from snowflake.cli._plugins.nativeapp.exceptions import InvalidTemplateInFileError
-from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.cli_global_context import get_cli_context, span
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import (
@@ -49,6 +49,8 @@ class TemplatesProcessor(ArtifactProcessor):
     Processor class to perform template expansion on all relevant artifacts (specified in the project definition file).
     """
 
+    NAME = "templates"
+
     def expand_templates_in_file(
         self, src: Path, dest: Path, template_context: dict[str, Any] | None = None
     ) -> None:
@@ -58,39 +60,47 @@ class TemplatesProcessor(ArtifactProcessor):
         if src.is_dir():
             return
 
-        with self.edit_file(dest) as file:
-            if not has_client_side_templates(file.contents) and not (
-                _is_sql_file(dest) and has_sql_templates(file.contents)
-            ):
-                return
-
-            src_file_name = src.relative_to(self._bundle_ctx.project_root)
-            cc.step(f"Expanding templates in {src_file_name}")
-            with cc.indented():
-                try:
-                    jinja_env = (
-                        choose_sql_jinja_env_based_on_template_syntax(
-                            file.contents, reference_name=src_file_name
+        src_file_name = src.relative_to(self._bundle_ctx.project_root)
+
+        try:
+            with self.edit_file(dest) as file:
+                if not has_client_side_templates(file.contents) and not (
+                    _is_sql_file(dest) and has_sql_templates(file.contents)
+                ):
+                    return
+                cc.step(f"Expanding templates in {src_file_name}")
+                with cc.indented():
+                    try:
+                        jinja_env = (
+                            choose_sql_jinja_env_based_on_template_syntax(
+                                file.contents, reference_name=src_file_name
+                            )
+                            if _is_sql_file(dest)
+                            else get_client_side_jinja_env()
+                        )
+                        expanded_template = jinja_env.from_string(file.contents).render(
+                            template_context or get_cli_context().template_context
                         )
-                        if _is_sql_file(dest)
-                        else get_client_side_jinja_env()
-                    )
-                    expanded_template = jinja_env.from_string(file.contents).render(
-                        template_context or get_cli_context().template_context
-                    )
-
-                # For now, we are printing the source file path in the error message
-                # instead of the destination file path to make it easier for the user
-                # to identify the file that has the error, and edit the correct file.
-                except jinja2.TemplateSyntaxError as e:
-                    raise InvalidTemplateInFileError(src_file_name, e, e.lineno) from e
-
-                except jinja2.UndefinedError as e:
-                    raise InvalidTemplateInFileError(src_file_name, e) from e
-
-                if expanded_template != file.contents:
-                    file.edited_contents = expanded_template
 
+                    # For now, we are printing the source file path in the error message
+                    # instead of the destination file path to make it easier for the user
+                    # to identify the file that has the error, and edit the correct file.
+                    except jinja2.TemplateSyntaxError as e:
+                        raise InvalidTemplateInFileError(
+                            src_file_name, e, e.lineno
+                        ) from e
+
+                    except jinja2.UndefinedError as e:
+                        raise InvalidTemplateInFileError(src_file_name, e) from e
+
+                    if expanded_template != file.contents:
+                        file.edited_contents = expanded_template
+        except UnicodeDecodeError as err:
+            cc.warning(
+                f"Could not read file {src_file_name}, error: {err.reason}. Skipping this file."
+            )
+
+    @span("templates_processor")
     def process(
         self,
         artifact_to_process: PathMapping,