snowflake-cli 3.9.1__py3-none-any.whl → 3.10.0__py3-none-any.whl

snowflake/cli/api/entities/common.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Generic, List, Optional, Type, TypeVar, get_args
 
 from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
-from snowflake.cli.api.cli_global_context import get_cli_context, span
+from snowflake.cli.api.cli_global_context import span
 from snowflake.cli.api.entities.resolver import Dependency, DependencyResolver
 from snowflake.cli.api.entities.utils import EntityActions, get_sql_executor
 from snowflake.cli.api.identifiers import FQN
@@ -102,8 +102,8 @@ class EntityBase(Generic[T]):
     ) -> SqlExecutor:
         return get_sql_executor()
 
-    def _execute_query(self, sql: str) -> SnowflakeCursor:
-        return self._sql_executor.execute_query(sql)
+    def _execute_query(self, sql: str, **kwargs) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(sql, **kwargs)
 
     @functools.cached_property
     def _conn(self) -> SnowflakeConnection:
@@ -117,13 +117,6 @@ class EntityBase(Generic[T]):
     def schema(self) -> Optional[str]:
         return self.get_from_fqn_or_conn("schema")
 
-    @property
-    def snow_api_root(self) -> Optional[object]:
-        root = get_cli_context().snow_api_root
-        if root is None:
-            raise ValueError("snow_api_root is not set")
-        return root
-
     @property
     def model(self) -> T:
         return self._entity_model
@@ -140,12 +133,22 @@ class EntityBase(Generic[T]):
     def get_drop_sql(self) -> str:
         return f"DROP {self.model.type.upper()} {self.identifier};"  # type: ignore[attr-defined]
 
-    def _get_identifier(
+    def _get_fqn(
         self, schema: Optional[str] = None, database: Optional[str] = None
-    ) -> str:
+    ) -> FQN:
         schema_to_use = schema or self._entity_model.fqn.schema or self._conn.schema  # type: ignore
         db_to_use = database or self._entity_model.fqn.database or self._conn.database  # type: ignore
-        return f"{self._entity_model.fqn.set_schema(schema_to_use).set_database(db_to_use).sql_identifier}"  # type: ignore
+        return self._entity_model.fqn.set_schema(schema_to_use).set_database(db_to_use)  # type: ignore
+
+    def _get_sql_identifier(
+        self, schema: Optional[str] = None, database: Optional[str] = None
+    ) -> str:
+        return str(self._get_fqn(schema, database).sql_identifier)
+
+    def _get_identifier(
+        self, schema: Optional[str] = None, database: Optional[str] = None
+    ) -> str:
+        return str(self._get_fqn(schema, database).identifier)
 
     def get_from_fqn_or_conn(self, attribute_name: str) -> str:
         attribute = getattr(self.fqn, attribute_name, None) or getattr(

snowflake/cli/api/entities/utils.py

@@ -86,11 +86,12 @@ def sync_deploy_root_with_stage(
     bundle_map: BundleMap,
     prune: bool,
     recursive: bool,
-    stage_path: StagePathParts,
+    stage_path_parts: StagePathParts,
     role: str | None = None,
     package_name: str | None = None,
     local_paths_to_sync: List[Path] | None = None,
     print_diff: bool = True,
+    force_overwrite: bool = False,
 ) -> DiffResult:
     """
     Ensures that the files on our remote stage match the artifacts we have in
@@ -101,27 +102,31 @@ def sync_deploy_root_with_stage(
         role (str): The name of the role to use for queries and commands.
         prune (bool): Whether to prune artifacts from the stage that don't exist locally.
         recursive (bool): Whether to traverse directories recursively.
-        stage_path (DefaultStagePathParts): stage path object.
+        stage_path_parts (StagePathParts): stage path parts object.
 
         package_name (str): supported for Native App compatibility. Should be None out of Native App context.
 
         local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
         local paths. Note that providing an empty list here is equivalent to None.
         print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
+        force_overwrite (bool): Some resources (e.g. streamlit) need to overwrite files on the stage. Defaults to False.
 
     Returns:
         A `DiffResult` instance describing the changes that were performed.
     """
-    if not package_name:
+    if stage_path_parts.is_vstage:
+        # vstages are created by FBE, so no need to do it manually
+        pass
+    elif not package_name:
         # ensure stage exists
-        stage_fqn = FQN.from_stage(stage_path.stage)
+        stage_fqn = FQN.from_stage(stage_path_parts.stage)
         console.step(f"Creating stage {stage_fqn} if not exists.")
         StageManager().create(fqn=stage_fqn)
     else:
         # ensure stage exists - nativeapp behavior
         sql_facade = get_snowflake_facade()
-        schema = stage_path.schema
-        stage_fqn = stage_path.stage
+        schema = stage_path_parts.schema
+        stage_fqn = stage_path_parts.stage
         # Does a stage already exist within the application package, or we need to create one?
         # Using "if not exists" should take care of either case.
         console.step(
@@ -134,12 +139,12 @@ def sync_deploy_root_with_stage(
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
         console.step(
-            f"Performing a diff between the Snowflake stage: {stage_path.path} and your local deploy_root: {deploy_root.resolve()}."
+            f"Performing a diff between the Snowflake stage: {stage_path_parts.path} and your local deploy_root: {deploy_root.resolve()}."
         )
 
     diff: DiffResult = compute_stage_diff(
         local_root=deploy_root,
-        stage_path=stage_path,
+        stage_path=stage_path_parts,
     )
 
     if local_paths_to_sync:
@@ -201,7 +206,8 @@ def sync_deploy_root_with_stage(
             role=role,
             deploy_root_path=deploy_root,
             diff_result=diff,
-            stage_full_path=stage_path.full_path,
+            stage_full_path=stage_path_parts.full_path,
+            force_overwrite=force_overwrite,
         )
     return diff
 

snowflake/cli/api/feature_flags.py

@@ -50,16 +50,12 @@ class FeatureFlagMixin(Enum):
             is not None
         )
 
-    def env_variable(self):
+    def env_variable(self) -> str:
         return get_env_variable_name(*FEATURE_FLAGS_SECTION_PATH, key=self.value.name)
 
 
 @unique
 class FeatureFlag(FeatureFlagMixin):
-    ENABLE_STREAMLIT_EMBEDDED_STAGE = BooleanFlag(
-        "ENABLE_STREAMLIT_EMBEDDED_STAGE", False
-    )
-    ENABLE_STREAMLIT_NO_CHECKOUTS = BooleanFlag("ENABLE_STREAMLIT_NO_CHECKOUTS", False)
     ENABLE_STREAMLIT_VERSIONED_STAGE = BooleanFlag(
         "ENABLE_STREAMLIT_VERSIONED_STAGE", False
     )
@@ -76,3 +72,4 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_NATIVE_APP_CHILDREN = BooleanFlag("ENABLE_NATIVE_APP_CHILDREN", False)
     # TODO 4.0: remove ENABLE_RELEASE_CHANNELS
     ENABLE_RELEASE_CHANNELS = BooleanFlag("ENABLE_RELEASE_CHANNELS", None)
+    ENABLE_SNOWFLAKE_PROJECTS = BooleanFlag("ENABLE_SNOWFLAKE_PROJECTS", False)

snowflake/cli/api/output/formats.py

@@ -18,3 +18,9 @@ from enum import Enum
 class OutputFormat(Enum):
     TABLE = "TABLE"
     JSON = "JSON"
+    JSON_EXT = "JSON_EXT"
+    CSV = "CSV"
+
+    @property
+    def is_json(self) -> bool:
+        return self in (OutputFormat.JSON, OutputFormat.JSON_EXT)

snowflake/cli/api/output/types.py

@@ -16,11 +16,22 @@ from __future__ import annotations
 
 import json
 import typing as t
+from enum import IntEnum
 
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.connector import DictCursor
 from snowflake.connector.cursor import SnowflakeCursor
 
 
+class SnowflakeColumnType(IntEnum):
+    """Snowflake column type codes for JSON-capable data types."""
+
+    VARIANT = 5
+    OBJECT = 9
+    ARRAY = 10
+
+
 class CommandResult:
     @property
     def result(self):
@@ -69,13 +80,48 @@ class StreamResult(CommandResult):
 class QueryResult(CollectionResult):
     def __init__(self, cursor: SnowflakeCursor | DictCursor):
         self.column_names = [col.name for col in cursor.description]
+        # Store column type information to identify VARIANT columns (JSON data)
+        self.column_types = [col.type_code for col in cursor.description]
         super().__init__(elements=self._prepare_payload(cursor))
         self._query = cursor.query
 
     def _prepare_payload(self, cursor: SnowflakeCursor | DictCursor):
         if isinstance(cursor, DictCursor):
-            return (k for k in cursor)
-        return ({k: v for k, v in zip(self.column_names, row)} for row in cursor)
+            return (self._process_columns(k) for k in cursor)
+        return (
+            self._process_columns({k: v for k, v in zip(self.column_names, row)})
+            for row in cursor
+        )
+
+    def _process_columns(self, row_dict):
+        if get_cli_context().output_format != OutputFormat.JSON_EXT:
+            return row_dict
+
+        processed_row = {}
+        for i, (column_name, value) in enumerate(row_dict.items()):
+            # Check if this column can contain JSON data
+            if i < len(self.column_types) and self.column_types[i] in (
+                SnowflakeColumnType.VARIANT,
+                SnowflakeColumnType.OBJECT,
+                SnowflakeColumnType.ARRAY,
+            ):
+                # For ARRAY and OBJECT types, the values are always JSON strings that need parsing
+                # For VARIANT types, only parse if the value is a string
+                if self.column_types[i] in (
+                    SnowflakeColumnType.OBJECT,
+                    SnowflakeColumnType.ARRAY,
+                ) or isinstance(value, str):
+                    try:
+                        # Try to parse as JSON
+                        processed_row[column_name] = json.loads(value)
+                    except (json.JSONDecodeError, TypeError):
+                        # If parsing fails, keep the original value
+                        processed_row[column_name] = value
+                else:
+                    processed_row[column_name] = value
+            else:
+                processed_row[column_name] = value
+        return processed_row
 
     @property
     def query(self):

snowflake/cli/api/rendering/sql_templates.py

@@ -14,19 +14,21 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Dict, Optional
 
 from click import ClickException
 from jinja2 import Environment, StrictUndefined, loaders, meta
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console.console import cli_console
-from snowflake.cli.api.exceptions import InvalidTemplateError
+from snowflake.cli.api.exceptions import CliArgumentError, InvalidTemplateError
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.rendering.jinja import (
     CONTEXT_KEY,
     FUNCTION_KEY,
     IgnoreAttrEnvironment,
     env_bootstrap,
+    get_basic_jinja_env,
 )
 
 _SQL_TEMPLATE_START = "<%"
@@ -63,11 +65,19 @@ def has_sql_templates(template_content: str) -> bool:
     )
 
 
+def _get_legacy_sql_env() -> Environment:
+    return _get_sql_jinja_env(_OLD_SQL_TEMPLATE_START, _OLD_SQL_TEMPLATE_END)
+
+
+def _get_standard_sql_env() -> Environment:
+    return _get_sql_jinja_env(_SQL_TEMPLATE_START, _SQL_TEMPLATE_END)
+
+
 def choose_sql_jinja_env_based_on_template_syntax(
     template_content: str, reference_name: Optional[str] = None
 ) -> Environment:
-    old_syntax_env = _get_sql_jinja_env(_OLD_SQL_TEMPLATE_START, _OLD_SQL_TEMPLATE_END)
-    new_syntax_env = _get_sql_jinja_env(_SQL_TEMPLATE_START, _SQL_TEMPLATE_END)
+    old_syntax_env = _get_legacy_sql_env()
+    new_syntax_env = _get_standard_sql_env()
     has_old_syntax = _does_template_have_env_syntax(old_syntax_env, template_content)
     has_new_syntax = _does_template_have_env_syntax(new_syntax_env, template_content)
     reference_name_str = f" in {reference_name}" if reference_name else ""
@@ -86,7 +96,29 @@ def choose_sql_jinja_env_based_on_template_syntax(
     return new_syntax_env
 
 
-def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
+@dataclass
+class SQLTemplateSyntaxConfig:
+    """Class defining which syntax should be used for the template resolution.
+    Jinja syntax is not recommended and should be disabled by default."""
+
+    enable_legacy_syntax: bool = True
+    enable_standard_syntax: bool = True
+    enable_jinja_syntax: bool = False
+
+
+def snowflake_sql_jinja_render(
+    content: str,
+    template_syntax_config: SQLTemplateSyntaxConfig,
+    data: Dict | None = None,
+) -> str:
+    """
+    If both legacy and standard syntax are enabled, CLI chooses one basing on provided content.
+    If jinja syntax is enabled, it is resolved after standard and legacy syntax.
+    """
+    # Jinja syntax is server-side templating, it should not be resolved by CLI by default.
+    # The main use case for adding support for it on CLI side is for testing scripts before running them on server,
+    # which is why jinja templates are resolved after standard CLI templates.
+
     data = data or {}
 
     for reserved_key in RESERVED_KEYS:
@@ -94,13 +126,37 @@ def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
             raise ClickException(
                 f"{reserved_key} in user defined data. The `{reserved_key}` variable is reserved for CLI usage."
             )
-
-    context_data = get_cli_context().template_context
-    context_data.update(data)
-    env = choose_sql_jinja_env_based_on_template_syntax(content)
-
+    has_templates = has_sql_templates(content)
     get_cli_context().metrics.set_counter(
-        CLICounterField.SQL_TEMPLATES, int(has_sql_templates(content))
+        CLICounterField.SQL_TEMPLATES, int(has_templates)
     )
+    context_data = {}
+    if has_templates:
+        try:
+            context_data = get_cli_context().template_context
+        except Exception as e:
+            raise CliArgumentError(f"Failed to read snowflake.yml file: {e}")
+    context_data.update(data)
 
-    return env.from_string(content).render(context_data)
+    # resolve legacy and standard SQL templating:
+    if (
+        template_syntax_config.enable_legacy_syntax
+        and template_syntax_config.enable_standard_syntax
+    ):
+        env = choose_sql_jinja_env_based_on_template_syntax(content)
+    elif template_syntax_config.enable_legacy_syntax:
+        env = _get_legacy_sql_env()
+    elif template_syntax_config.enable_standard_syntax:
+        env = _get_standard_sql_env()
+    else:
+        env = None
+
+    if env:
+        content = env.from_string(content).render(context_data)
+
+    # resolve jinja templating
+    if template_syntax_config.enable_jinja_syntax:
+        jinja_env = get_basic_jinja_env()
+        content = jinja_env.from_string(content).render(context_data)
+
+    return content

snowflake/cli/api/stage_path.py

@@ -9,6 +9,7 @@ from snowflake.cli.api.project.util import (
 )
 
 USER_STAGE_PREFIX = "~"
+SNOW_PREFIX = "snow://"
 
 
 class StagePath:
@@ -19,6 +20,7 @@ class StagePath:
         git_ref: str | None = None,
         trailing_slash: bool = False,
     ):
+        self._is_snow_prefixed_stage = stage_name.startswith(SNOW_PREFIX)
         self._stage_name = self.strip_stage_prefixes(stage_name)
         self._path = PurePosixPath(path) if path else PurePosixPath(".")
 
@@ -53,6 +55,10 @@ class StagePath:
     def stage_with_at(self) -> str:
         return self.add_at_prefix(self._stage_name)
 
+    @property
+    def stage_with_snow(self) -> str:
+        return self.add_snow_prefix(self._stage_name)
+
     def is_user_stage(self) -> bool:
         return self._is_user_stage
 
@@ -69,6 +75,12 @@ class StagePath:
             return "@" + text
         return text
 
+    @staticmethod
+    def add_snow_prefix(text: str):
+        if not text.startswith(SNOW_PREFIX):
+            return SNOW_PREFIX + text
+        return text
+
     @staticmethod
     def strip_at_prefix(text: str):
         if text.startswith("@"):
@@ -77,8 +89,8 @@ class StagePath:
 
     @staticmethod
     def strip_snow_prefix(text: str):
-        if text.startswith("snow://"):
-            return text[len("snow://") :]
+        if text.startswith(SNOW_PREFIX):
+            return text[len(SNOW_PREFIX) :]
         return text
 
     @classmethod
@@ -86,8 +98,15 @@ class StagePath:
         return cls.strip_at_prefix(cls.strip_snow_prefix(text))
 
     @classmethod
-    def from_stage_str(cls, stage_str: str | FQN):
+    def from_stage_str(cls, stage_str: str | FQN) -> StagePath:
+        _is_at_prefixed = str(stage_str).startswith("@")
+        _is_snow_prefixed = str(stage_str).startswith(SNOW_PREFIX)
         stage_str = cls.strip_stage_prefixes(str(stage_str))
+        if _is_snow_prefixed:
+            resource_type = stage_str.split("/", maxsplit=1)[0]
+            stage_str = stage_str.removeprefix(resource_type + "/")
+        else:
+            resource_type = ""
         parts = stage_str.split("/", maxsplit=1)
         parts = [p for p in parts if p]
         if len(parts) == 2:
@@ -95,9 +114,14 @@ class StagePath:
         else:
             stage_string = parts[0]
             path = None
-        return cls(
+        if _is_at_prefixed:
+            stage_string = cls.add_at_prefix(stage_string)
+        if _is_snow_prefixed:
+            stage_string = cls.add_snow_prefix(resource_type + "/" + stage_string)
+        stage_path = cls(
             stage_name=stage_string, path=path, trailing_slash=stage_str.endswith("/")
         )
+        return stage_path
 
     @classmethod
     def from_git_str(cls, git_str: str):
@@ -105,9 +129,15 @@ class StagePath:
         @configuration_repo / branches/main  / scripts/setup.sql
         @configuration_repo / branches/"foo/main"  / scripts/setup.sql
         """
+        _is_at_prefixed = git_str.startswith("@")
+        _is_snow_prefixed = git_str.startswith(SNOW_PREFIX)
         repo_name, git_ref, path = cls._split_repo_path(
             cls.strip_stage_prefixes(git_str)
         )
+        if _is_at_prefixed:
+            repo_name = cls.add_at_prefix(repo_name)
+        if _is_snow_prefixed:
+            repo_name = cls.add_snow_prefix(repo_name)
         return cls(
             stage_name=repo_name,
             path=path,
@@ -150,7 +180,9 @@ class StagePath:
             path = path / self._path
 
         str_path = str(path)
-        if at_prefix:
+        if self._is_snow_prefixed_stage:
+            str_path = self.add_snow_prefix(str_path)
+        elif at_prefix:
             str_path = self.add_at_prefix(str_path)
 
         if self._trailing_slash:

{snowflake_cli-3.9.1.dist-info → snowflake_cli-3.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-cli
-Version: 3.9.1
+Version: 3.10.0
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues
@@ -217,33 +217,66 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: SQL
 Classifier: Topic :: Database
 Requires-Python: >=3.10
+Requires-Dist: annotated-types==0.7.0
+Requires-Dist: asn1crypto==1.5.1
+Requires-Dist: boto3==1.39.2
+Requires-Dist: botocore==1.39.2
+Requires-Dist: certifi==2025.6.15
+Requires-Dist: cffi==1.17.1
+Requires-Dist: cfgv==3.4.0
+Requires-Dist: charset-normalizer==3.4.2
 Requires-Dist: click==8.1.8
+Requires-Dist: cryptography==45.0.5
+Requires-Dist: faker==37.4.0
+Requires-Dist: filelock==3.18.0
+Requires-Dist: gitdb==4.0.12
 Requires-Dist: gitpython==3.1.44
+Requires-Dist: identify==2.6.12
+Requires-Dist: idna==3.10
+Requires-Dist: iniconfig==2.1.0
 Requires-Dist: jinja2==3.1.6
+Requires-Dist: keyring==25.6.0
+Requires-Dist: markdown-it-py==3.0.0
+Requires-Dist: markupsafe==3.0.2
+Requires-Dist: nodeenv==1.9.1
 Requires-Dist: packaging
 Requires-Dist: pip
+Requires-Dist: platformdirs==4.3.8
 Requires-Dist: pluggy==1.6.0
 Requires-Dist: prompt-toolkit==3.0.51
-Requires-Dist: pydantic==2.11.4
+Requires-Dist: pydantic-core==2.33.2
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: pygments==2.19.2
+Requires-Dist: pyjwt==2.10.1
+Requires-Dist: pyopenssl==25.1.0
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: pytz==2025.2
 Requires-Dist: pyyaml==6.0.2
-Requires-Dist: requests==2.32.3
-Requires-Dist: requirements-parser==0.11.0
+Requires-Dist: requests==2.32.4
+Requires-Dist: requirements-parser==0.13.0
 Requires-Dist: rich==14.0.0
-Requires-Dist: setuptools==80.3.1
+Requires-Dist: setuptools==80.8.0
+Requires-Dist: shellingham==1.5.4
 Requires-Dist: snowflake-connector-python[secure-local-storage]==3.15.0
-Requires-Dist: snowflake-core==1.4.0
-Requires-Dist: snowflake-snowpark-python<1.26.0,>=1.15.0; python_version < '3.12'
-Requires-Dist: tomlkit==0.13.2
-Requires-Dist: typer==0.15.2
-Requires-Dist: urllib3<2.5,>=1.24.3
+Requires-Dist: snowflake-core==1.5.1
+Requires-Dist: snowflake-snowpark-python==1.33.0; python_version < '3.12'
+Requires-Dist: sortedcontainers==2.4.0
+Requires-Dist: tomlkit==0.13.3
+Requires-Dist: typer==0.16.0
+Requires-Dist: typing-extensions==4.14.0
+Requires-Dist: typing-inspection==0.4.1
+Requires-Dist: urllib3<2.6,>=1.24.3
+Requires-Dist: virtualenv==20.31.2
+Requires-Dist: wcwidth==0.2.13
+Requires-Dist: werkzeug==3.1.3
 Provides-Extra: development
 Requires-Dist: coverage==7.8.0; extra == 'development'
 Requires-Dist: factory-boy==3.3.3; extra == 'development'
-Requires-Dist: faker==37.3.0; extra == 'development'
+Requires-Dist: faker==37.4.0; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'
 Requires-Dist: pytest-httpserver==1.1.3; extra == 'development'
 Requires-Dist: pytest-randomly==3.16.0; extra == 'development'
-Requires-Dist: pytest==8.3.5; extra == 'development'
+Requires-Dist: pytest==8.4.1; extra == 'development'
 Requires-Dist: syrupy==4.9.1; extra == 'development'
 Provides-Extra: packaging
 Description-Content-Type: text/markdown