snowflake-cli 3.6.0__py3-none-any.whl → 3.7.0__py3-none-any.whl

snowflake/cli/_plugins/streamlit/manager.py

@@ -31,7 +31,7 @@ from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
 from snowflake.cli._plugins.streamlit.streamlit_project_paths import (
     StreamlitProjectPaths,
 )
-from snowflake.cli.api.artifacts.upload import put_files
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
 from snowflake.cli.api.commands.experimental_behaviour import (
     experimental_behaviour_enabled,
 )
@@ -56,18 +56,20 @@ class StreamlitManager(SqlExecutionMixin):
             f"grant usage on streamlit {streamlit_name.sql_identifier} to role {to_role}"
         )
 
-    def _put_streamlit_files(
+    def _upload_artifacts(
         self,
         streamlit_project_paths: StreamlitProjectPaths,
         stage_root: str,
+        prune: bool,
         artifacts: Optional[List[PathMapping]] = None,
     ):
-        cli_console.step(f"Deploying files to {stage_root}")
-        put_files(
-            project_paths=streamlit_project_paths,
-            stage_root=stage_root,
-            artifacts=artifacts,
-        )
+        with cli_console.phase(f"Deploying files to {stage_root}"):
+            sync_artifacts_with_stage(
+                project_paths=streamlit_project_paths,
+                stage_root=stage_root,
+                prune=prune,
+                artifacts=artifacts,
+            )
 
     def _create_streamlit(
         self,
@@ -126,6 +128,7 @@ class StreamlitManager(SqlExecutionMixin):
         streamlit: StreamlitEntityModel,
         streamlit_project_paths: StreamlitProjectPaths,
         replace: bool = False,
+        prune: bool = False,
     ):
         streamlit_id = streamlit.fqn.using_connection(self._conn)
         if (
@@ -182,10 +185,11 @@ class StreamlitManager(SqlExecutionMixin):
             else:
                 stage_root = f"{embedded_stage_name}/default_checkout"
 
-            self._put_streamlit_files(
+            self._upload_artifacts(
                 streamlit_project_paths,
                 stage_root,
-                streamlit.artifacts,
+                prune=prune,
+                artifacts=streamlit.artifacts,
             )
         else:
             """
@@ -198,15 +202,15 @@ class StreamlitManager(SqlExecutionMixin):
             stage_name = streamlit.stage or "streamlit"
             stage_name = FQN.from_string(stage_name).using_connection(self._conn)
 
-            cli_console.step(f"Creating {stage_name} stage")
-            stage_manager.create(fqn=stage_name)
-
             stage_root = stage_manager.get_standard_stage_prefix(
                 f"{stage_name}/{streamlit_name_for_root_location}"
             )
 
-            self._put_streamlit_files(
-                streamlit_project_paths, stage_root, streamlit.artifacts
+            self._upload_artifacts(
+                streamlit_project_paths,
+                stage_root,
+                prune=prune,
+                artifacts=streamlit.artifacts,
             )
 
             self._create_streamlit(

snowflake/cli/api/artifacts/upload.py

@@ -1,51 +1,47 @@
-from pathlib import PurePosixPath
 from typing import List, Optional
 
 from snowflake.cli._plugins.stage.manager import StageManager
-from snowflake.cli.api.artifacts.bundle_map import BundleMap
-from snowflake.cli.api.artifacts.utils import symlink_or_copy
+from snowflake.cli.api.artifacts.utils import bundle_artifacts
 from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.entities.utils import sync_deploy_root_with_stage
 from snowflake.cli.api.project.project_paths import ProjectPaths
 from snowflake.cli.api.project.schemas.entities.common import PathMapping
 
 
-def put_files(
+def sync_artifacts_with_stage(
     project_paths: ProjectPaths,
     stage_root: str,
+    prune: bool = False,
     artifacts: Optional[List[PathMapping]] = None,
 ):
-    if not artifacts:
-        return
-    stage_manager = StageManager()
+    if artifacts is None:
+        artifacts = []
+
+    bundle_map = bundle_artifacts(project_paths, artifacts)
+    stage_path_parts = StageManager().stage_path_parts_from_str(stage_root)
     # We treat the bundle root as deploy root
-    bundle_map = BundleMap(
-        project_root=project_paths.project_root,
+    sync_deploy_root_with_stage(
+        console=cli_console,
         deploy_root=project_paths.bundle_root,
+        bundle_map=bundle_map,
+        prune=prune,
+        recursive=True,
+        stage_path=stage_path_parts,
+        print_diff=True,
     )
-    for artifact in artifacts:
-        bundle_map.add(PathMapping(src=str(artifact.src), dest=artifact.dest))
 
-    # Clean up bundle root
-    project_paths.remove_up_bundle_root()
 
-    for (absolute_src, absolute_dest) in bundle_map.all_mappings(
-        absolute=True, expand_directories=True
-    ):
-        if absolute_src.is_file():
-            # We treat the bundle/streamlit root as deploy root
-            symlink_or_copy(
-                absolute_src,
-                absolute_dest,
-                deploy_root=project_paths.bundle_root,
-            )
-            # Temporary solution, will be replaced with diff
-            stage_path = (
-                PurePosixPath(absolute_dest)
-                .relative_to(project_paths.bundle_root)
-                .parent
-            )
-            full_stage_path = f"{stage_root}/{stage_path}".rstrip("/")
-            cli_console.step(f"Uploading {absolute_dest} to {full_stage_path}")
-            stage_manager.put(
-                local_path=absolute_dest, stage_path=full_stage_path, overwrite=True
-            )
+def put_files(
+    project_paths: ProjectPaths,
+    stage_root: str,
+    artifacts: Optional[List[PathMapping]] = None,
+):
+    if not artifacts:
+        return
+
+    sync_artifacts_with_stage(
+        project_paths=project_paths,
+        stage_root=stage_root,
+        prune=False,
+        artifacts=artifacts,
+    )

snowflake/cli/api/artifacts/utils.py

@@ -69,14 +69,16 @@ def bundle_artifacts(project_paths: ProjectPaths, artifacts: Artifacts) -> Bundl
         bundle_map.add(artifact)
 
     project_paths.remove_up_bundle_root()
+    SecurePath(project_paths.bundle_root).mkdir(parents=True, exist_ok=True)
     for absolute_src, absolute_dest in bundle_map.all_mappings(
         absolute=True, expand_directories=True
     ):
-        # We treat the bundle root as deploy root
-        symlink_or_copy(
-            absolute_src,
-            absolute_dest,
-            deploy_root=project_paths.bundle_root,
-        )
+        if absolute_src.is_file():
+            # We treat the bundle root as deploy root
+            symlink_or_copy(
+                absolute_src,
+                absolute_dest,
+                deploy_root=project_paths.bundle_root,
+            )
 
     return bundle_map

snowflake/cli/api/cli_global_context.py

@@ -22,7 +22,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Iterator, Optional
 
 from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
-from snowflake.cli.api.exceptions import MissingConfiguration
+from snowflake.cli.api.exceptions import MissingConfigurationError
 from snowflake.cli.api.metrics import CLIMetrics
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
@@ -61,6 +61,7 @@ class _CliGlobalContextManager:
     override_project_definition: ProjectDefinition | None = None
 
     _definition_manager: DefinitionManager | None = None
+    enhanced_exit_codes: bool = False
 
     # which properties invalidate our current DefinitionManager?
     DEFINITION_MANAGER_DEPENDENCIES = [
@@ -126,7 +127,7 @@ class _CliGlobalContextManager:
                 {CONTEXT_KEY: {"env": self.project_env_overrides_args}},
             )
             if not dm.has_definition_file and not self.project_is_optional:
-                raise MissingConfiguration(
+                raise MissingConfigurationError(
                     "Cannot find project definition (snowflake.yml). Please provide a path to the project or run this command in a valid project directory."
                 )
             self._definition_manager = dm
@@ -209,6 +210,10 @@ class _CliGlobalContextAccess:
         else:
             return None
 
+    @property
+    def enhanced_exit_codes(self) -> bool:
+        return self._manager.enhanced_exit_codes
+
 
 _CLI_CONTEXT_MANAGER: ContextVar[_CliGlobalContextManager | None] = ContextVar(
     "cli_context", default=None

snowflake/cli/api/commands/decorators.py

@@ -29,6 +29,7 @@ from snowflake.cli.api.commands.flags import (
     DiagAllowlistPathOption,
     DiagLogPathOption,
     EnableDiagOption,
+    EnhancedExitCodesOption,
     HostOption,
     MasterTokenOption,
     MfaPasscodeOption,
@@ -78,7 +79,6 @@ def global_options_with_connection(func: Callable):
 
 def with_project_definition(is_optional: bool = False):
     def _decorator(func: Callable):
-
         return _options_decorator_factory(
             func,
             additional_options=[
@@ -159,7 +159,10 @@ def _options_decorator_factory(
             execute_before_command_using_new_options(**options)
         return func(**options)
 
-    wrapper.__signature__ = _extend_signature_with_additional_options(func, additional_options)  # type: ignore
+    wrapper.__signature__ = _extend_signature_with_additional_options(  # type: ignore
+        func, additional_options
+    )
+
     return wrapper
 
 
@@ -353,6 +356,12 @@ GLOBAL_OPTIONS = [
         annotation=Optional[bool],
         default=SilentOption,
     ),
+    inspect.Parameter(
+        "enhanced_exit_codes",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[bool],
+        default=EnhancedExitCodesOption,
+    ),
 ]
 
 

snowflake/cli/api/commands/flags.py

@@ -371,6 +371,17 @@ DebugOption = typer.Option(
     rich_help_panel=_CLI_BEHAVIOUR,
 )
 
+EnhancedExitCodesOption = typer.Option(
+    False,
+    "--enhanced-exit-codes",
+    help="Differentiate exit error codes based on failure type.",
+    callback=_context_callback("enhanced_exit_codes"),
+    is_flag=True,
+    rich_help_panel=_CLI_BEHAVIOUR,
+    is_eager=True,
+    envvar="SNOWFLAKE_ENHANCED_EXIT_CODES",
+)
+
 
 # If IfExistsOption, IfNotExistsOption, or ReplaceOption are used with names other than those in CREATE_MODE_OPTION_NAMES,
 # you must also override mutually_exclusive if you want to retain the validation that at most one of these flags is
@@ -412,9 +423,19 @@ OnErrorOption = typer.Option(
 
 NoInteractiveOption = typer.Option(False, "--no-interactive", help="Disable prompting.")
 
+PruneOption = OverrideableOption(
+    False,
+    "--prune",
+    help=f"Delete files that exist in the stage, but not in the local filesystem.",
+    show_default=False,
+)
+
 
-def entity_argument(entity_type: str) -> typer.Argument:
-    return typer.Argument(None, help=f"ID of {entity_type} entity.")
+def entity_argument(entity_type: str, required=False) -> typer.Argument:
+    _help = f"ID of {entity_type} entity."
+    if not required:
+        return typer.Argument(None, help=_help)
+    return typer.Argument(..., help=_help, show_default=False)
 
 
 def variables_option(description: str):

snowflake/cli/api/commands/snow_typer.py

@@ -31,7 +31,13 @@ from snowflake.cli.api.commands.execution_metadata import (
     ExecutionStatus,
 )
 from snowflake.cli.api.commands.flags import DEFAULT_CONTEXT_SETTINGS
-from snowflake.cli.api.exceptions import CommandReturnTypeError
+from snowflake.cli.api.exceptions import (
+    BaseCliError,
+    CliArgumentError,
+    CliError,
+    CliSqlError,
+    CommandReturnTypeError,
+)
 from snowflake.cli.api.output.types import CommandResult
 from snowflake.cli.api.sanitizers import sanitize_for_terminal
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
@@ -168,8 +174,20 @@ class SnowTyper(typer.Typer):
 
         log.debug("Executing command exception callback")
         log_command_execution_error(exception, execution)
+        exception = SnowTyper._cli_base_exception_migration_dispatcher(exception)
+        return exception
+
+    @staticmethod
+    def _cli_base_exception_migration_dispatcher(exception):
+        """Handler used for dispatching exception until migration completed."""
+        if isinstance(
+            exception, (BaseCliError, CliError, CliArgumentError, CliSqlError)
+        ):
+            return exception
+
         if isinstance(exception, DatabaseError):
-            return ClickException(exception.msg)
+            return CliSqlError(exception.msg)
+
         return exception
 
     @staticmethod

snowflake/cli/api/config.py

@@ -26,7 +26,7 @@ import tomlkit
 from click import ClickException
 from snowflake.cli.api.exceptions import (
     ConfigFileTooWidePermissionsError,
-    MissingConfiguration,
+    MissingConfigurationError,
     UnsupportedConfigSectionTypeError,
 )
 from snowflake.cli.api.secure_path import SecurePath
@@ -252,7 +252,9 @@ def get_connection_dict(connection_name: str) -> dict:
     try:
         return get_config_section(CONNECTIONS_SECTION, connection_name)
     except KeyError:
-        raise MissingConfiguration(f"Connection {connection_name} is not configured")
+        raise MissingConfigurationError(
+            f"Connection {connection_name} is not configured"
+        )
 
 
 def get_default_connection_name() -> str:
@@ -262,7 +264,7 @@ def get_default_connection_name() -> str:
 def get_default_connection_dict() -> dict:
     def_connection_name = get_default_connection_name()
     if not connection_exists(def_connection_name):
-        raise MissingConfiguration(
+        raise MissingConfigurationError(
             f"Couldn't find connection for default connection `{def_connection_name}`. "
             f"Specify connection name or configure default connection."
         )

snowflake/cli/api/entities/utils.py

@@ -19,7 +19,10 @@ from snowflake.cli._plugins.stage.diff import (
     sync_local_diff_with_stage,
     to_stage_path,
 )
-from snowflake.cli._plugins.stage.manager import DefaultStagePathParts
+from snowflake.cli._plugins.stage.manager import (
+    StageManager,
+    StagePathParts,
+)
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
 from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.cli_global_context import get_cli_context, span
@@ -33,6 +36,7 @@ from snowflake.cli.api.exceptions import (
     NoWarehouseSelectedInSessionError,
     SnowflakeSQLExecutionError,
 )
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.rendering.sql_templates import (
@@ -79,12 +83,12 @@ def _get_stage_paths_to_sync(
 def sync_deploy_root_with_stage(
     console: AbstractConsole,
     deploy_root: Path,
-    package_name: str,
     bundle_map: BundleMap,
-    role: str,
     prune: bool,
     recursive: bool,
-    stage_path: DefaultStagePathParts,
+    stage_path: StagePathParts,
+    role: str | None = None,
+    package_name: str | None = None,
     local_paths_to_sync: List[Path] | None = None,
     print_diff: bool = True,
 ) -> DiffResult:
@@ -99,6 +103,8 @@ def sync_deploy_root_with_stage(
         recursive (bool): Whether to traverse directories recursively.
         stage_path (DefaultStagePathParts): stage path object.
 
+        package_name (str): supported for Native App compatibility. Should be None out of Native App context.
+
         local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
         local paths. Note that providing an empty list here is equivalent to None.
         print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
@@ -106,17 +112,24 @@ def sync_deploy_root_with_stage(
     Returns:
         A `DiffResult` instance describing the changes that were performed.
     """
-    sql_facade = get_snowflake_facade()
-    schema = stage_path.schema
-    stage_fqn = stage_path.stage
-    # Does a stage already exist within the application package, or we need to create one?
-    # Using "if not exists" should take care of either case.
-    console.step(
-        f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
-    )
-    if not sql_facade.stage_exists(stage_fqn):
-        sql_facade.create_schema(schema, database=package_name)
-        sql_facade.create_stage(stage_fqn)
+    if not package_name:
+        # ensure stage exists
+        stage_fqn = FQN.from_stage(stage_path.stage)
+        console.step(f"Creating stage {stage_fqn} if not exists.")
+        StageManager().create(fqn=stage_fqn)
+    else:
+        # ensure stage exists - nativeapp behavior
+        sql_facade = get_snowflake_facade()
+        schema = stage_path.schema
+        stage_fqn = stage_path.stage
+        # Does a stage already exist within the application package, or we need to create one?
+        # Using "if not exists" should take care of either case.
+        console.step(
+            f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
+        )
+        if not sql_facade.stage_exists(stage_fqn):
+            sql_facade.create_schema(schema, database=package_name)
+            sql_facade.create_stage(stage_fqn)
 
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
@@ -178,7 +191,7 @@ def sync_deploy_root_with_stage(
     if print_diff:
         print_diff_to_console(diff, bundle_map)
 
-    # Upload diff-ed files to application package stage
+    # Upload diff-ed files to the stage
     if diff.has_changes():
         console.step(
             "Updating the Snowflake stage from your local %s directory."