snowflake-cli 3.3.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/sf_sql_facade.py

@@ -45,6 +45,7 @@ from snowflake.cli._plugins.nativeapp.sf_facade_exceptions import (
     UserScriptError,
     handle_unclassified_error,
 )
+from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.errno import (
@@ -53,6 +54,8 @@ from snowflake.cli.api.errno import (
     APPLICATION_PACKAGE_MAX_VERSIONS_HIT,
     APPLICATION_PACKAGE_PATCH_ALREADY_EXISTS,
     APPLICATION_REQUIRES_TELEMETRY_SHARING,
+    CANNOT_ADD_PATCH_WITH_NON_INCREASING_PATCH_NUMBER,
+    CANNOT_CREATE_VERSION_WITH_NON_ZERO_PATCH,
     CANNOT_DEREGISTER_VERSION_ASSOCIATED_WITH_CHANNEL,
     CANNOT_DISABLE_MANDATORY_TELEMETRY,
     CANNOT_DISABLE_RELEASE_CHANNELS,
@@ -64,6 +67,7 @@ from snowflake.cli.api.errno import (
     MAX_VERSIONS_IN_RELEASE_CHANNEL_REACHED,
     NO_WAREHOUSE_SELECTED_IN_SESSION,
     RELEASE_DIRECTIVE_DOES_NOT_EXIST,
+    RELEASE_DIRECTIVE_UNAPPROVED_VERSION_OR_PATCH,
     RELEASE_DIRECTIVES_VERSION_PATCH_NOT_FOUND,
     SQL_COMPILATION_ERROR,
     TARGET_ACCOUNT_USED_BY_OTHER_RELEASE_DIRECTIVE,
@@ -289,7 +293,7 @@ class SnowflakeSQLFacade:
     def create_version_in_package(
         self,
         package_name: str,
-        stage_fqn: str,
+        path_to_version_directory: str,
         version: str,
         label: str | None = None,
         role: str | None = None,
@@ -297,7 +301,7 @@ class SnowflakeSQLFacade:
         """
         Creates a new version in an existing application package.
         @param package_name: Name of the application package to alter.
-        @param stage_fqn: Stage fully qualified name.
+        @param path_to_version_directory: Path to artifacts on the stage to create a version from.
         @param version: Version name to create.
         @param [Optional] role: Switch to this role while executing create version.
         @param [Optional] label: Label for this version, visible to consumers.
@@ -312,6 +316,9 @@ class SnowflakeSQLFacade:
         with_label_clause = (
             f"label={to_string_literal(label)}" if label is not None else ""
         )
+        using_clause = (
+            f"using {StageManager.quote_stage_name(path_to_version_directory)}"
+        )
 
         action = "register" if available_release_channels else "add"
 
@@ -320,7 +327,7 @@ class SnowflakeSQLFacade:
                 f"""\
                     alter application package {package_name}
                         {action} version {version}
-                        using @{stage_fqn}
+                        {using_clause}
                         {with_label_clause}
                 """
             )
@@ -342,6 +349,10 @@ class SnowflakeSQLFacade:
                             f"Maximum versions reached for application package {package_name}. "
                             "Please drop the other versions first."
                         ) from err
+                    if err.errno == CANNOT_CREATE_VERSION_WITH_NON_ZERO_PATCH:
+                        raise UserInputError(
+                            "Cannot create a new version with a non-zero patch in the manifest file."
+                        ) from err
                 handle_unclassified_error(
                     err,
                     f"Failed to {action} version {version} to application package {package_name}.",
@@ -389,7 +400,7 @@ class SnowflakeSQLFacade:
     def add_patch_to_package_version(
         self,
         package_name: str,
-        stage_fqn: str,
+        path_to_version_directory: str,
         version: str,
         patch: int | None = None,
         label: str | None = None,
@@ -398,7 +409,7 @@ class SnowflakeSQLFacade:
         """
         Add a new patch, optionally a custom one, to an existing version in an application package.
         @param package_name: Name of the application package to alter.
-        @param stage_fqn: Stage fully qualified name.
+        @param path_to_version_directory: Path to artifacts on the stage to create a version from.
         @param version: Version name to create.
         @param [Optional] patch: Patch number to create.
         @param [Optional] label: Label for this patch, visible to consumers.
@@ -416,13 +427,13 @@ class SnowflakeSQLFacade:
         )
 
         patch_query = f" {patch}" if patch is not None else ""
-
+        using_clause = StageManager.quote_stage_name(path_to_version_directory)
         # No space between patch and patch{patch_query} to avoid extra space when patch is None
         add_patch_query = dedent(
             f"""\
                  alter application package {package_name}
                      add patch{patch_query} for version {version}
-                     using @{stage_fqn}{with_label_clause}
+                     using {using_clause}{with_label_clause}
              """
         )
         with self._use_role_optional(role):
@@ -433,8 +444,17 @@ class SnowflakeSQLFacade:
             except Exception as err:
                 if isinstance(err, ProgrammingError):
                     if err.errno == APPLICATION_PACKAGE_PATCH_ALREADY_EXISTS:
+                        extra_message = (
+                            " Check the manifest file for any hard-coded patch value."
+                            if patch is None
+                            else ""
+                        )
                         raise UserInputError(
-                            f"Patch {patch} already exists for version {version} in application package {package_name}."
+                            f"Patch{patch_query} already exists for version {version} in application package {package_name}.{extra_message}"
+                        ) from err
+                    if err.errno == CANNOT_ADD_PATCH_WITH_NON_INCREASING_PATCH_NUMBER:
+                        raise UserInputError(
+                            f"Cannot add a patch with a non-increasing patch number to version {version} in application package {package_name}."
                         ) from err
                 handle_unclassified_error(
                     err,
@@ -713,7 +733,7 @@ class SnowflakeSQLFacade:
         self,
         name: str,
         install_method: SameAccountInstallMethod,
-        stage_fqn: str,
+        path_to_version_directory: str,
         role: str,
         warehouse: str,
         debug_mode: bool | None,
@@ -725,7 +745,7 @@ class SnowflakeSQLFacade:
 
         @param name: Name of the application object
         @param install_method: Method of installing the application
-        @param stage_fqn: FQN of the stage housing the application artifacts
+        @param path_to_version_directory: Path to directory in stage housing the application artifacts
         @param role: Role to use when creating the application and provider-side objects
         @param warehouse: Warehouse which is required to create an application object
         @param debug_mode: Whether to enable debug mode; None means not explicitly enabled or disabled
@@ -750,7 +770,7 @@ class SnowflakeSQLFacade:
 
         with self._use_role_optional(role), self._use_warehouse_optional(warehouse):
             try:
-                using_clause = install_method.using_clause(stage_fqn)
+                using_clause = install_method.using_clause(path_to_version_directory)
 
                 current_release_channel = (
                     get_app_properties().get(CHANNEL_COL) or DEFAULT_CHANNEL
@@ -828,7 +848,7 @@ class SnowflakeSQLFacade:
         name: str,
         package_name: str,
         install_method: SameAccountInstallMethod,
-        stage_fqn: str,
+        path_to_version_directory: str,
         role: str,
         warehouse: str,
         debug_mode: bool | None,
@@ -842,7 +862,7 @@ class SnowflakeSQLFacade:
         @param name: Name of the application object
         @param package_name: Name of the application package to install the application from
         @param install_method: Method of installing the application
-        @param stage_fqn: FQN of the stage housing the application artifacts
+        @param path_to_version_directory: Path to directory in stage housing the application artifacts
         @param role: Role to use when creating the application and provider-side objects
         @param warehouse: Warehouse which is required to create an application object
         @param debug_mode: Whether to enable debug mode; None means not explicitly enabled or disabled
@@ -868,7 +888,7 @@ class SnowflakeSQLFacade:
             )
             authorize_telemetry_clause = f"AUTHORIZE_TELEMETRY_EVENT_SHARING = {str(should_authorize_event_sharing).upper()}"
 
-        using_clause = install_method.using_clause(stage_fqn)
+        using_clause = install_method.using_clause(path_to_version_directory)
         release_channel_clause = (
             f"using release channel {release_channel}" if release_channel else ""
         )
@@ -1096,13 +1116,22 @@ class SnowflakeSQLFacade:
                         raise UserInputError(
                             f"Some target accounts are already referenced by other release directives in application package {package_name}.\n{str(err.msg)}"
                         ) from err
-                    _handle_release_directive_version_error(
-                        err,
-                        package_name=package_name,
-                        release_channel=release_channel,
-                        version=version,
-                        patch=patch,
-                    )
+                    if err.errno == VERSION_NOT_ADDED_TO_RELEASE_CHANNEL:
+                        raise UserInputError(
+                            f"Version {version} is not added to release channel {release_channel}. Please add it to the release channel first."
+                        ) from err
+                    if err.errno == RELEASE_DIRECTIVES_VERSION_PATCH_NOT_FOUND:
+                        raise UserInputError(
+                            f"Patch {patch} for version {version} not found in application package {package_name}."
+                        ) from err
+                    if err.errno == RELEASE_DIRECTIVE_UNAPPROVED_VERSION_OR_PATCH:
+                        raise UserInputError(
+                            f"Version {version}, patch {patch} has not yet been approved to release to accounts outside of this organization."
+                        ) from err
+                    if err.errno == VERSION_DOES_NOT_EXIST:
+                        raise UserInputError(
+                            f"Version {version} does not exist in application package {package_name}."
+                        ) from err
                 handle_unclassified_error(
                     err,
                     f"Failed to set release directive {release_directive} for application package {package_name}.",
@@ -1154,6 +1183,138 @@ class SnowflakeSQLFacade:
                     f"Failed to unset release directive {release_directive} for application package {package_name}.",
                 )
 
+    def add_accounts_to_release_directive(
+        self,
+        package_name: str,
+        release_directive: str,
+        release_channel: str | None,
+        target_accounts: List[str],
+        role: str | None = None,
+    ):
+        """
+        Adds target accounts to a release directive of a release channel in an application package.
+        Release directive must already exist in the application package.
+        Default release directive does not support target accounts.
+
+        @param package_name: Name of the application package to alter.
+        @param release_directive: Name of the release directive to add target accounts to.
+        @param release_channel: Name of the release channel where the release directive belongs to.
+        @param target_accounts: List of target accounts to add to the release directive.
+        @param [Optional] role: Role to switch to while running this script. Current role will be used if no role is passed in.
+        """
+        package_name = to_identifier(package_name)
+        release_channel = to_identifier(release_channel) if release_channel else None
+        release_directive = to_identifier(release_directive)
+
+        if same_identifiers(release_directive, DEFAULT_DIRECTIVE):
+            raise UserInputError(
+                "Default release directive does not support adding accounts. Please specify a non-default release directive."
+            )
+
+        release_channel_statement = ""
+        if release_channel:
+            release_channel_statement = f"modify release channel {release_channel}"
+
+        with self._use_role_optional(role):
+            try:
+                self._sql_executor.execute_query(
+                    dedent(
+                        _strip_empty_lines(
+                            f"""\
+                            alter application package {package_name}
+                                {release_channel_statement}
+                                modify release directive {release_directive}
+                                add accounts = ({','.join(target_accounts)})
+                        """
+                        )
+                    )
+                )
+            except Exception as err:
+                if isinstance(err, ProgrammingError):
+                    if (
+                        err.errno == ACCOUNT_DOES_NOT_EXIST
+                        or err.errno == ACCOUNT_HAS_TOO_MANY_QUALIFIERS
+                    ):
+                        raise UserInputError(
+                            f"Invalid account passed in.\n{str(err.msg)}"
+                        ) from err
+                    if err.errno == RELEASE_DIRECTIVE_DOES_NOT_EXIST:
+                        raise UserInputError(
+                            f"Release directive {release_directive} does not exist in application package {package_name}."
+                        ) from err
+                    if err.errno == TARGET_ACCOUNT_USED_BY_OTHER_RELEASE_DIRECTIVE:
+                        raise UserInputError(
+                            f"Some target accounts are already referenced by other release directives in application package {package_name}.\n{str(err.msg)}"
+                        ) from err
+                handle_unclassified_error(
+                    err,
+                    f"Failed to add accounts to release directive {release_directive} for application package {package_name}.",
+                )
+
+    def remove_accounts_from_release_directive(
+        self,
+        package_name: str,
+        release_directive: str,
+        release_channel: str | None,
+        target_accounts: List[str],
+        role: str | None = None,
+    ):
+        """
+        Removes target accounts from a release directive of a release channel in an application package.
+        Release directive must already exist in the application package.
+        Default release directive does not support target accounts.
+
+        @param package_name: Name of the application package to alter.
+        @param release_directive: Name of the release directive to remove target accounts from.
+        @param release_channel: Name of the release channel where the release directive belongs to.
+        @param target_accounts: List of target accounts to remove from the release directive.
+        @param [Optional] role: Role to switch to while running this script. Current role will be used if no role is passed in.
+        """
+        package_name = to_identifier(package_name)
+        release_channel = to_identifier(release_channel) if release_channel else None
+        release_directive = to_identifier(release_directive)
+
+        if same_identifiers(release_directive, DEFAULT_DIRECTIVE):
+            raise UserInputError(
+                "Default release directive does not support removing accounts. Please specify a non-default release directive."
+            )
+
+        release_channel_statement = ""
+        if release_channel:
+            release_channel_statement = f"modify release channel {release_channel}"
+
+        with self._use_role_optional(role):
+            try:
+                self._sql_executor.execute_query(
+                    dedent(
+                        _strip_empty_lines(
+                            f"""\
+                            alter application package {package_name}
+                                {release_channel_statement}
+                                modify release directive {release_directive}
+                                remove accounts = ({','.join(target_accounts)})
+                        """
+                        )
+                    )
+                )
+            except Exception as err:
+                if isinstance(err, ProgrammingError):
+                    if (
+                        err.errno == ACCOUNT_DOES_NOT_EXIST
+                        or err.errno == ACCOUNT_HAS_TOO_MANY_QUALIFIERS
+                    ):
+                        raise UserInputError(
+                            f"Invalid account passed in.\n{str(err.msg)}"
+                        ) from err
+                    if err.errno == RELEASE_DIRECTIVE_DOES_NOT_EXIST:
+                        raise UserInputError(
+                            f"Release directive {release_directive} does not exist in application package {package_name}."
+                        ) from err
+                handle_unclassified_error(
+                    err,
+                    f"Failed to remove accounts from release directive {release_directive} for application package {package_name}.",
+                )
+
     def show_release_channels(
         self, package_name: str, role: str | None = None
     ) -> list[ReleaseChannel]:
@@ -1295,6 +1456,48 @@ class SnowflakeSQLFacade:
                     f"Failed to remove accounts from release channel {release_channel} in application package {package_name}.",
                 )
 
+    def set_accounts_for_release_channel(
+        self,
+        package_name: str,
+        release_channel: str,
+        target_accounts: List[str],
+        role: str | None = None,
+    ):
+        """
+        Sets accounts for a release channel.
+
+        @param package_name: Name of the application package
+        @param release_channel: Name of the release channel
+        @param target_accounts: List of target accounts to set for the release channel
+        @param [Optional] role: Role to switch to while running this script. Current role will be used if no role is passed in.
+        """
+
+        package_name = to_identifier(package_name)
+        release_channel = to_identifier(release_channel)
+
+        with self._use_role_optional(role):
+            try:
+                self._sql_executor.execute_query(
+                    f"alter application package {package_name} modify release channel {release_channel} set accounts = ({','.join(target_accounts)})"
+                )
+            except Exception as err:
+                if isinstance(err, ProgrammingError):
+                    if (
+                        err.errno == ACCOUNT_DOES_NOT_EXIST
+                        or err.errno == ACCOUNT_HAS_TOO_MANY_QUALIFIERS
+                    ):
+                        raise UserInputError(
+                            f"Invalid account passed in.\n{str(err.msg)}"
+                        ) from err
+                    if err.errno == CANNOT_MODIFY_RELEASE_CHANNEL_ACCOUNTS:
+                        raise UserInputError(
+                            f"Cannot modify accounts for release channel {release_channel} in application package {package_name}."
+                        ) from err
+                handle_unclassified_error(
+                    err,
+                    f"Failed to set accounts for release channel {release_channel} in application package {package_name}.",
+                )
+
     def add_version_to_release_channel(
         self,
         package_name: str,
@@ -1424,26 +1627,3 @@ def _strip_empty_lines(text: str) -> str:
     other_lines = [line for line in all_lines[:-1] if line.strip()]
 
     return "\n".join(other_lines) + "\n" + last_line
-
-
-def _handle_release_directive_version_error(
-    err: ProgrammingError,
-    *,
-    package_name: str,
-    release_channel: str | None,
-    version: str,
-    patch: int,
-) -> None:
-
-    if err.errno == VERSION_NOT_ADDED_TO_RELEASE_CHANNEL:
-        raise UserInputError(
-            f"Version {version} is not added to release channel {release_channel}. Please add it to the release channel first."
-        ) from err
-    if err.errno == RELEASE_DIRECTIVES_VERSION_PATCH_NOT_FOUND:
-        raise UserInputError(
-            f"Patch {patch} for version {version} not found in application package {package_name}."
-        ) from err
-    if err.errno == VERSION_DOES_NOT_EXIST:
-        raise UserInputError(
-            f"Version {version} does not exist in application package {package_name}."
-        ) from err

snowflake/cli/_plugins/nativeapp/v2_conversions/compat.py

@@ -46,7 +46,7 @@ APP_AND_PACKAGE_OPTIONS = [
         annotation=Optional[str],
         default=typer.Option(
             default="",
-            help="The ID of the package entity on which to operate when definition_version is 2 or higher.",
+            help="The ID of the package entity on which to operate when the definition_version is 2 or higher.",
         ),
     ),
     inspect.Parameter(
@@ -55,7 +55,7 @@ APP_AND_PACKAGE_OPTIONS = [
         annotation=Optional[str],
         default=typer.Option(
             default="",
-            help="The ID of the application entity on which to operate when definition_version is 2 or higher.",
+            help="The ID of the application entity on which to operate when the definition_version is 2 or higher.",
         ),
     ),
 ]

snowflake/cli/_plugins/nativeapp/version/commands.py

@@ -29,7 +29,7 @@ from snowflake.cli.api.commands.decorators import (
     with_project_definition,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.entities.common import EntityActions
+from snowflake.cli.api.entities.utils import EntityActions
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import (
     CollectionResult,

snowflake/cli/_plugins/notebook/commands.py

@@ -15,12 +15,28 @@
 import logging
 
 import typer
+from click import UsageError
 from snowflake.cli._plugins.notebook.manager import NotebookManager
+from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntityModel
 from snowflake.cli._plugins.notebook.types import NotebookStagePath
-from snowflake.cli.api.commands.flags import identifier_argument
+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 (
+    ReplaceOption,
+    entity_argument,
+    identifier_argument,
+)
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.commands.utils import get_entity_for_operation
+from snowflake.cli.api.entities.common import EntityActions
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import MessageResult
+from snowflake.cli.api.output.types import (
+    CommandResult,
+    MessageResult,
+)
 from typing_extensions import Annotated
 
 app = SnowTyperFactory(
@@ -84,3 +100,40 @@ def create(
         notebook_file=notebook_file,
     )
     return MessageResult(message=notebook_url)
+
+
+@app.command(requires_connection=True)
+@with_project_definition()
+def deploy(
+    entity_id: str = entity_argument("notebook"),
+    replace: bool = ReplaceOption(
+        help="Replace notebook object if it already exists.",
+    ),
+    **options,
+) -> CommandResult:
+    """Uploads a notebook and required files to a stage and creates a Snowflake notebook."""
+    cli_context = get_cli_context()
+    pd = cli_context.project_definition
+    if not pd.meets_version_requirement("2"):
+        raise UsageError(
+            "This command requires project definition of version at least 2."
+        )
+
+    notebook: NotebookEntityModel = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=entity_id,
+        project_definition=pd,
+        entity_type="notebook",
+    )
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    notebook_url = ws.perform_action(
+        notebook.entity_id,
+        EntityActions.DEPLOY,
+        replace=replace,
+    )
+    return MessageResult(
+        f"Notebook successfully deployed and available under {notebook_url}"
+    )

snowflake/cli/_plugins/notebook/exceptions.py

@@ -15,6 +15,6 @@
 from click.exceptions import ClickException
 
 
-class NotebookStagePathError(ClickException):
+class NotebookFilePathError(ClickException):
     def __init__(self, path: str):
         super().__init__(f"Cannot extract notebook file name from {path=}")

snowflake/cli/_plugins/notebook/manager.py

@@ -16,7 +16,7 @@ from pathlib import Path
 from textwrap import dedent
 
 from snowflake.cli._plugins.connection.util import make_snowsight_url
-from snowflake.cli._plugins.notebook.exceptions import NotebookStagePathError
+from snowflake.cli._plugins.notebook.exceptions import NotebookFilePathError
 from snowflake.cli._plugins.notebook.types import NotebookStagePath
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.identifiers import FQN
@@ -40,11 +40,11 @@ class NotebookManager(SqlExecutionMixin):
     def parse_stage_as_path(notebook_file: str) -> Path:
         """Parses notebook file path to pathlib.Path."""
         if not notebook_file.endswith(".ipynb"):
-            raise NotebookStagePathError(notebook_file)
+            raise NotebookFilePathError(notebook_file)
         # we don't perform any operations on the path, so we don't need to differentiate git repository paths
         stage_path = StagePath.from_stage_str(notebook_file)
         if len(stage_path.parts) < 1:
-            raise NotebookStagePathError(notebook_file)
+            raise NotebookFilePathError(notebook_file)
 
         return stage_path
 

snowflake/cli/_plugins/notebook/notebook_entity.py

@@ -0,0 +1,120 @@
+import functools
+
+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.cli_global_context import get_cli_context
+from snowflake.cli.api.console.console import cli_console
+from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli.api.stage_path import StagePath
+from snowflake.connector import ProgrammingError
+from snowflake.connector.cursor import SnowflakeCursor
+
+_DEFAULT_NOTEBOOK_STAGE_NAME = "@notebooks"
+
+
+class NotebookEntity(EntityBase[NotebookEntityModel]):
+    """
+    A notebook.
+    """
+
+    @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)
+
+    @functools.cached_property
+    def _project_paths(self):
+        return NotebookProjectPaths(get_cli_context().project_root)
+
+    def _object_exists(self) -> bool:
+        # currently notebook objects are not supported by object manager - re-implementing "exists"
+        try:
+            self.action_describe()
+            return True
+        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(
+                self._project_paths.project_root
+            )
+        )
+        query = "CREATE OR REPLACE " if replace else "CREATE "
+        query += (
+            f"NOTEBOOK {self.fqn.sql_identifier}\n"
+            f"FROM '{main_file_stage_path.stage_with_at}'\n"
+            f"QUERY_WAREHOUSE = '{self.model.query_warehouse}'\n"
+            f"MAIN_FILE = '{main_file_stage_path.path}'"
+        )
+        if self.model.compute_pool:
+            query += f"\nCOMPUTE_POOL = '{self.model.compute_pool}'"
+        if self.model.runtime_name:
+            query += f"\nRUNTIME_NAME = '{self.model.runtime_name}'"
+
+        query += (
+            ";\n// Cannot use IDENTIFIER(...)"
+            f"\nALTER NOTEBOOK {self.fqn.identifier} ADD LIVE VERSION FROM LAST;"
+        )
+        return query
+
+    def action_describe(self) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(self.get_describe_sql())
+
+    def action_create(self, replace: bool) -> str:
+        self._sql_executor.execute_query(self.get_create_sql(replace))
+        return make_snowsight_url(
+            self._conn,
+            f"/#/notebooks/{self.fqn.using_connection(self._conn).url_identifier}",
+        )
+
+    def action_deploy(
+        self,
+        action_ctx: ActionContext,
+        replace: bool,
+        *args,
+        **kwargs,
+    ) -> str:
+        if self._object_exists():
+            if not replace:
+                raise ClickException(
+                    f"Notebook {self.fqn.name} already exists. Consider using --replace."
+                )
+        with cli_console.phase(f"Uploading artifacts to {self._stage_path}"):
+            self._upload_artifacts()
+        with cli_console.phase(f"Creating notebook {self.fqn}"):
+            return self.action_create(replace=replace)
+
+    # complementary actions, currently not used - to be implemented in future
+    def action_drop(self, *args, **kwargs):
+        raise ClickException("action DROP not supported by NOTEBOOK entity")
+
+    def action_teardown(self, *args, **kwargs):
+        raise ClickException("action TEARDOWN not supported by NOTEBOOK entity")