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

snowflake/cli/__about__.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from enum import Enum, unique
 
-VERSION = "3.6.0"
+VERSION = "3.7.0"
 
 
 @unique

snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -18,6 +18,7 @@ from snowflake.cli._plugins.cortex import plugin_spec as cortex_plugin_spec
 from snowflake.cli._plugins.git import plugin_spec as git_plugin_spec
 from snowflake.cli._plugins.helpers import plugin_spec as migrate_plugin_spec
 from snowflake.cli._plugins.init import plugin_spec as init_plugin_spec
+from snowflake.cli._plugins.logs import plugin_spec as logs_plugin_spec
 from snowflake.cli._plugins.nativeapp import plugin_spec as nativeapp_plugin_spec
 from snowflake.cli._plugins.notebook import plugin_spec as notebook_plugin_spec
 from snowflake.cli._plugins.object import plugin_spec as object_plugin_spec
@@ -51,6 +52,7 @@ def get_builtin_plugin_name_to_plugin_spec():
         "init": init_plugin_spec,
         "workspace": workspace_plugin_spec,
         "plugin": plugin_plugin_spec,
+        "logs": logs_plugin_spec,
     }
 
     return plugin_specs

snowflake/cli/_app/loggers.py

@@ -20,7 +20,7 @@ from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, List
 
 import typer
-from snowflake.cli.api.exceptions import InvalidLogsConfiguration
+from snowflake.cli.api.exceptions import InvalidLogsConfigurationError
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector.errors import ConfigSourceError
 
@@ -129,7 +129,7 @@ class FileLogsConfig:
             logging.CRITICAL,
         ]
         if self.level not in possible_log_levels:
-            raise InvalidLogsConfiguration(
+            raise InvalidLogsConfigurationError(
                 f"Invalid 'level' value set in [logs] section: {config['level']}. "
                 f"'level' should be one of: {' / '.join(logging.getLevelName(lvl) for lvl in possible_log_levels)}"
             )

snowflake/cli/_app/snow_connector.py

@@ -33,7 +33,7 @@ from snowflake.cli.api.config import (
 )
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.exceptions import (
-    InvalidConnectionConfiguration,
+    InvalidConnectionConfigurationError,
     SnowflakeConnectionError,
 )
 from snowflake.cli.api.feature_flags import FeatureFlag
@@ -169,7 +169,7 @@ def connect_to_snowflake(
     except ForbiddenError as err:
         raise SnowflakeConnectionError(err)
     except DatabaseError as err:
-        raise InvalidConnectionConfiguration(err.msg)
+        raise InvalidConnectionConfigurationError(err.msg)
 
 
 def _avoid_closing_the_connection_if_it_was_shared(

snowflake/cli/_plugins/connection/commands.py

@@ -66,6 +66,7 @@ from snowflake.cli.api.config import (
 )
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -289,7 +290,7 @@ def add(
     if connection_exists(connection_name):
         raise UsageError(f"Connection {connection_name} already exists")
 
-    if not no_interactive:
+    if FeatureFlag.ENABLE_AUTH_KEYPAIR.is_enabled() and not no_interactive:
         connection_options, keypair_error = _extend_add_with_key_pair(
             connection_name, connection_options
         )

snowflake/cli/_plugins/helpers/commands.py

@@ -15,12 +15,14 @@
 from __future__ import annotations
 
 import logging
+import os
 from pathlib import Path
 from typing import Any, List, Optional
 
 import typer
 import yaml
 from click import ClickException
+from snowflake.cli._plugins.helpers.snowsl_vars_reader import check_env_vars
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.config import (
     ConnectionConfig,
@@ -29,7 +31,12 @@ from snowflake.cli.api.config import (
     set_config_value,
 )
 from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.output.types import CommandResult, MessageResult
+from snowflake.cli.api.output.types import (
+    CollectionResult,
+    CommandResult,
+    MessageResult,
+    MultipleResults,
+)
 from snowflake.cli.api.project.definition_conversion import (
     convert_project_definition_to_v2,
 )
@@ -293,3 +300,20 @@ def _validate_and_save_connections_imported_from_snowsql(
             path=["default_connection_name"],
             value=default_cli_connection_name,
         )
+
+
+@app.command(name="check-snowsql-env-vars", requires_connection=False)
+def check_snowsql_env_vars(**options):
+    """Check if there are any SnowSQL environment variables set."""
+
+    env_vars = os.environ.copy()
+    discovered, unused, summary = check_env_vars(env_vars)
+
+    results = []
+    if discovered:
+        results.append(CollectionResult(discovered))
+    if unused:
+        results.append(CollectionResult(unused))
+
+    results.append(MessageResult(summary))
+    return MultipleResults(results)

snowflake/cli/_plugins/helpers/snowsl_vars_reader.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+EnvVars = dict[str, str]
+
+DicoveredVars = list[dict[str, str]]
+UnusedVars = list[dict[str, str]]
+Summary = str
+
+CheckResult = tuple[DicoveredVars, UnusedVars, Summary]
+
+KNOWN_SNOWSQL_ENV_VARS = {
+    "SNOWSQL_ACCOUNT": {
+        "Found": "SNOWSQL_ACCOUNT",
+        "Suggested": "SNOWFLAKE_ACCOUNT",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_PWD": {
+        "Found": "SNOWSQL_PASSWORD",
+        "Suggested": "SNOWFLAKE_PASSWORD",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_USER": {
+        "Found": "SNOWSQL_USER",
+        "Suggested": "SNOWFLAKE_USER",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_REGION": {
+        "Found": "SNOWSQL_REGION",
+        "Suggested": "SNOWFLAKE_REGION",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_ROLE": {
+        "Found": "SNOWSQL_ROLE",
+        "Suggested": "SNOWFLAKE_ROLE",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_WAREHOUSE": {
+        "Found": "SNOWSQL_WAREHOUSE",
+        "Suggested": "SNOWFLAKE_WAREHOUSE",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_DATABASE": {
+        "Found": "SNOWSQL_DATABASE",
+        "Suggested": "SNOWFLAKE_DATABASE",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_SCHEMA": {
+        "found": "SNOWSQL_SCHEMA",
+        "Suggested": "SNOWFLAKE_SCHEMA",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_HOST": {
+        "Found": "SNOWSQL_HOST",
+        "Suggested": "SNOWFLAKE_HOST",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_PORT": {
+        "Found": "SNOWSQL_PORT",
+        "Suggested": "SNOWFLAKE_PORT",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_PROTOCOL": {
+        "Found": "SNOWSQL_PROTOCOL",
+        "Suggested": "SNOWFLAKE_PROTOCOL",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections#use-environment-variables-for-snowflake-credentials",
+    },
+    "SNOWSQL_PROXY_HOST": {
+        "Found": "SNOWSQL_PROXY_HOST",
+        "Suggested": "PROXY_HOST",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-cli#use-a-proxy-server",
+    },
+    "SNOWSQL_PROXY_PORT": {
+        "Found": "SNOWSQL_PROXY_HOST",
+        "Suggested": "PROXY_HOST",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-cli#use-a-proxy-server",
+    },
+    "SNOWSQL_PROXY_USER": {
+        "Found": "SNOWSQL_PROXY_PORT",
+        "Suggested": "PROXY_PORT",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-cli#use-a-proxy-server",
+    },
+    "SNOWSQL_PROXY_PWD": {
+        "Found": "SNOWSQL_PROXY_PWD",
+        "Suggested": "PROXY_PWD",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-cli#use-a-proxy-server",
+    },
+    "SNOWSQL_PRIVATE_KEY_PASSPHRASE": {
+        "Found": "SNOWSQL_PRIVATE_KEY_PASSPHRASE",
+        "Suggested": "PRIVATE_KEY_PASSPHRASE",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/connecting/configure-connections",
+    },
+    "EXIT_ON_ERROR": {
+        "Found": "EXIT_ON_ERROR",
+        "Suggested": "SNOWFLAKE_ENHANCED_EXIT_CODES",
+        "Additional info": "https://docs.snowflake.com/en/developer-guide/snowflake-cli/sql/execute-sql",
+    },
+}
+
+
+def check_env_vars(variables: EnvVars) -> CheckResult:
+    """Checks passed dict objects for possible SnowSQL variables.
+
+    Returns tuple of
+    - sequence of variables that can be adjusted
+    - sequence of variables that have no corresponding variables
+    - a summary messages
+    """
+    discovered: DicoveredVars = []
+    unused: UnusedVars = []
+
+    prefix_matched = (e for e in variables if e.lower().startswith("snowsql"))
+
+    for var in prefix_matched:
+        if suggestion := KNOWN_SNOWSQL_ENV_VARS.get(var, None):
+            discovered.append(suggestion)
+        else:
+            unused.append(
+                {
+                    "Found": var,
+                    "Suggested": "n/a",
+                    "Additional info": "Unused variable",
+                }
+            )
+
+    discovered_cnt = len(discovered)
+    unused_cnt = len(unused)
+
+    summary: Summary = (
+        f"Found {discovered_cnt + unused_cnt} SnowSQL environment variables,"
+        f" {discovered_cnt} with replacements, {unused_cnt} unused."
+    )
+
+    return discovered, unused, summary

snowflake/cli/_plugins/init/commands.py

@@ -28,7 +28,7 @@ from snowflake.cli.api.commands.flags import (
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
-from snowflake.cli.api.exceptions import InvalidTemplate
+from snowflake.cli.api.exceptions import InvalidTemplateError
 from snowflake.cli.api.output.types import (
     CommandResult,
     MessageResult,
@@ -138,7 +138,7 @@ def _read_template_metadata(template_root: SecurePath, args_error_msg: str) -> T
     template_metadata_path = template_root / TEMPLATE_METADATA_FILE_NAME
     log.debug("Reading template metadata from %s", template_metadata_path.path)
     if not template_metadata_path.exists():
-        raise InvalidTemplate(
+        raise InvalidTemplateError(
             f"File {TEMPLATE_METADATA_FILE_NAME} not found. {args_error_msg}"
         )
     with template_metadata_path.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
@@ -201,8 +201,9 @@ def init(
     variables_from_flags = {
         v.key: v.value for v in parse_key_value_variables(variables)
     }
-    is_remote = any(
-        template_source.startswith(prefix) for prefix in ["git@", "http://", "https://"]  # type: ignore
+    is_remote = template_source is not None and any(
+        template_source.startswith(prefix)
+        for prefix in ["git@", "http://", "https://"]  # type: ignore
     )
     args_error_msg = f"Check whether {TemplateOption.param_decls[0]} and {SourceOption.param_decls[0]} arguments are correct."
 
@@ -210,11 +211,13 @@ def init(
     with SecurePath.temporary_directory() as tmpdir:
         if is_remote:
             template_root = _fetch_remote_template(
-                url=template_source, path=template, destination=tmpdir  # type: ignore
+                url=template_source,  # type: ignore
+                path=template,
+                destination=tmpdir,  # type: ignore
             )
         else:
             template_root = _fetch_local_template(
-                template_source=SecurePath(template_source),
+                template_source=SecurePath(template_source),  # type: ignore
                 path=template,
                 destination=tmpdir,
             )

snowflake/cli/_plugins/logs/commands.py

@@ -0,0 +1,105 @@
+import itertools
+from datetime import datetime
+from typing import Generator, Iterable, Optional, cast
+
+import typer
+from click import ClickException
+from snowflake.cli._plugins.logs.manager import LogsManager
+from snowflake.cli._plugins.logs.utils import LOG_LEVELS, LogsQueryRow
+from snowflake.cli._plugins.object.commands import NameArgument, ObjectArgument
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.exceptions import CliArgumentError
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.output.types import (
+    CommandResult,
+    MessageResult,
+    StreamResult,
+)
+
+app = SnowTyperFactory()
+
+
+@app.command(name="logs", requires_connection=True)
+def get_logs(
+    object_type: str = ObjectArgument,
+    object_name: FQN = NameArgument,
+    from_: Optional[str] = typer.Option(
+        None,
+        "--from",
+        help="The start time of the logs to retrieve. Accepts all ISO8061 formats",
+    ),
+    to: Optional[str] = typer.Option(
+        None,
+        "--to",
+        help="The end time of the logs to retrieve. Accepts all ISO8061 formats",
+    ),
+    refresh_time: int = typer.Option(
+        None,
+        "--refresh",
+        help="If set, the logs will be streamed with the given refresh time in seconds",
+    ),
+    event_table: Optional[str] = typer.Option(
+        None,
+        "--table",
+        help="The table to query for logs. If not provided, the default table will be used",
+    ),
+    log_level: Optional[str] = typer.Option(
+        "INFO",
+        "--log-level",
+        help="The log level to filter by. If not provided, INFO will be used",
+    ),
+    **options,
+):
+    """
+    Retrieves logs for a given object.
+    """
+
+    if log_level and not log_level.upper() in LOG_LEVELS:
+        raise CliArgumentError(
+            f"Invalid log level. Please choose from {', '.join(LOG_LEVELS)}"
+        )
+
+    if refresh_time and to:
+        raise ClickException(
+            "You cannot set both --refresh and --to parameters. Please check the values"
+        )
+
+    from_time = get_datetime_from_string(from_, "--from") if from_ else None
+    to_time = get_datetime_from_string(to, "--to") if to else None
+
+    if refresh_time:
+        logs_stream: Iterable[LogsQueryRow] = LogsManager().stream_logs(
+            object_type=object_type,
+            object_name=object_name,
+            from_time=from_time,
+            refresh_time=refresh_time,
+            event_table=event_table,
+            log_level=log_level,
+        )
+        logs = itertools.chain(
+            (MessageResult(log.log_message) for logs in logs_stream for log in logs)
+        )
+    else:
+        logs_iterable: Iterable[LogsQueryRow] = LogsManager().get_logs(
+            object_type=object_type,
+            object_name=object_name,
+            from_time=from_time,
+            to_time=to_time,
+            event_table=event_table,
+            log_level=log_level,
+        )
+        logs = (MessageResult(log.log_message) for log in logs_iterable)  # type: ignore
+
+    return StreamResult(cast(Generator[CommandResult, None, None], logs))
+
+
+def get_datetime_from_string(
+    date_str: str,
+    name: Optional[str] = None,
+) -> datetime:
+    try:
+        return datetime.fromisoformat(date_str)
+    except ValueError:
+        raise ClickException(
+            f"Incorrect format for '{name}'. Please use one of approved ISO formats."
+        )

snowflake/cli/_plugins/logs/manager.py

@@ -0,0 +1,107 @@
+import time
+from datetime import datetime
+from textwrap import dedent
+from typing import Iterable, List, Optional
+
+from snowflake.cli._plugins.logs.utils import (
+    LogsQueryRow,
+    get_timestamp_query,
+    parse_log_levels_for_query,
+    sanitize_logs,
+)
+from snowflake.cli._plugins.object.commands import NameArgument, ObjectArgument
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.connector.cursor import SnowflakeCursor
+
+
+class LogsManager(SqlExecutionMixin):
+    def stream_logs(
+        self,
+        refresh_time: int,
+        object_type: str = ObjectArgument,
+        object_name: FQN = NameArgument,
+        from_time: Optional[datetime] = None,
+        event_table: Optional[str] = None,
+        log_level: Optional[str] = "INFO",
+    ) -> Iterable[List[LogsQueryRow]]:
+        try:
+            previous_end = from_time
+
+            while True:
+                raw_logs = self.get_raw_logs(
+                    object_type=object_type,
+                    object_name=object_name,
+                    from_time=previous_end,
+                    to_time=None,
+                    event_table=event_table,
+                    log_level=log_level,
+                ).fetchall()
+
+                if raw_logs:
+                    result = self.sanitize_logs(raw_logs)
+                    yield result
+                    if result:
+                        previous_end = result[-1].timestamp
+                time.sleep(refresh_time)
+
+        except KeyboardInterrupt:
+            return
+
+    def get_logs(
+        self,
+        object_type: str = ObjectArgument,
+        object_name: FQN = NameArgument,
+        from_time: Optional[datetime] = None,
+        to_time: Optional[datetime] = None,
+        event_table: Optional[str] = None,
+        log_level: Optional[str] = "INFO",
+    ) -> Iterable[LogsQueryRow]:
+        """
+        Basic function to get a single batch of logs from the server
+        """
+
+        logs = self.get_raw_logs(
+            object_type=object_type,
+            object_name=object_name,
+            from_time=from_time,
+            to_time=to_time,
+            event_table=event_table,
+            log_level=log_level,
+        )
+
+        return sanitize_logs(logs)
+
+    def get_raw_logs(
+        self,
+        object_type: str = ObjectArgument,
+        object_name: FQN = NameArgument,
+        from_time: Optional[datetime] = None,
+        to_time: Optional[datetime] = None,
+        event_table: Optional[str] = None,
+        log_level: Optional[str] = "INFO",
+    ) -> SnowflakeCursor:
+
+        table = event_table if event_table else "SNOWFLAKE.TELEMETRY.EVENTS"
+
+        query = dedent(
+            f"""
+            SELECT
+                timestamp,
+                resource_attributes:"snow.database.name"::string as database_name,
+                resource_attributes:"snow.schema.name"::string as schema_name,
+                resource_attributes:"snow.{object_type}.name"::string as object_name,
+                record:severity_text::string as log_level,
+                value::string as log_message
+            FROM {table}
+            WHERE record_type = 'LOG'
+            AND (record:severity_text IN ({parse_log_levels_for_query((log_level))}) or record:severity_text is NULL )
+            AND object_name = '{object_name}'
+            {get_timestamp_query(from_time, to_time)}
+            ORDER BY timestamp;
+"""
+        ).strip()
+
+        result = self.execute_query(query)
+
+        return result

snowflake/cli/_plugins/logs/plugin_spec.py

@@ -0,0 +1,16 @@
+from snowflake.cli._plugins.logs import commands
+from snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.SINGLE_COMMAND,
+        typer_instance=commands.app.create_instance(),
+    )

snowflake/cli/_plugins/logs/utils.py

@@ -0,0 +1,60 @@
+from datetime import datetime
+from typing import List, NamedTuple, Optional, Tuple
+
+from snowflake.cli.api.exceptions import CliArgumentError, CliSqlError
+from snowflake.connector.cursor import SnowflakeCursor
+
+LOG_LEVELS = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"]
+
+LogsQueryRow = NamedTuple(
+    "LogsQueryRow",
+    [
+        ("timestamp", datetime),
+        ("database_name", str),
+        ("schema_name", str),
+        ("object_name", str),
+        ("log_level", str),
+        ("log_message", str),
+    ],
+)
+
+
+def sanitize_logs(logs: SnowflakeCursor | List[Tuple]) -> List[LogsQueryRow]:
+    try:
+        return [LogsQueryRow(*log) for log in logs]
+    except TypeError:
+        raise CliSqlError(
+            "Logs table has incorrect format. Please check the logs_table in your database"
+        )
+
+
+def get_timestamp_query(from_time: Optional[datetime], to_time: Optional[datetime]):
+    if from_time and to_time and from_time > to_time:
+        raise CliArgumentError(
+            "From_time cannot be later than to_time. Please check the values"
+        )
+    query = []
+
+    if from_time is not None:
+        query.append(f"AND timestamp >= TO_TIMESTAMP_LTZ('{from_time.isoformat()}')\n")
+
+    if to_time is not None:
+        query.append(f"AND timestamp <= TO_TIMESTAMP_LTZ('{to_time.isoformat()}')\n")
+
+    return "".join(query)
+
+
+def get_log_levels(log_level: str):
+    if log_level.upper() not in LOG_LEVELS and log_level != "":
+        raise CliArgumentError(
+            f"Invalid log level. Please choose from {', '.join(LOG_LEVELS)}"
+        )
+
+    if log_level == "":
+        log_level = "INFO"
+
+    return LOG_LEVELS[LOG_LEVELS.index(log_level.upper()) :]
+
+
+def parse_log_levels_for_query(log_level: str):
+    return ", ".join(f"'{level}'" for level in get_log_levels(log_level))

snowflake/cli/_plugins/notebook/commands.py

@@ -23,6 +23,7 @@ from snowflake.cli._plugins.workspace.manager import WorkspaceManager
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
+    PruneOption,
     ReplaceOption,
     entity_argument,
     identifier_argument,
@@ -108,6 +109,7 @@ def deploy(
         help="Replace notebook object if it already exists. It only uploads new and overwrites existing files, "
         "but does not remove any files already on the stage.",
     ),
+    prune: bool = PruneOption(),
     **options,
 ) -> CommandResult:
     """Uploads a notebook and required files to a stage and creates a Snowflake notebook."""
@@ -132,6 +134,7 @@ def deploy(
         notebook.entity_id,
         EntityActions.DEPLOY,
         replace=replace,
+        prune=prune,
     )
     return MessageResult(
         f"Notebook successfully deployed and available under {notebook_url}"