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

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
@@ -40,19 +42,27 @@ from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
 
-class SqlExecutor:
-    def __init__(self, connection: SnowflakeConnection | None = None):
-        self._snowpark_session = None
+class BaseSqlExecutor:
+    """
+    Base class for executing SQL queries on a Snowflake connection.
+
+    This class provides methods to execute single or multiple SQL queries and handle the connection context.
+    It also includes logging capabilities.
+    """
+
+    def __init__(self, connection: SnowflakeConnection | None = None) -> None:
         self._connection = connection
 
     @property
     def _conn(self) -> SnowflakeConnection:
+        """Returns the current Snowflake connection, either from the instance or the global CLI context."""
         if self._connection:
             return self._connection
         return get_cli_context().connection
 
     @cached_property
     def _log(self):
+        """Returns a logger instance for logging debug information."""
         return logging.getLogger(__name__)
 
     def _execute_string(
@@ -75,30 +85,35 @@ class SqlExecutor:
         )
         return stream_generator if return_cursors else list()
 
-    def _execute_query(self, query: str, **kwargs):
-        *_, last_result = self._execute_queries(query, **kwargs)
+    def execute_query(self, query: str, **kwargs):
+        """Executes a single SQL query and returns the result"""
+        *_, last_result = list(self._execute_string(dedent(query), **kwargs))
         return last_result
 
-    def _execute_queries(self, queries: str, **kwargs):
+    def execute_queries(self, queries: str, **kwargs):
+        """Executes multiple SQL queries (passed as one string) and returns the results as a list"""
         return list(self._execute_string(dedent(queries), **kwargs))
 
-    def execute_query(self, query: str, **kwargs):
-        return self._execute_query(query, **kwargs)
 
-    def execute_queries(self, queries: str, **kwargs):
-        return self._execute_queries(queries, **kwargs)
+class SqlExecutor(BaseSqlExecutor):
+    """
+    SqlExecutor extends BaseSqlExecutor and provides additional methods to manage roles, warehouses,
+    and create specific objects like secrets and API integrations.
+    """
+
+    def __init__(self, connection: SnowflakeConnection | None = None):
+        super().__init__(connection)
+        self._snowpark_session = None
 
     def use(self, object_type: ObjectType, name: str):
         try:
-            self._execute_query(f"use {object_type.value.sf_name} {name}")
-        except ProgrammingError:
+            self.execute_query(f"use {object_type.value.sf_name} {name}")
+        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]
+        return self.execute_query(f"select current_role()").fetchone()[0]
 
     @contextmanager
     def use_role(self, new_role: str):
@@ -110,17 +125,15 @@ class SqlExecutor:
         is_different_role = new_role.lower() != prev_role.lower()
         if is_different_role:
             self._log.debug("Assuming different role: %s", new_role)
-            self._execute_query(f"use role {new_role}")
+            self.execute_query(f"use role {new_role}")
         try:
             yield
         finally:
             if is_different_role:
-                self._execute_query(f"use role {prev_role}")
+                self.execute_query(f"use role {prev_role}")
 
     def session_has_warehouse(self) -> bool:
-        result = self._execute_query(
-            "select current_warehouse() is not null"
-        ).fetchone()
+        result = self.execute_query("select current_warehouse() is not null").fetchone()
         return bool(result[0])
 
     @contextmanager
@@ -131,7 +144,7 @@ class SqlExecutor:
         If there is no default warehouse in the account, it will throw an error.
         """
 
-        wh_result = self._execute_query(f"select current_warehouse()").fetchone()
+        wh_result = self.execute_query(f"select current_warehouse()").fetchone()
         # If user has an assigned default warehouse, prev_wh will contain a value even if the warehouse is suspended.
         try:
             prev_wh = wh_result[0]
@@ -153,7 +166,7 @@ class SqlExecutor:
     def create_password_secret(
         self, name: FQN, username: str, password: str
     ) -> SnowflakeCursor:
-        return self._execute_query(
+        return self.execute_query(
             f"""
             create secret {name.sql_identifier}
             type = password
@@ -165,7 +178,7 @@ class SqlExecutor:
     def create_api_integration(
         self, name: FQN, api_provider: str, allowed_prefix: str, secret: Optional[str]
     ) -> SnowflakeCursor:
-        return self._execute_query(
+        return self.execute_query(
             f"""
             create api integration {name.sql_identifier}
             api_provider = {api_provider}
@@ -180,7 +193,7 @@ class SqlExecutor:
         Check that a database and schema are provided before executing the query. Useful for operating on schema level objects.
         """
         self.check_database_and_schema_provided(name)
-        return self._execute_query(query, **kwargs)
+        return self.execute_query(query, **kwargs)
 
     def check_database_and_schema_provided(self, name: Optional[str] = None) -> None:
         """
@@ -240,16 +253,14 @@ class SqlExecutor:
                 show_obj_query, name=name, cursor_class=DictCursor
             )
         else:
-            show_obj_cursor = self._execute_query(  # type: ignore
+            show_obj_cursor = self.execute_query(  # type: ignore
                 show_obj_query, cursor_class=DictCursor
             )
 
         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,244 @@
+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 | Path) -> StagePath:
+        if self.is_file():
+            raise ValueError("Cannot join path to a file")
+
+        return StagePath(
+            stage_name=self._stage_name,
+            path=PurePosixPath(self._path) / str(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 __repr__(self):
+        return str(self)
+
+    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.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli
-Version: 3.0.2
+Version: 3.2.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
@@ -206,7 +206,6 @@ License:                                  Apache License
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
-License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -226,20 +225,22 @@ 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: setuptools==75.1.0
-Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.2
+Requires-Dist: rich==13.9.4
+Requires-Dist: setuptools==75.3.0
+Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.3
 Requires-Dist: snowflake-core==0.12.1; python_version < '3.12'
 Requires-Dist: snowflake-snowpark-python>=1.15.0; python_version < '3.12'
 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.4; extra == 'development'
+Requires-Dist: factory-boy==3.3.1; extra == 'development'
+Requires-Dist: faker==30.8.2; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'
-Requires-Dist: pytest-randomly==3.15.0; extra == 'development'
+Requires-Dist: pytest-randomly==3.16.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 +273,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 +288,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 +321,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>