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

snowflake/cli/_plugins/stage/manager.py

@@ -17,16 +17,21 @@ from __future__ import annotations
 import fnmatch
 import glob
 import logging
+import os
 import re
+import shutil
 import sys
+import time
+from collections import deque
 from contextlib import nullcontext
 from dataclasses import dataclass
 from os import path
 from pathlib import Path
+from tempfile import TemporaryDirectory
 from textwrap import dedent
-from typing import Dict, List, Optional, Union
+from typing import Deque, Dict, Generator, List, Optional, Union
 
-from click import ClickException
+from click import ClickException, UsageError
 from snowflake.cli._plugins.snowpark.package_utils import parse_requirements
 from snowflake.cli.api.commands.common import (
     OnErrorType,
@@ -39,6 +44,7 @@ from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.util import to_string_literal
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.cli.api.stage_path import StagePath
 from snowflake.cli.api.utils.path_utils import path_resolver
 from snowflake.connector import DictCursor, ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
@@ -90,12 +96,12 @@ class StagePathParts:
         raise NotImplementedError
 
     def get_full_stage_path(self, path: str):
-        if prefix := FQN.from_stage(self.stage).prefix:
+        if prefix := FQN.from_stage_path(self.stage).prefix:
             return prefix + "." + path
         return path
 
     def get_standard_stage_path(self) -> str:
-        path = self.path
+        path = self.get_full_stage_path(self.path)
         return f"@{path}{'/'if self.is_directory and not path.endswith('/') else ''}"
 
     def get_standard_stage_directory_path(self) -> str:
@@ -104,6 +110,9 @@ class StagePathParts:
             return path + "/"
         return path
 
+    def strip_stage_prefix(self, path: str):
+        raise NotImplementedError
+
 
 @dataclass
 class DefaultStagePathParts(StagePathParts):
@@ -141,6 +150,13 @@ class DefaultStagePathParts(StagePathParts):
         file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
+    def strip_stage_prefix(self, file_path: str) -> str:
+        if file_path.startswith("@"):
+            file_path = file_path[OMIT_FIRST]
+        if file_path.startswith(self.stage_name):
+            return file_path[len(self.stage_name) :]
+        return file_path
+
     def add_stage_prefix(self, file_path: str) -> str:
         stage = self.stage.rstrip("/")
         return f"{stage}/{file_path.lstrip('/')}"
@@ -197,6 +213,10 @@ class StageManager(SqlExecutionMixin):
         super().__init__()
         self._python_exe_procedure = None
 
+    @staticmethod
+    def build_path(stage_path: str) -> StagePath:
+        return StagePath.from_stage_str(stage_path)
+
     @staticmethod
     def get_standard_stage_prefix(name: str | FQN) -> str:
         if isinstance(name, FQN):
@@ -234,12 +254,17 @@ class StageManager(SqlExecutionMixin):
             return uri
         return to_string_literal(uri)
 
-    def list_files(self, stage_name: str, pattern: str | None = None) -> DictCursor:
-        stage_name = self.get_standard_stage_prefix(stage_name)
-        query = f"ls {self.quote_stage_name(stage_name)}"
+    def list_files(
+        self, stage_name: str | StagePath, pattern: str | None = None
+    ) -> DictCursor:
+        if not isinstance(stage_name, StagePath):
+            stage_path = self.build_path(stage_name).path_for_sql()
+        else:
+            stage_path = stage_name.path_for_sql()
+        query = f"ls {stage_path}"
         if pattern is not None:
             query += f" pattern = '{pattern}'"
-        return self._execute_query(query, cursor_class=DictCursor)
+        return self.execute_query(query, cursor_class=DictCursor)
 
     @staticmethod
     def _assure_is_existing_directory(path: Path) -> None:
@@ -251,27 +276,27 @@ class StageManager(SqlExecutionMixin):
     def get(
         self, stage_path: str, dest_path: Path, parallel: int = 4
     ) -> SnowflakeCursor:
-        stage_path = self.get_standard_stage_prefix(stage_path)
+        spath = self.build_path(stage_path)
         self._assure_is_existing_directory(dest_path)
         dest_directory = f"{dest_path}/"
-        return self._execute_query(
-            f"get {self.quote_stage_name(stage_path)} {self._to_uri(dest_directory)} parallel={parallel}"
+        return self.execute_query(
+            f"get {spath.path_for_sql()} {self._to_uri(dest_directory)} parallel={parallel}"
         )
 
     def get_recursive(
         self, stage_path: str, dest_path: Path, parallel: int = 4
     ) -> List[SnowflakeCursor]:
-        stage_path_parts = self._stage_path_part_factory(stage_path)
+        stage_root = self.build_path(stage_path)
 
         results = []
-        for file_path in self.iter_stage(stage_path):
-            dest_directory = dest_path
-            for path_part in stage_path_parts.get_directory_from_file_path(file_path):
-                dest_directory = dest_directory / path_part
-            self._assure_is_existing_directory(dest_directory)
-
-            result = self._execute_query(
-                f"get {self.quote_stage_name(stage_path_parts.replace_stage_prefix(file_path))} {self._to_uri(f'{dest_directory}/')} parallel={parallel}"
+        for file_path in self.iter_stage(stage_root):
+            local_dir = file_path.get_local_target_path(
+                target_dir=dest_path, stage_root=stage_root
+            )
+            self._assure_is_existing_directory(local_dir)
+
+            result = self.execute_query(
+                f"get {file_path.path_for_sql()} {self._to_uri(f'{local_dir}/')} parallel={parallel}"
             )
             results.append(result)
 
@@ -285,6 +310,7 @@ class StageManager(SqlExecutionMixin):
         overwrite: bool = False,
         role: Optional[str] = None,
         auto_compress: bool = False,
+        use_dict_cursor: bool = False,
     ) -> SnowflakeCursor:
         """
         This method will take a file path from the user's system and put it into a Snowflake stage,
@@ -292,30 +318,157 @@ class StageManager(SqlExecutionMixin):
         If provided with a role, then temporarily use this role to perform the operation above,
         and switch back to the original role for the next commands to run.
         """
+        if "*" not in str(local_path):
+            local_path = (
+                os.path.join(local_path, "*")
+                if Path(local_path).is_dir()
+                else str(local_path)
+            )
         with self.use_role(role) if role else nullcontext():
-            stage_path = self.get_standard_stage_prefix(stage_path)
+            spath = self.build_path(stage_path)
             local_resolved_path = path_resolver(str(local_path))
             log.info("Uploading %s to %s", local_resolved_path, stage_path)
-            cursor = self._execute_query(
-                f"put {self._to_uri(local_resolved_path)} {self.quote_stage_name(stage_path)} "
-                f"auto_compress={str(auto_compress).lower()} parallel={parallel} overwrite={overwrite}"
+            cursor = self.execute_query(
+                f"put {self._to_uri(local_resolved_path)} {spath.path_for_sql()} "
+                f"auto_compress={str(auto_compress).lower()} parallel={parallel} overwrite={overwrite}",
+                cursor_class=DictCursor if use_dict_cursor else SnowflakeCursor,
             )
         return cursor
 
+    @staticmethod
+    def _symlink_or_copy(source_root: Path, source_file_or_dir: Path, dest_dir: Path):
+        from snowflake.cli._plugins.nativeapp.artifacts import resolve_without_follow
+
+        absolute_src = resolve_without_follow(source_file_or_dir)
+        dest_path = dest_dir / source_file_or_dir.relative_to(source_root)
+
+        if absolute_src.is_file():
+            try:
+                os.symlink(absolute_src, dest_path)
+            except OSError:
+                if not dest_path.parent.exists():
+                    dest_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(absolute_src, dest_path)
+        else:
+            dest_path.mkdir(exist_ok=True, parents=True)
+
+    def put_recursive(
+        self,
+        local_path: Path,
+        stage_path: str,
+        parallel: int = 4,
+        overwrite: bool = False,
+        role: Optional[str] = None,
+        auto_compress: bool = False,
+    ) -> Generator[dict, None, None]:
+        if local_path.is_file():
+            raise UsageError("Cannot use recursive upload with a single file.")
+
+        if local_path.is_dir():
+            root = local_path
+            glob_pattern = str(local_path / "**/*")
+        else:
+            root = Path([p for p in local_path.parents if p.is_dir()][0])
+            glob_pattern = str(local_path)
+
+        with TemporaryDirectory() as tmp:
+            temp_dir_with_copy = Path(tmp)
+
+            # Create a symlink or copy the file to the temp directory
+            for file_or_dir in glob.iglob(glob_pattern, recursive=True):
+                self._symlink_or_copy(
+                    source_root=root,
+                    source_file_or_dir=Path(file_or_dir),
+                    dest_dir=temp_dir_with_copy,
+                )
+
+            # Find the deepest directories, we will be iterating from bottom to top
+            deepest_dirs_list = self._find_deepest_directories(temp_dir_with_copy)
+
+            while deepest_dirs_list:
+                # Remove as visited
+                directory = deepest_dirs_list.pop(0)
+
+                # We reached root but there are still directories to process
+                if directory == temp_dir_with_copy and deepest_dirs_list:
+                    continue
+
+                # Upload the directory content, at this moment the directory has only files
+                if list(directory.iterdir()):
+                    destination = StagePath.from_stage_str(
+                        stage_path
+                    ) / directory.relative_to(temp_dir_with_copy)
+                    results: list[dict] = self.put(
+                        local_path=directory,
+                        stage_path=destination,
+                        parallel=parallel,
+                        overwrite=overwrite,
+                        role=role,
+                        auto_compress=auto_compress,
+                        use_dict_cursor=True,
+                    ).fetchall()
+
+                    # Rewrite results to have resolved paths for better UX
+                    for item in results:
+                        item["source"] = (directory / item["source"]).relative_to(
+                            temp_dir_with_copy
+                        )
+                        item["target"] = str(destination / item["target"])
+                        yield item
+
+                # We end if we reach the root directory
+                if directory == temp_dir_with_copy:
+                    break
+
+                # Add parent directory to the list if it's not already there
+                if directory.parent not in deepest_dirs_list:
+                    deepest_dirs_list.append(directory.parent)
+
+                # Remove the directory so the parent directory will contain only files
+                shutil.rmtree(directory)
+
+    @staticmethod
+    def _find_deepest_directories(root_directory: Path) -> list[Path]:
+        """
+        BFS to find the deepest directories. Build a tree of directories
+        structure and return leaves.
+        """
+        deepest_dirs: list[Path] = list()
+
+        queue: Deque[Path] = deque()
+        queue.append(root_directory)
+        while queue:
+            current_dir = queue.popleft()
+            # Sorted to have deterministic order
+            children_directories = sorted(
+                list(d for d in current_dir.iterdir() if d.is_dir())
+            )
+            if not children_directories and current_dir not in deepest_dirs:
+                deepest_dirs.append(current_dir)
+            else:
+                queue.extend([c for c in children_directories if c not in deepest_dirs])
+        deepest_dirs_list = sorted(
+            list(deepest_dirs), key=lambda d: len(d.parts), reverse=True
+        )
+        return deepest_dirs_list
+
     def copy_files(self, source_path: str, destination_path: str) -> SnowflakeCursor:
-        source_path_parts = self._stage_path_part_factory(source_path)
-        destination_path_parts = self._stage_path_part_factory(destination_path)
+        source_stage_path = self.build_path(source_path)
+        # We copy only into stage
+        destination_stage_path = StagePath.from_stage_str(destination_path)
 
-        if isinstance(destination_path_parts, UserStagePathParts):
+        if destination_stage_path.is_user_stage():
             raise ClickException(
                 "Destination path cannot be a user stage. Please provide a named stage."
             )
 
-        source = source_path_parts.get_standard_stage_path()
-        destination = destination_path_parts.get_standard_stage_directory_path()
-        log.info("Copying files from %s to %s", source, destination)
-        query = f"copy files into {destination} from {source}"
-        return self._execute_query(query)
+        log.info(
+            "Copying files from %s to %s", source_stage_path, destination_stage_path
+        )
+        # Destination needs to end with /
+        dest = destination_stage_path.absolute_path().rstrip("/") + "/"
+        query = f"copy files into {dest} from {source_stage_path}"
+        return self.execute_query(query)
 
     def remove(
         self, stage_name: str, path: str, role: Optional[str] = None
@@ -327,29 +480,48 @@ class StageManager(SqlExecutionMixin):
         and switch back to the original role for the next commands to run.
         """
         with self.use_role(role) if role else nullcontext():
-            stage_name = self.get_standard_stage_prefix(stage_name)
-            path = path if path.startswith("/") else "/" + path
-            quoted_stage_name = self.quote_stage_name(f"{stage_name}{path}")
-            return self._execute_query(f"remove {quoted_stage_name}")
+            stage_path = self.build_path(stage_name) / path
+            return self.execute_query(f"remove {stage_path.path_for_sql()}")
 
-    def create(self, fqn: FQN, comment: Optional[str] = None) -> SnowflakeCursor:
-        query = f"create stage if not exists {fqn.sql_identifier}"
+    def create(
+        self, fqn: FQN, comment: Optional[str] = None, temporary: bool = False
+    ) -> SnowflakeCursor:
+        temporary_str = "temporary " if temporary else ""
+        query = f"create {temporary_str}stage if not exists {fqn.sql_identifier}"
         if comment:
             query += f" comment='{comment}'"
-        return self._execute_query(query)
+        return self.execute_query(query)
 
-    def iter_stage(self, stage_path: str):
-        for file in self.list_files(stage_path).fetchall():
-            yield file["name"]
+    def iter_stage(self, stage_path: StagePath):
+        for file in self.list_files(stage_path.absolute_path()).fetchall():
+            if stage_path.is_user_stage():
+                path = StagePath.get_user_stage() / file["name"]
+            else:
+                path = self.build_path(file["name"])
+            yield path
 
     def execute(
         self,
-        stage_path: str,
+        stage_path_str: str,
         on_error: OnErrorType,
         variables: Optional[List[str]] = None,
+        requires_temporary_stage: bool = False,
     ):
-        stage_path_parts = self._stage_path_part_factory(stage_path)
-        all_files_list = self._get_files_list_from_stage(stage_path_parts)
+        if requires_temporary_stage:
+            (
+                stage_path_parts,
+                original_path_parts,
+            ) = self._create_temporary_copy_of_stage(stage_path_str)
+            stage_path = StagePath.from_stage_str(
+                stage_path_parts.get_standard_stage_path()
+            )
+        else:
+            stage_path_parts = self._stage_path_part_factory(stage_path_str)
+            stage_path = self.build_path(stage_path_str)
+
+        all_files_list = self._get_files_list_from_stage(stage_path.root_path())
+        if not all_files_list:
+            raise ClickException(f"No files found on stage '{stage_path}'")
 
         all_files_with_stage_name_prefix = [
             stage_path_parts.get_directory(file) for file in all_files_list
@@ -370,42 +542,75 @@ class StageManager(SqlExecutionMixin):
 
         parsed_variables = parse_key_value_variables(variables)
         sql_variables = self._parse_execute_variables(parsed_variables)
-        python_variables = {str(v.key): v.value for v in parsed_variables}
+        python_variables = self._parse_python_variables(parsed_variables)
         results = []
 
         if any(file.endswith(".py") for file in sorted_file_path_list):
             self._python_exe_procedure = self._bootstrap_snowpark_execution_environment(
-                stage_path_parts
+                stage_path
             )
 
         for file_path in sorted_file_path_list:
             file_stage_path = stage_path_parts.add_stage_prefix(file_path)
+
+            # For better reporting push down the information about original
+            # path if execution happens from temporary stage
+            if requires_temporary_stage:
+                original_path = original_path_parts.add_stage_prefix(file_path)
+            else:
+                original_path = file_stage_path
+
             if file_path.endswith(".py"):
                 result = self._execute_python(
                     file_stage_path=file_stage_path,
                     on_error=on_error,
                     variables=python_variables,
+                    original_file=original_path,
                 )
             else:
                 result = self._call_execute_immediate(
                     file_stage_path=file_stage_path,
                     variables=sql_variables,
                     on_error=on_error,
+                    original_file=original_path,
                 )
             results.append(result)
 
         return results
 
-    def _get_files_list_from_stage(
-        self, stage_path_parts: StagePathParts, pattern: str | None = None
-    ) -> List[str]:
-        files_list_result = self.list_files(
-            stage_path_parts.stage, pattern=pattern
-        ).fetchall()
+    def _create_temporary_copy_of_stage(
+        self, stage_path: str
+    ) -> tuple[StagePathParts, StagePathParts]:
+        sm = StageManager()
+
+        # Rewrite stage paths to temporary stage paths. Git paths become stage paths
+        original_path_parts = self._stage_path_part_factory(stage_path)  # noqa: SLF001
 
-        if not files_list_result:
-            raise ClickException(f"No files found on stage '{stage_path_parts.stage}'")
+        tmp_stage_name = f"snowflake_cli_tmp_stage_{int(time.time())}"
+        tmp_stage_fqn = FQN.from_stage(tmp_stage_name).using_connection(conn=self._conn)
+        tmp_stage = tmp_stage_fqn.identifier
+        stage_path_parts = sm._stage_path_part_factory(  # noqa: SLF001
+            tmp_stage + "/" + original_path_parts.directory
+        )
+
+        # Create temporary stage, it will be dropped with end of session
+        sm.create(tmp_stage_fqn, temporary=True)
+
+        # Copy the content
+        self.copy_files(
+            source_path=original_path_parts.get_full_stage_path(
+                original_path_parts.stage_name
+            ),
+            destination_path=stage_path_parts.get_full_stage_path(
+                stage_path_parts.stage_name
+            ),
+        )
+        return stage_path_parts, original_path_parts
 
+    def _get_files_list_from_stage(
+        self, stage_path: StagePath, pattern: str | None = None
+    ) -> List[str]:
+        files_list_result = self.list_files(stage_path, pattern=pattern).fetchall()
         return [f["name"] for f in files_list_result]
 
     def _filter_files_list(
@@ -444,6 +649,17 @@ class StageManager(SqlExecutionMixin):
         query_parameters = [f"{v.key}=>{v.value}" for v in variables]
         return f" using ({', '.join(query_parameters)})"
 
+    @staticmethod
+    def _parse_python_variables(variables: List[Variable]) -> Dict:
+        def _unwrap(s: str):
+            if s.startswith("'") and s.endswith("'"):
+                return s[1:-1]
+            if s.startswith('"') and s.endswith('"'):
+                return s[1:-1]
+            return s
+
+        return {str(v.key): _unwrap(v.value) for v in variables}
+
     @staticmethod
     def _success_result(file: str):
         cli_console.warning(f"SUCCESS - {file}")
@@ -464,16 +680,17 @@ class StageManager(SqlExecutionMixin):
         file_stage_path: str,
         variables: Optional[str],
         on_error: OnErrorType,
+        original_file: str,
     ) -> Dict:
         try:
             query = f"execute immediate from {self.quote_stage_name(file_stage_path)}"
             if variables:
                 query += variables
-            self._execute_query(query)
-            return StageManager._success_result(file=file_stage_path)
+            self.execute_query(query)
+            return StageManager._success_result(file=original_file)
         except ProgrammingError as e:
             StageManager._handle_execution_exception(on_error=on_error, exception=e)
-            return StageManager._error_result(file=file_stage_path, msg=e.msg)
+            return StageManager._error_result(file=original_file, msg=e.msg)
 
     @staticmethod
     def _stage_path_part_factory(stage_path: str) -> StagePathParts:
@@ -482,32 +699,34 @@ class StageManager(SqlExecutionMixin):
             return UserStagePathParts(stage_path)
         return DefaultStagePathParts(stage_path)
 
-    def _check_for_requirements_file(
-        self, stage_path_parts: StagePathParts
-    ) -> List[str]:
+    def _check_for_requirements_file(self, stage_path: StagePath) -> List[str]:
         """Looks for requirements.txt file on stage."""
+        current_dir = stage_path.parent if stage_path.is_file() else stage_path
         req_files_on_stage = self._get_files_list_from_stage(
-            stage_path_parts, pattern=r".*requirements\.txt$"
+            current_dir, pattern=r".*requirements\.txt$"
         )
         if not req_files_on_stage:
             return []
 
         # Construct all possible path for requirements file for this context
-        # We don't use os.path or pathlib to preserve compatibility on Windows
         req_file_name = "requirements.txt"
-        path_parts = stage_path_parts.path.split("/")
         possible_req_files = []
+        while not current_dir.is_root():
+            current_file = current_dir / req_file_name
+            possible_req_files.append(current_file)
+            current_dir = current_dir.parent
 
-        while path_parts:
-            current_file = "/".join([*path_parts, req_file_name])
-            possible_req_files.append(str(current_file))
-            path_parts = path_parts[:-1]
+        current_file = current_dir / req_file_name
+        possible_req_files.append(current_file)
 
         # Now for every possible path check if the file exists on stage,
         # if yes break, we use the first possible file
-        requirements_file = None
+        requirements_file: StagePath | None = None
         for req_file in possible_req_files:
-            if req_file in req_files_on_stage:
+            if (
+                req_file.absolute_path(no_fqn=True, at_prefix=False)
+                in req_files_on_stage
+            ):
                 requirements_file = req_file
                 break
 
@@ -516,37 +735,34 @@ class StageManager(SqlExecutionMixin):
             return []
 
         # req_file at this moment is the first found requirements file
+        requirements_path = requirements_file.with_stage(stage_path.stage)
         with SecurePath.temporary_directory() as tmp_dir:
-            self.get(
-                stage_path_parts.get_full_stage_path(requirements_file), tmp_dir.path
-            )
+            self.get(str(requirements_path), tmp_dir.path)
             requirements = parse_requirements(
                 requirements_file=tmp_dir / "requirements.txt"
             )
 
         return [req.package_name for req in requirements]
 
-    def _bootstrap_snowpark_execution_environment(
-        self, stage_path_parts: StagePathParts
-    ):
+    def _bootstrap_snowpark_execution_environment(self, stage_path: StagePath):
         """Prepares Snowpark session for executing Python code remotely."""
         if sys.version_info >= PYTHON_3_12:
             raise ClickException(
-                f"Executing python files is not supported in Python >= 3.12. Current version: {sys.version}"
+                f"Executing Python files is not supported in Python >= 3.12. Current version: {sys.version}"
             )
 
         from snowflake.snowpark.functions import sproc
 
         self.snowpark_session.add_packages("snowflake-snowpark-python")
         self.snowpark_session.add_packages("snowflake.core")
-        requirements = self._check_for_requirements_file(stage_path_parts)
+        requirements = self._check_for_requirements_file(stage_path)
         self.snowpark_session.add_packages(*requirements)
 
-        @sproc(is_permanent=False)
+        @sproc(is_permanent=False, session=self.snowpark_session)
         def _python_execution_procedure(
             _: Session, file_path: str, variables: Dict | None = None
         ) -> None:
-            """Snowpark session-scoped stored procedure to execute content of provided python file."""
+            """Snowpark session-scoped stored procedure to execute content of provided Python file."""
             import json
 
             from snowflake.snowpark.files import SnowflakeFile
@@ -566,7 +782,11 @@ class StageManager(SqlExecutionMixin):
         return _python_execution_procedure
 
     def _execute_python(
-        self, file_stage_path: str, on_error: OnErrorType, variables: Dict
+        self,
+        file_stage_path: str,
+        on_error: OnErrorType,
+        variables: Dict,
+        original_file: str,
     ):
         """
         Executes Python file from stage using a Snowpark temporary procedure.
@@ -575,8 +795,8 @@ class StageManager(SqlExecutionMixin):
         from snowflake.snowpark.exceptions import SnowparkSQLException
 
         try:
-            self._python_exe_procedure(self.get_standard_stage_prefix(file_stage_path), variables)  # type: ignore
-            return StageManager._success_result(file=file_stage_path)
+            self._python_exe_procedure(self.get_standard_stage_prefix(file_stage_path), variables, session=self.snowpark_session)  # type: ignore
+            return StageManager._success_result(file=original_file)
         except SnowparkSQLException as e:
             StageManager._handle_execution_exception(on_error=on_error, exception=e)
-            return StageManager._error_result(file=file_stage_path, msg=e.message)
+            return StageManager._error_result(file=original_file, msg=e.message)

snowflake/cli/_plugins/stage/md5.py

@@ -110,7 +110,7 @@ def file_matches_md5sum(local_file: Path, remote_md5: str | None) -> bool:
     to a file that has a given remote md5sum.
 
     Handles the multi-part md5sums generated by e.g. AWS S3, using values
-    from the python connector to make educated guesses on chunk size.
+    from the Python connector to make educated guesses on chunk size.
 
     Assumes that upload time would dominate local hashing time.
     """

snowflake/cli/_plugins/streamlit/manager.py

@@ -45,10 +45,10 @@ log = logging.getLogger(__name__)
 class StreamlitManager(SqlExecutionMixin):
     def execute(self, app_name: FQN):
         query = f"EXECUTE STREAMLIT {app_name.sql_identifier}()"
-        return self._execute_query(query=query)
+        return self.execute_query(query=query)
 
     def share(self, streamlit_name: FQN, to_role: str) -> SnowflakeCursor:
-        return self._execute_query(
+        return self.execute_query(
             f"grant usage on streamlit {streamlit_name.sql_identifier} to role {to_role}"
         )
 
@@ -118,7 +118,7 @@ class StreamlitManager(SqlExecutionMixin):
         if streamlit.secrets:
             query.append(streamlit.get_secrets_sql())
 
-        self._execute_query("\n".join(query))
+        self.execute_query("\n".join(query))
 
     def deploy(self, streamlit: StreamlitEntityModel, replace: bool = False):
         streamlit_id = streamlit.fqn.using_connection(self._conn)
@@ -152,11 +152,11 @@ class StreamlitManager(SqlExecutionMixin):
             )
             try:
                 if use_versioned_stage:
-                    self._execute_query(
+                    self.execute_query(
                         f"ALTER STREAMLIT {streamlit_id.identifier} ADD LIVE VERSION FROM LAST"
                     )
                 elif not FeatureFlag.ENABLE_STREAMLIT_NO_CHECKOUTS.is_enabled():
-                    self._execute_query(
+                    self.execute_query(
                         f"ALTER streamlit {streamlit_id.identifier} CHECKOUT"
                     )
             except ProgrammingError as e: