snowflake-cli 3.0.2__py3-none-any.whl → 3.1.0__py3-none-any.whl

snowflake/cli/api/project/schemas/project_definition.py

@@ -19,6 +19,7 @@ from typing import Any, Dict, List, Optional, Union
 
 from packaging.version import Version
 from pydantic import Field, ValidationError, field_validator, model_validator
+from pydantic_core.core_schema import ValidationInfo
 from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
 from snowflake.cli.api.project.errors import SchemaValidationError
 from snowflake.cli.api.project.schemas.entities.common import (
@@ -115,7 +116,17 @@ class DefinitionV11(DefinitionV10):
 
 
 class DefinitionV20(_ProjectDefinitionBase):
-    entities: Dict[str, AnnotatedEntity] = Field(title="Entity definitions.")
+    entities: Dict[str, AnnotatedEntity] = Field(
+        title="Entity definitions.", default={}
+    )
+    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
+        default=None,
+    )
+    mixins: Optional[Dict[str, Dict]] = Field(
+        title="Mixins to apply to entities",
+        default=None,
+    )
 
     @model_validator(mode="after")
     def validate_entities_identifiers(self):
@@ -163,38 +174,32 @@ class DefinitionV20(_ProjectDefinitionBase):
                 f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
             )
 
-    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
-        title="Default environment specification for this project.",
-        default=None,
-    )
-
-    mixins: Optional[Dict[str, Dict]] = Field(
-        title="Mixins to apply to entities",
-        default=None,
-    )
-
     @model_validator(mode="before")
     @classmethod
-    def apply_mixins(cls, data: Dict) -> Dict:
+    def apply_mixins(cls, data: Dict, info: ValidationInfo) -> Dict:
         """
         Applies mixins to those entities, whose meta field contains the mixin name.
         """
         if "mixins" not in data or "entities" not in data:
             return data
 
-        entities = data["entities"]
-        for entity_name, entity in entities.items():
-            entity_mixins = entity_mixins_to_list(
-                entity.get("meta", {}).get("use_mixins")
-            )
+        duplicated_run = (
+            info.context.get("is_duplicated_run", False) if info.context else False
+        )
+        if not duplicated_run:
+            entities = data["entities"]
+            for entity_name, entity in entities.items():
+                entity_mixins = entity_mixins_to_list(
+                    entity.get("meta", {}).get("use_mixins")
+                )
 
-            merged_values = cls._merge_mixins_with_entity(
-                entity_id=entity_name,
-                entity=entity,
-                entity_mixins_names=entity_mixins,
-                mixin_defs=data["mixins"],
-            )
-            entities[entity_name] = merged_values
+                merged_values = cls._merge_mixins_with_entity(
+                    entity_id=entity_name,
+                    entity=entity,
+                    entity_mixins_names=entity_mixins,
+                    mixin_defs=data["mixins"],
+                )
+                entities[entity_name] = merged_values
         return data
 
     @classmethod
@@ -325,6 +330,6 @@ def get_allowed_fields_for_entity(entity: Dict[str, Any]) -> List[str]:
 def _unique_extend(list_a: List, list_b: List) -> List:
     new_list = list(list_a)
     for item in list_b:
-        if item not in list_a:
+        if all(item != x for x in list_a):
             new_list.append(item)
     return new_list

snowflake/cli/api/sql_execution.py

@@ -25,8 +25,10 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import (
+    CouldNotUseObjectError,
     DatabaseNotProvidedError,
     SchemaNotProvidedError,
+    ShowSpecificObjectMultipleRowsError,
     SnowflakeSQLExecutionError,
 )
 from snowflake.cli.api.identifiers import FQN
@@ -91,11 +93,9 @@ class SqlExecutor:
     def use(self, object_type: ObjectType, name: str):
         try:
             self._execute_query(f"use {object_type.value.sf_name} {name}")
-        except ProgrammingError:
+        except ProgrammingError as err:
             # Rewrite the error to make the message more useful.
-            raise ProgrammingError(
-                f"Could not use {object_type} {name}. Object does not exist, or operation cannot be performed."
-            )
+            raise CouldNotUseObjectError(object_type=object_type, name=name) from err
 
     def current_role(self) -> str:
         return self._execute_query(f"select current_role()").fetchone()[0]
@@ -247,9 +247,7 @@ class SqlExecutor:
         if show_obj_cursor.rowcount is None:
             raise SnowflakeSQLExecutionError(show_obj_query)
         elif show_obj_cursor.rowcount > 1:
-            raise ProgrammingError(
-                f"Received multiple rows from result of SQL statement: {show_obj_query}. Usage of 'show_specific_object' may not be properly scoped."
-            )
+            raise ShowSpecificObjectMultipleRowsError(show_obj_query=show_obj_query)
 
         show_obj_row = find_first_row(
             show_obj_cursor,

snowflake/cli/api/stage_path.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path, PurePosixPath
+
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.util import (
+    to_string_literal,
+)
+
+USER_STAGE_PREFIX = "~"
+
+
+class StagePath:
+    def __init__(
+        self,
+        stage_name: str,
+        path: str | PurePosixPath | None = None,
+        git_ref: str | None = None,
+        trailing_slash: bool = False,
+    ):
+        self._stage_name = self.strip_stage_prefixes(stage_name)
+        self._path = PurePosixPath(path) if path else PurePosixPath(".")
+
+        self._trailing_slash = trailing_slash
+        # Check if user stage
+        self._is_user_stage = self._stage_name.startswith(USER_STAGE_PREFIX)
+
+        # Setup git information
+        self._git_ref = None
+        self._is_git_repo = False
+        if git_ref:
+            self._git_ref = git_ref
+            self._is_git_repo = True
+
+    @classmethod
+    def get_user_stage(cls) -> StagePath:
+        return cls.from_stage_str("~")
+
+    @property
+    def stage(self) -> str:
+        return self._stage_name
+
+    @property
+    def path(self) -> PurePosixPath:
+        return self._path
+
+    @property
+    def stage_with_at(self) -> str:
+        return self.add_at_prefix(self._stage_name)
+
+    def is_user_stage(self) -> bool:
+        return self._is_user_stage
+
+    def is_git_repo(self) -> bool:
+        return self._is_git_repo
+
+    @property
+    def git_ref(self) -> str | None:
+        return self._git_ref
+
+    @staticmethod
+    def add_at_prefix(text: str):
+        if not text.startswith("@"):
+            return "@" + text
+        return text
+
+    @staticmethod
+    def strip_at_prefix(text: str):
+        if text.startswith("@"):
+            return text[1:]
+        return text
+
+    @staticmethod
+    def strip_snow_prefix(text: str):
+        if text.startswith("snow://"):
+            return text[len("snow://") :]
+        return text
+
+    @classmethod
+    def strip_stage_prefixes(cls, text: str):
+        return cls.strip_at_prefix(cls.strip_snow_prefix(text))
+
+    @classmethod
+    def from_stage_str(cls, stage_str: str | FQN):
+        stage_str = cls.strip_stage_prefixes(str(stage_str))
+        parts = stage_str.split("/", maxsplit=1)
+        parts = [p for p in parts if p]
+        if len(parts) == 2:
+            stage_string, path = parts
+        else:
+            stage_string = parts[0]
+            path = None
+        return cls(
+            stage_name=stage_string, path=path, trailing_slash=stage_str.endswith("/")
+        )
+
+    @classmethod
+    def from_git_str(cls, git_str: str):
+        """
+        @configuration_repo / branches/main  / scripts/setup.sql
+        @configuration_repo / branches/"foo/main"  / scripts/setup.sql
+        """
+        repo_name, git_ref, path = cls._split_repo_path(
+            cls.strip_stage_prefixes(git_str)
+        )
+        return cls(
+            stage_name=repo_name,
+            path=path,
+            git_ref=git_ref,
+            trailing_slash=git_str.endswith("/"),
+        )
+
+    @staticmethod
+    def _split_repo_path(git_str: str) -> tuple[str, str, str]:
+        parts = []
+        slash_index = 0
+        skipping_mode = False
+        for current_idx, (char, next_char) in enumerate(zip(git_str[:-1], git_str[1:])):
+            if not skipping_mode:
+                if char != "/":
+                    continue
+
+                # Normal split
+                parts.append(git_str[slash_index:current_idx])
+                slash_index = current_idx + 1
+
+            if next_char == '"':
+                skipping_mode = not skipping_mode
+            # Add last part
+        parts.append(git_str[slash_index:])
+        repo_name = parts[0]
+        ref = parts[1] + "/" + parts[2]
+        path = "/".join(parts[3:]) if len(parts) > 2 else ""
+        return repo_name, ref, path
+
+    def absolute_path(self, no_fqn=False, at_prefix=True) -> str:
+        stage_name = self._stage_name
+        if not self.is_user_stage() and no_fqn:
+            stage_name = FQN.from_string(self._stage_name).name
+
+        path = PurePosixPath(stage_name)
+        if self.git_ref:
+            path = path / self.git_ref
+        if not self.is_root():
+            path = path / self._path
+
+        str_path = str(path)
+        if at_prefix:
+            str_path = self.add_at_prefix(str_path)
+
+        if self._trailing_slash:
+            return str_path.rstrip("/") + "/"
+        return str_path
+
+    def joinpath(self, path: str) -> StagePath:
+        if self.is_file():
+            raise ValueError("Cannot join path to a file")
+
+        return StagePath(
+            stage_name=self._stage_name,
+            path=PurePosixPath(self._path) / path.lstrip("/"),
+            git_ref=self._git_ref,
+        )
+
+    def __truediv__(self, path: str):
+        return self.joinpath(path)
+
+    def with_stage(self, stage_name: str) -> StagePath:
+        """Returns a new path with new stage name"""
+        return StagePath(
+            stage_name=stage_name,
+            path=self._path,
+            git_ref=self._git_ref,
+        )
+
+    @property
+    def parts(self) -> tuple[str, ...]:
+        return self._path.parts
+
+    @property
+    def name(self) -> str:
+        return self._path.name
+
+    def is_dir(self) -> bool:
+        return "." not in self.name
+
+    def is_file(self) -> bool:
+        return not self.is_dir()
+
+    @property
+    def suffix(self) -> str:
+        return self._path.suffix
+
+    @property
+    def stem(self) -> str:
+        return self._path.stem
+
+    @property
+    def parent(self) -> StagePath:
+        return StagePath(
+            stage_name=self._stage_name, path=self._path.parent, git_ref=self._git_ref
+        )
+
+    def is_root(self) -> bool:
+        return self._path == PurePosixPath(".")
+
+    def root_path(self) -> StagePath:
+        if self.is_git_repo():
+            return StagePath(stage_name=self._stage_name, git_ref=self._git_ref)
+        return StagePath(stage_name=self._stage_name)
+
+    def is_quoted(self) -> bool:
+        path = self.absolute_path()
+        return path.startswith("'") and path.endswith("'")
+
+    def path_for_sql(self) -> str:
+        path = self.absolute_path()
+        if not re.fullmatch(r"@([\w./$])+", path):
+            return to_string_literal(path)
+        return path
+
+    def quoted_absolute_path(self) -> str:
+        if self.is_quoted():
+            return self.absolute_path()
+        return to_string_literal(self.absolute_path())
+
+    def relative_to(self, stage_path: StagePath) -> PurePosixPath:
+        return self.path.relative_to(stage_path.path)
+
+    def get_local_target_path(self, target_dir: Path, stage_root: StagePath):
+        # Case for downloading @stage/aa/file.py with root @stage/aa
+        if self.relative_to(stage_root) == PurePosixPath("."):
+            return target_dir
+        return (target_dir / self.relative_to(stage_root)).parent
+
+    def __str__(self):
+        return self.absolute_path()
+
+    def __eq__(self, other):
+        return self.absolute_path() == other.absolute_path()

snowflake/cli/api/utils/definition_rendering.py

@@ -285,9 +285,7 @@ def _add_defaults_to_definition(original_definition: Definition) -> Definition:
     with context({"skip_validation_on_templates": True}):
         # pass a flag to Pydantic to skip validation for templated scalars
         # populate the defaults
-        project_definition = build_project_definition(
-            **copy.deepcopy(original_definition)
-        )
+        project_definition = build_project_definition(**original_definition)
 
     definition_with_defaults = project_definition.model_dump(
         exclude_none=True, warnings=False, by_alias=True
@@ -392,8 +390,8 @@ def render_definition_template(
         definition,
         update_action=lambda val: template_env.render(val, final_context),
     )
-
-    project_definition = build_project_definition(**definition)
+    with context({"is_duplicated_run": True}):
+        project_definition = build_project_definition(**definition)
 
     # Use the values originally provided by the user as the template context
     # This intentionally doesn't reflect any field changes made by

{snowflake_cli-3.0.2.dist-info → snowflake_cli-3.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli
-Version: 3.0.2
+Version: 3.1.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
@@ -226,7 +226,7 @@ Requires-Dist: pydantic==2.9.2
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: requests==2.32.3
 Requires-Dist: requirements-parser==0.11.0
-Requires-Dist: rich==13.8.1
+Requires-Dist: rich==13.9.2
 Requires-Dist: setuptools==75.1.0
 Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.2
 Requires-Dist: snowflake-core==0.12.1; python_version < '3.12'
@@ -235,11 +235,13 @@ Requires-Dist: tomlkit==0.13.2
 Requires-Dist: typer==0.12.5
 Requires-Dist: urllib3<2.3,>=1.24.3
 Provides-Extra: development
-Requires-Dist: coverage==7.6.1; extra == 'development'
+Requires-Dist: coverage==7.6.3; extra == 'development'
+Requires-Dist: factory-boy==3.3.1; extra == 'development'
+Requires-Dist: faker==30.3.0; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'
 Requires-Dist: pytest-randomly==3.15.0; extra == 'development'
 Requires-Dist: pytest==8.3.3; extra == 'development'
-Requires-Dist: syrupy==4.7.1; extra == 'development'
+Requires-Dist: syrupy==4.7.2; extra == 'development'
 Provides-Extra: packaging
 Requires-Dist: pyinstaller~=6.10; extra == 'packaging'
 Description-Content-Type: text/markdown
@@ -272,15 +274,13 @@ Snowflake CLI is an open-source command-line tool explicitly designed for develo
 
 With Snowflake CLI, developers can create, manage, update, and view apps running on Snowflake across workloads such as Streamlit in Snowflake, the Snowflake Native App Framework, Snowpark Container Services, and Snowpark. It supports a range of Snowflake features, including user-defined functions, stored procedures, Streamlit in Snowflake, and SQL execution.
 
-
 **Note**: Snowflake CLI is in Public Preview (PuPr).
 
-Docs: https://docs.snowflake.com/en/developer-guide/snowflake-cli-v2/index.
-
-Quick start: https://quickstarts.snowflake.com/guide/getting-started-with-snowflake-cli
+Docs: <https://docs.snowflake.com/en/developer-guide/snowflake-cli-v2/index>.
 
-Cheatsheet: https://github.com/Snowflake-Labs/sf-cheatsheets/blob/main/snowflake-cli.md
+Quick start: <https://quickstarts.snowflake.com/guide/getting-started-with-snowflake-cli>
 
+Cheatsheet: <https://github.com/Snowflake-Labs/sf-cheatsheets/blob/main/snowflake-cli.md>
 
 ## Install Snowflake CLI
 
@@ -289,7 +289,7 @@ Cheatsheet: https://github.com/Snowflake-Labs/sf-cheatsheets/blob/main/snowflake
 We recommend installing Snowflake CLI in isolated environment using [pipx](https://pipx.pypa.io/stable/). Requires Python >= 3.10
 
 ```bash
-pipx install snowflake-cli-labs
+pipx install snowflake-cli
 snow --help
 ```
 
@@ -322,4 +322,4 @@ You should now be able to run `snow` and get the CLI message.
 ## Get involved
 
 Have a feature idea? Running into a bug? Want to contribute? We'd love to hear from you!
-Please open or review issues, open pull requests, or reach out to us on developers@snowflake.com
+Please open or review issues, open pull requests, or reach out to us on <developers@snowflake.com>