snowflake-cli-labs 3.0.0rc0__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/manager.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import json
 import time
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
@@ -37,9 +36,7 @@ from snowflake.cli._plugins.nativeapp.constants import (
     NAME_COL,
 )
 from snowflake.cli._plugins.nativeapp.exceptions import (
-    ApplicationPackageDoesNotExistError,
     NoEventTableForAccount,
-    SetupScriptFailedValidation,
 )
 from snowflake.cli._plugins.nativeapp.project_model import (
     NativeAppProjectModel,
@@ -47,7 +44,6 @@ from snowflake.cli._plugins.nativeapp.project_model import (
 from snowflake.cli._plugins.stage.diff import (
     DiffResult,
 )
-from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.entities.application_package_entity import (
     ApplicationPackageEntity,
@@ -57,10 +53,6 @@ from snowflake.cli.api.entities.utils import (
     generic_sql_error_handler,
     sync_deploy_root_with_stage,
 )
-from snowflake.cli.api.errno import (
-    DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
-)
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
 from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
@@ -381,59 +373,38 @@ class NativeAppManager(SqlExecutionMixin):
 
         return diff
 
-    def validate(self, use_scratch_stage: bool = False):
-        """Validates Native App setup script SQL."""
-        with cc.phase(f"Validating Snowflake Native App setup script."):
-            validation_result = self.get_validation_result(use_scratch_stage)
-
-            # First print warnings, regardless of the outcome of validation
-            for warning in validation_result.get("warnings", []):
-                cc.warning(_validation_item_to_str(warning))
-
-            # Then print errors
-            for error in validation_result.get("errors", []):
-                # Print them as warnings for now since we're going to be
-                # revamping CLI output soon
-                cc.warning(_validation_item_to_str(error))
+    def deploy_to_scratch_stage_fn(self):
+        bundle_map = self.build_bundle()
+        self.deploy(
+            bundle_map=bundle_map,
+            prune=True,
+            recursive=True,
+            stage_fqn=self.scratch_stage_fqn,
+            validate=False,
+            print_diff=False,
+        )
 
-            # Then raise an exception if validation failed
-            if validation_result["status"] == "FAIL":
-                raise SetupScriptFailedValidation()
+    def validate(self, use_scratch_stage: bool = False):
+        return ApplicationPackageEntity.validate_setup_script(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            stage_fqn=self.stage_fqn,
+            use_scratch_stage=use_scratch_stage,
+            scratch_stage_fqn=self.scratch_stage_fqn,
+            deploy_to_scratch_stage_fn=self.deploy_to_scratch_stage_fn,
+        )
 
     def get_validation_result(self, use_scratch_stage: bool):
-        """Call system$validate_native_app_setup() to validate deployed Native App setup script."""
-        stage_fqn = self.stage_fqn
-        if use_scratch_stage:
-            stage_fqn = self.scratch_stage_fqn
-            bundle_map = self.build_bundle()
-            self.deploy(
-                bundle_map=bundle_map,
-                prune=True,
-                recursive=True,
-                stage_fqn=stage_fqn,
-                validate=False,
-                print_diff=False,
-            )
-        prefixed_stage_fqn = StageManager.get_standard_stage_prefix(stage_fqn)
-        try:
-            cursor = self._execute_query(
-                f"call system$validate_native_app_setup('{prefixed_stage_fqn}')"
-            )
-        except ProgrammingError as err:
-            if err.errno == DOES_NOT_EXIST_OR_NOT_AUTHORIZED:
-                raise ApplicationPackageDoesNotExistError(self.package_name)
-            generic_sql_error_handler(err)
-        else:
-            if not cursor.rowcount:
-                raise SnowflakeSQLExecutionError()
-            return json.loads(cursor.fetchone()[0])
-        finally:
-            if use_scratch_stage:
-                cc.step(f"Dropping stage {self.scratch_stage_fqn}.")
-                with self.use_role(self.package_role):
-                    self._execute_query(
-                        f"drop stage if exists {self.scratch_stage_fqn}"
-                    )
+        return ApplicationPackageEntity.get_validation_result(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            stage_fqn=self.stage_fqn,
+            use_scratch_stage=use_scratch_stage,
+            scratch_stage_fqn=self.scratch_stage_fqn,
+            deploy_to_scratch_stage_fn=self.deploy_to_scratch_stage_fn,
+        )
 
     def get_events(  # type: ignore [return]
         self,

snowflake/cli/_plugins/nativeapp/project_model.py

@@ -21,6 +21,7 @@ from typing import List, Optional
 from snowflake.cli._plugins.nativeapp.artifacts import resolve_without_follow
 from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
 from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.project.definition import (
     default_app_package,
     default_application,
@@ -34,14 +35,6 @@ from snowflake.cli.api.project.util import (
     extract_schema,
     to_identifier,
 )
-from snowflake.connector import DictCursor
-
-
-def current_role() -> str:
-    conn = get_cli_context().connection
-    *_, cursor = conn.execute_string("select current_role()", cursor_class=DictCursor)
-    role_result = cursor.fetchone()
-    return role_result["CURRENT_ROLE()"]
 
 
 class NativeAppProjectModel:
@@ -198,7 +191,7 @@ class NativeAppProjectModel:
     def _default_role(self) -> str:
         role = default_role()
         if role is None:
-            role = current_role()
+            role = get_sql_executor().current_role()
         return role
 
     @cached_property

snowflake/cli/_plugins/nativeapp/teardown_processor.py

@@ -22,13 +22,8 @@ import typer
 from snowflake.cli._plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
-    EXTERNAL_DISTRIBUTION,
-    INTERNAL_DISTRIBUTION,
     OWNER_COL,
 )
-from snowflake.cli._plugins.nativeapp.exceptions import (
-    CouldNotDropApplicationPackageWithVersions,
-)
 from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
@@ -37,11 +32,15 @@ from snowflake.cli._plugins.nativeapp.utils import (
     needs_confirmation,
 )
 from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.entities.utils import ensure_correct_owner
+from snowflake.cli.api.entities.application_package_entity import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli.api.entities.utils import (
+    drop_generic_object,
+    ensure_correct_owner,
+)
 from snowflake.cli.api.errno import APPLICATION_NO_LONGER_AVAILABLE
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor
 
 
 class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
@@ -51,20 +50,13 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
     def drop_generic_object(
         self, object_type: str, object_name: str, role: str, cascade: bool = False
     ):
-        """
-        Drop object using the given role.
-        """
-        with self.use_role(role):
-            cc.step(f"Dropping {object_type} {object_name} now.")
-            drop_query = f"drop {object_type} {object_name}"
-            if cascade:
-                drop_query += " cascade"
-            try:
-                self._execute_query(drop_query)
-            except:
-                raise SnowflakeSQLExecutionError(drop_query)
-
-            cc.message(f"Dropped {object_type} {object_name} successfully.")
+        return drop_generic_object(
+            console=cc,
+            object_type=object_type,
+            object_name=object_name,
+            role=role,
+            cascade=cascade,
+        )
 
     def drop_application(
         self, auto_yes: bool, interactive: bool = False, cascade: Optional[bool] = None
@@ -198,90 +190,12 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
         return  # The application object was successfully dropped, therefore exit gracefully
 
     def drop_package(self, auto_yes: bool):
-        """
-        Attempts to drop application package unless user specifies otherwise.
-        """
-        needs_confirm = True
-
-        # 1. If existing application package is not found, exit gracefully
-        show_obj_row = self.get_existing_app_pkg_info()
-        if show_obj_row is None:
-            cc.warning(
-                f"Role {self.package_role} does not own any application package with the name {self.package_name}, or the application package does not exist."
-            )
-            return
-
-        # 2. Check for the right owner
-        ensure_correct_owner(
-            row=show_obj_row, role=self.package_role, obj_name=self.package_name
-        )
-
-        with self.use_role(self.package_role):
-            # 3. Check for versions in the application package
-            show_versions_query = (
-                f"show versions in application package {self.package_name}"
-            )
-            show_versions_cursor = self._execute_query(
-                show_versions_query, cursor_class=DictCursor
-            )
-            if show_versions_cursor.rowcount is None:
-                raise SnowflakeSQLExecutionError(show_versions_query)
-
-            if show_versions_cursor.rowcount > 0:
-                # allow dropping a package with versions when --force is set
-                if not auto_yes:
-                    raise CouldNotDropApplicationPackageWithVersions(
-                        "Drop versions first, or use --force to override."
-                    )
-
-        # 4. Check distribution of the existing application package
-        actual_distribution = self.get_app_pkg_distribution_in_snowflake
-        if not self.verify_project_distribution(actual_distribution):
-            cc.warning(
-                f"Continuing to execute `snow app teardown` on application package {self.package_name} with distribution '{actual_distribution}'."
-            )
-
-        # 5. If distribution is internal, check if created by the Snowflake CLI
-        row_comment = show_obj_row[COMMENT_COL]
-        if actual_distribution == INTERNAL_DISTRIBUTION:
-            if row_comment in ALLOWED_SPECIAL_COMMENTS:
-                needs_confirm = False
-            else:
-                if needs_confirmation(needs_confirm, auto_yes):
-                    cc.warning(
-                        f"Application package {self.package_name} was not created by Snowflake CLI."
-                    )
-        else:
-            if needs_confirmation(needs_confirm, auto_yes):
-                cc.warning(
-                    f"Application package {self.package_name} in your Snowflake account has distribution property '{EXTERNAL_DISTRIBUTION}' and could be associated with one or more of your listings on Snowflake Marketplace."
-                )
-
-        if needs_confirmation(needs_confirm, auto_yes):
-            should_drop_object = typer.confirm(
-                dedent(
-                    f"""\
-                        Application package details:
-                        Name: {self.app_name}
-                        Created on: {show_obj_row["created_on"]}
-                        Distribution: {actual_distribution}
-                        Owner: {show_obj_row[OWNER_COL]}
-                        Comment: {show_obj_row[COMMENT_COL]}
-                        Are you sure you want to drop it?
-                    """
-                )
-            )
-            if not should_drop_object:
-                cc.message(f"Did not drop application package {self.package_name}.")
-                return  # The user desires to keep the application package, therefore exit gracefully
-
-        # All validations have passed, drop object
-        self.drop_generic_object(
-            object_type="application package",
-            object_name=self.package_name,
-            role=self.package_role,
+        return ApplicationPackageEntity.drop(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            force_drop=auto_yes,
         )
-        return  # The application package was successfully dropped, therefore exit gracefully
 
     def process(
         self,

snowflake/cli/_plugins/snowpark/commands.py

@@ -75,7 +75,6 @@ from snowflake.cli.api.constants import (
     DEFAULT_SIZE_LIMIT_MB,
 )
 from snowflake.cli.api.exceptions import (
-    NoProjectDefinitionError,
     SecretsWithoutExternalAccessIntegrationError,
 )
 from snowflake.cli.api.identifiers import FQN
@@ -85,6 +84,9 @@ from snowflake.cli.api.output.types import (
     MessageResult,
     SingleQueryResult,
 )
+from snowflake.cli.api.project.definition_conversion import (
+    convert_project_definition_to_v2,
+)
 from snowflake.cli.api.project.schemas.entities.snowpark_entity import (
     FunctionEntityModel,
     ProcedureEntityModel,
@@ -93,10 +95,6 @@ from snowflake.cli.api.project.schemas.project_definition import (
     ProjectDefinition,
     ProjectDefinitionV2,
 )
-from snowflake.cli.api.project.schemas.snowpark.callable import (
-    FunctionSchema,
-    ProcedureSchema,
-)
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import DictCursor, ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
@@ -123,7 +121,7 @@ LikeOption = like_option(
 )
 
 
-@app.command("deploy", requires_connection=True)
+@app.command("deploy", requires_connection=True, require_warehouse=True)
 @with_project_definition()
 def deploy(
     replace: bool = ReplaceOption(
@@ -445,66 +443,8 @@ def describe(
     )
 
 
-def migrate_v1_snowpark_to_v2(pd: ProjectDefinition):
-    if not pd.snowpark:
-        raise NoProjectDefinitionError(
-            project_type="snowpark", project_root=get_cli_context().project_root
-        )
-
-    artifact_mapping = {"src": pd.snowpark.src}
-    if pd.snowpark.project_name:
-        artifact_mapping["dest"] = pd.snowpark.project_name
-
-    snowpark_shared_mixin = "snowpark_shared"
-    data: dict = {
-        "definition_version": "2",
-        "mixins": {
-            snowpark_shared_mixin: {
-                "stage": pd.snowpark.stage_name,
-                "artifacts": [artifact_mapping],
-            }
-        },
-        "entities": {},
-    }
-
-    for index, entity in enumerate([*pd.snowpark.procedures, *pd.snowpark.functions]):
-        identifier = {"name": entity.name}
-        if entity.database is not None:
-            identifier["database"] = entity.database
-        if entity.schema_name is not None:
-            identifier["schema"] = entity.schema_name
-
-        if entity.name.startswith("<%") and entity.name.endswith("%>"):
-            entity_name = f"snowpark_entity_{index}"
-        else:
-            entity_name = entity.name
-
-        v2_entity = {
-            "type": "function" if isinstance(entity, FunctionSchema) else "procedure",
-            "stage": pd.snowpark.stage_name,
-            "handler": entity.handler,
-            "returns": entity.returns,
-            "signature": entity.signature,
-            "runtime": entity.runtime,
-            "external_access_integrations": entity.external_access_integrations,
-            "secrets": entity.secrets,
-            "imports": entity.imports,
-            "identifier": identifier,
-            "meta": {"use_mixins": [snowpark_shared_mixin]},
-        }
-        if isinstance(entity, ProcedureSchema):
-            v2_entity["execute_as_caller"] = entity.execute_as_caller
-
-        data["entities"][entity_name] = v2_entity
-
-    if hasattr(pd, "env") and pd.env:
-        data["env"] = {k: v for k, v in pd.env.items()}
-
-    return ProjectDefinitionV2(**data)
-
-
 def _get_v2_project_definition(cli_context) -> ProjectDefinitionV2:
     pd = cli_context.project_definition
     if not pd.meets_version_requirement("2"):
-        pd = migrate_v1_snowpark_to_v2(pd)
+        pd = convert_project_definition_to_v2(pd)
     return pd

snowflake/cli/_plugins/snowpark/common.py

@@ -23,7 +23,13 @@ from click import UsageError
 from snowflake.cli._plugins.snowpark.models import Requirement
 from snowflake.cli._plugins.snowpark.snowpark_project_paths import Artefact
 from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.constants import (
+    INIT_TEMPLATE_VARIABLE_CLOSING,
+    INIT_TEMPLATE_VARIABLE_OPENING,
+    PROJECT_TEMPLATE_VARIABLE_CLOSING,
+    PROJECT_TEMPLATE_VARIABLE_OPENING,
+    ObjectType,
+)
 from snowflake.cli.api.project.schemas.entities.snowpark_entity import (
     ProcedureEntityModel,
     SnowparkEntityModel,
@@ -250,3 +256,13 @@ def _compare_imports(
         }
 
     return project_imports != object_imports
+
+
+def is_name_a_templated_one(name: str) -> bool:
+    return (
+        PROJECT_TEMPLATE_VARIABLE_OPENING in name
+        and PROJECT_TEMPLATE_VARIABLE_CLOSING in name
+    ) or (
+        INIT_TEMPLATE_VARIABLE_OPENING in name
+        and INIT_TEMPLATE_VARIABLE_CLOSING in name
+    )

snowflake/cli/_plugins/snowpark/package/anaconda_packages.py

@@ -18,12 +18,9 @@ import logging
 from dataclasses import dataclass
 from typing import Dict, List, Set
 
-import requests
-from click import ClickException
 from packaging.requirements import InvalidRequirement
 from packaging.requirements import Requirement as PkgRequirement
 from packaging.version import InvalidVersion, parse
-from requests import HTTPError
 from snowflake.cli._plugins.snowpark.models import Requirement
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.secure_path import SecurePath
@@ -170,23 +167,13 @@ class AnacondaPackagesManager(SqlExecutionMixin):
         "https://repo.anaconda.com/pkgs/snowflake/channeldata.json"
     )
 
-    # TODO in v3.0: Keep only SQL query, remove fallback to JSON with channel's metadata
     def find_packages_available_in_snowflake_anaconda(self) -> AnacondaPackages:
         """
         Finds python packages available in Snowflake to use in functions and stored procedures.
         It tries to get the list of packages using SQL query
         but if the try fails then the fallback is to parse JSON containing info about Snowflake's Anaconda channel.
         """
-        try:
-            packages = self._query_snowflake_for_available_packages()
-        except Exception as ex:
-            log.warning(
-                "Cannot fetch available packages information from Snowflake. "
-                "Please check your connection configuration. "
-                "Fallback to Anaconda channel metadata."
-            )
-            log.debug("Available packages query failure: %s", ex.__str__(), exc_info=ex)
-            packages = self._get_available_packages_from_anaconda_channel_info()
+        packages = self._query_snowflake_for_available_packages()
         return AnacondaPackages(packages)
 
     def _query_snowflake_for_available_packages(self) -> dict[str, AvailablePackage]:
@@ -210,24 +197,3 @@ class AnacondaPackagesManager(SqlExecutionMixin):
                     snowflake_name=package_name, versions={version}
                 )
         return packages
-
-    def _get_available_packages_from_anaconda_channel_info(
-        self,
-    ) -> dict[str, AvailablePackage]:
-        try:
-            response = requests.get(self._snowflake_channel_url)
-            response.raise_for_status()
-            packages = {}
-            for key, package in response.json()["packages"].items():
-                if not (version := package.get("version")):
-                    continue
-                package_name = package.get("name", key)
-                standardized_name = Requirement.standardize_name(package_name)
-                packages[standardized_name] = AvailablePackage(
-                    snowflake_name=package_name, versions={version}
-                )
-            return packages
-        except HTTPError as err:
-            raise ClickException(
-                f"Accessing Snowflake Anaconda channel failed. Reason {err}"
-            )

snowflake/cli/_plugins/sql/commands.py

@@ -73,8 +73,7 @@ def execute_sql(
     Query to execute can be specified using query option, filename option (all queries from file will be executed)
     or via stdin by piping output from other command. For example `cat my.sql | snow sql -i`.
 
-    The command supports variable substitution that happens on client-side. Both &VARIABLE or &{ VARIABLE }
-    syntax are supported.
+    The command supports variable substitution that happens on client-side.
     """
 
     data = {}

snowflake/cli/_plugins/stage/commands.py

@@ -37,7 +37,7 @@ from snowflake.cli.api.commands.flags import (
     ExecuteVariablesOption,
     OnErrorOption,
     PatternOption,
-    identifier_argument,
+    identifier_stage_argument,
     like_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
@@ -59,7 +59,7 @@ app = SnowTyperFactory(
     help="Manages stages.",
 )
 
-StageNameArgument = identifier_argument(sf_object="stage", example="@my_stage")
+StageNameArgument = identifier_stage_argument(sf_object="stage", example="@my_stage")
 
 add_object_command_aliases(
     app=app,

snowflake/cli/_plugins/stage/manager.py

@@ -65,14 +65,21 @@ class StagePathParts:
     stage_name: str
     is_directory: bool
 
-    @staticmethod
-    def get_directory(stage_path: str) -> str:
+    @classmethod
+    def get_directory(cls, stage_path: str) -> str:
         return "/".join(Path(stage_path).parts[1:])
 
     @property
     def path(self) -> str:
         raise NotImplementedError
 
+    @property
+    def full_path(self) -> str:
+        raise NotImplementedError
+
+    def replace_stage_prefix(self, file_path: str) -> str:
+        raise NotImplementedError
+
     def add_stage_prefix(self, file_path: str) -> str:
         raise NotImplementedError
 
@@ -112,24 +119,27 @@ class DefaultStagePathParts(StagePathParts):
         self.directory = self.get_directory(stage_path)
         self.stage = StageManager.get_stage_from_path(stage_path)
         stage_name = self.stage.split(".")[-1]
-        if stage_name.startswith("@"):
-            stage_name = stage_name[1:]
+        stage_name = stage_name[1:] if stage_name.startswith("@") else stage_name
         self.stage_name = stage_name
         self.is_directory = True if stage_path.endswith("/") else False
 
     @property
     def path(self) -> str:
-        return (
-            f"{self.stage_name}{self.directory}"
-            if self.stage_name.endswith("/")
-            else f"{self.stage_name}/{self.directory}"
-        )
+        return f"{self.stage_name.rstrip('/')}/{self.directory}"
 
-    def add_stage_prefix(self, file_path: str) -> str:
+    @property
+    def full_path(self) -> str:
+        return f"{self.stage.rstrip('/')}/{self.directory}"
+
+    def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
         file_path_without_prefix = Path(file_path).parts[1:]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
+    def add_stage_prefix(self, file_path: str) -> str:
+        stage = self.stage.rstrip("/")
+        return f"{stage}/{file_path.lstrip('/')}"
+
     def get_directory_from_file_path(self, file_path: str) -> List[str]:
         stage_path_length = len(Path(self.directory).parts)
         return list(Path(file_path).parts[1 + stage_path_length : -1])
@@ -146,14 +156,29 @@ class UserStagePathParts(StagePathParts):
 
     def __init__(self, stage_path: str):
         self.directory = self.get_directory(stage_path)
-        self.stage = "@~"
-        self.stage_name = "@~"
+        self.stage = USER_STAGE_PREFIX
+        self.stage_name = USER_STAGE_PREFIX
         self.is_directory = True if stage_path.endswith("/") else False
 
+    @classmethod
+    def get_directory(cls, stage_path: str) -> str:
+        if Path(stage_path).parts[0] == USER_STAGE_PREFIX:
+            return super().get_directory(stage_path)
+        return stage_path
+
     @property
     def path(self) -> str:
         return f"{self.directory}"
 
+    @property
+    def full_path(self) -> str:
+        return f"{self.stage}/{self.directory}"
+
+    def replace_stage_prefix(self, file_path: str) -> str:
+        if Path(file_path).parts[0] == self.stage_name:
+            return file_path
+        return f"{self.stage}/{file_path}"
+
     def add_stage_prefix(self, file_path: str) -> str:
         return f"{self.stage}/{file_path}"
 
@@ -241,7 +266,7 @@ class StageManager(SqlExecutionMixin):
             self._assure_is_existing_directory(dest_directory)
 
             result = self._execute_query(
-                f"get {self.quote_stage_name(stage_path_parts.add_stage_prefix(file_path))} {self._to_uri(f'{dest_directory}/')} parallel={parallel}"
+                f"get {self.quote_stage_name(stage_path_parts.replace_stage_prefix(file_path))} {self._to_uri(f'{dest_directory}/')} parallel={parallel}"
             )
             results.append(result)
 
@@ -321,8 +346,14 @@ class StageManager(SqlExecutionMixin):
         stage_path_parts = self._stage_path_part_factory(stage_path)
         all_files_list = self._get_files_list_from_stage(stage_path_parts)
 
+        all_files_with_stage_name_prefix = [
+            stage_path_parts.get_directory(file) for file in all_files_list
+        ]
+
         # filter files from stage if match stage_path pattern
-        filtered_file_list = self._filter_files_list(stage_path_parts, all_files_list)
+        filtered_file_list = self._filter_files_list(
+            stage_path_parts, all_files_with_stage_name_prefix
+        )
 
         if not filtered_file_list:
             raise ClickException(f"No files matched pattern '{stage_path}'")
@@ -378,7 +409,7 @@ class StageManager(SqlExecutionMixin):
         if not stage_path_parts.directory:
             return self._filter_supported_files(files_on_stage)
 
-        stage_path = stage_path_parts.path.lower()
+        stage_path = stage_path_parts.directory
 
         # Exact file path was provided if stage_path in file list
         if stage_path in files_on_stage: