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

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/nativeapp/entities/application.py

@@ -669,7 +669,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 role_to_use=package.role,
             )
 
-        return get_snowflake_facade().create_application(
+        create_app_result, warnings = get_snowflake_facade().create_application(
             name=self.name,
             package_name=package.name,
             install_method=install_method,
@@ -680,6 +680,9 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             warehouse=self.warehouse,
             release_channel=release_channel,
         )
+        for warning in warnings:
+            self.console.warning(warning)
+        return create_app_result
 
     @span("update_app_object")
     def create_or_upgrade_app(

snowflake/cli/_plugins/nativeapp/sf_sql_facade.py

@@ -60,6 +60,7 @@ from snowflake.cli.api.errno import (
     CANNOT_DISABLE_MANDATORY_TELEMETRY,
     CANNOT_DISABLE_RELEASE_CHANNELS,
     CANNOT_MODIFY_RELEASE_CHANNEL_ACCOUNTS,
+    CANNOT_SET_DEBUG_MODE_WITH_MANIFEST_VERSION,
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
     INSUFFICIENT_PRIVILEGES,
@@ -854,7 +855,7 @@ class SnowflakeSQLFacade:
         debug_mode: bool | None,
         should_authorize_event_sharing: bool | None,
         release_channel: str | None = None,
-    ) -> list[tuple[str]]:
+    ) -> tuple[list[tuple[str]], list[str]]:
         """
         Creates a new application object using an application package,
         running the setup script of the application package
@@ -868,6 +869,7 @@ class SnowflakeSQLFacade:
         @param debug_mode: Whether to enable debug mode; None means not explicitly enabled or disabled
         @param should_authorize_event_sharing: Whether to enable event sharing; None means not explicitly enabled or disabled
         @param release_channel [Optional]: Release channel to use when creating the application
+        @return: a tuple containing the result of the create application query and possible warning messages
         """
         package_name = to_identifier(package_name)
         name = to_identifier(name)
@@ -875,11 +877,9 @@ class SnowflakeSQLFacade:
 
         # by default, applications are created in debug mode when possible;
         # this can be overridden in the project definition
-        debug_mode_clause = ""
+        initial_debug_mode = False
         if install_method.is_dev_mode:
             initial_debug_mode = debug_mode if debug_mode is not None else True
-            debug_mode_clause = f"debug_mode = {initial_debug_mode}"
-
         authorize_telemetry_clause = ""
         if should_authorize_event_sharing is not None:
             self._log.info(
@@ -903,13 +903,13 @@ class SnowflakeSQLFacade:
                                     from application package {package_name}
                                     {using_clause}
                                     {release_channel_clause}
-                                    {debug_mode_clause}
                                     {authorize_telemetry_clause}
                                     comment = {SPECIAL_COMMENT}
                             """
                         )
                     ),
                 )
+
             except Exception as err:
                 if isinstance(err, ProgrammingError):
                     if err.errno == APPLICATION_REQUIRES_TELEMETRY_SHARING:
@@ -927,9 +927,36 @@ class SnowflakeSQLFacade:
                             f"Failed to create application {name} with the following error message:\n"
                             f"{err.msg}"
                         ) from err
+
                 handle_unclassified_error(err, f"Failed to create application {name}.")
 
-            return create_cursor.fetchall()
+            warnings = []
+            try:
+                if initial_debug_mode:
+                    self._sql_executor.execute_query(
+                        dedent(
+                            _strip_empty_lines(
+                                f"""\
+                                    alter application {name}
+                                    set debug_mode = {initial_debug_mode}
+                                """
+                            )
+                        )
+                    )
+            except Exception as err:
+                if (
+                    isinstance(err, ProgrammingError)
+                    and err.errno == CANNOT_SET_DEBUG_MODE_WITH_MANIFEST_VERSION
+                ):
+                    warnings.append(
+                        "Did not apply debug mode to application because the manifest version is set to 2 or higher. Please use session debugging instead."
+                    )
+                else:
+                    warnings.append(
+                        f"Failed to set debug mode for application {name}. {str(err)}"
+                    )
+
+            return create_cursor.fetchall(), warnings
 
     def create_application_package(
         self,

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}"

snowflake/cli/_plugins/notebook/notebook_entity.py

@@ -4,9 +4,8 @@ from click import ClickException
 from snowflake.cli._plugins.connection.util import make_snowsight_url
 from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntityModel
 from snowflake.cli._plugins.notebook.notebook_project_paths import NotebookProjectPaths
-from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli._plugins.workspace.context import ActionContext
-from snowflake.cli.api.artifacts.utils import bundle_artifacts
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.entities.common import EntityBase
@@ -22,12 +21,15 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
     A notebook.
     """
 
+    @property
+    def _stage_path_from_model(self) -> str:
+        if self.model.stage_path is None:
+            return f"{_DEFAULT_NOTEBOOK_STAGE_NAME}/{self.fqn.name}"
+        return self.model.stage_path
+
     @functools.cached_property
     def _stage_path(self) -> StagePath:
-        stage_path = self.model.stage_path
-        if stage_path is None:
-            stage_path = f"{_DEFAULT_NOTEBOOK_STAGE_NAME}/{self.fqn.name}"
-        return StagePath.from_stage_str(stage_path)
+        return StagePath.from_stage_str(self._stage_path_from_model)
 
     @functools.cached_property
     def _project_paths(self):
@@ -41,26 +43,6 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
         except ProgrammingError:
             return False
 
-    def _upload_artifacts(self):
-        stage_fqn = self._stage_path.stage_fqn
-        stage_manager = StageManager()
-        cli_console.step(f"Creating stage {stage_fqn} if not exists")
-        stage_manager.create(fqn=stage_fqn)
-
-        cli_console.step("Uploading artifacts")
-
-        # creating bundle map to handle glob patterns logic
-        bundle_map = bundle_artifacts(self._project_paths, self.model.artifacts)
-        for absolute_src, absolute_dest in bundle_map.all_mappings(
-            absolute=True, expand_directories=True
-        ):
-            artifact_stage_path = self._stage_path / (
-                absolute_dest.relative_to(self._project_paths.bundle_root).parent
-            )
-            stage_manager.put(
-                local_path=absolute_src, stage_path=artifact_stage_path, overwrite=True
-            )
-
     def get_create_sql(self, replace: bool) -> str:
         main_file_stage_path = self._stage_path / (
             self.model.notebook_file.absolute().relative_to(
@@ -99,6 +81,7 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
         self,
         action_ctx: ActionContext,
         replace: bool,
+        prune: bool,
         *args,
         **kwargs,
     ) -> str:
@@ -108,7 +91,13 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
                     f"Notebook {self.fqn.name} already exists. Consider using --replace."
                 )
         with cli_console.phase(f"Uploading artifacts to {self._stage_path}"):
-            self._upload_artifacts()
+            sync_artifacts_with_stage(
+                project_paths=self._project_paths,
+                stage_root=self._stage_path_from_model,
+                prune=prune,
+                artifacts=self.model.artifacts,
+            )
+
         with cli_console.phase(f"Creating notebook {self.fqn}"):
             return self.action_create(replace=replace)
 

snowflake/cli/_plugins/object/command_aliases.py

@@ -36,8 +36,10 @@ def add_object_command_aliases(
     name_argument: typer.Argument,
     like_option: Optional[typer.Option],
     scope_option: Optional[typer.Option],
-    ommit_commands: List[str] = [],
+    ommit_commands: Optional[List[str]] = None,
 ):
+    if ommit_commands is None:
+        ommit_commands = list()
     if "list" not in ommit_commands:
         if not like_option:
             raise ClickException('[like_option] have to be defined for "list" command')

snowflake/cli/_plugins/object/manager.py

@@ -58,14 +58,16 @@ class ObjectManager(SqlExecutionMixin):
         object_name = _get_object_names(object_type).sf_name
         return self.execute_query(f"drop {object_name} {fqn.sql_identifier}")
 
-    def describe(self, *, object_type: str, fqn: FQN):
+    def describe(self, *, object_type: str, fqn: FQN, **kwargs):
         # Image repository is the only supported object that does not have a DESCRIBE command.
         if object_type == "image-repository":
             raise ClickException(
                 f"Describe is currently not supported for object of type image-repository"
             )
         object_name = _get_object_names(object_type).sf_name
-        return self.execute_query(f"describe {object_name} {fqn.sql_identifier}")
+        return self.execute_query(
+            f"describe {object_name} {fqn.sql_identifier}", **kwargs
+        )
 
     def object_exists(self, *, object_type: str, fqn: FQN):
         try: