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

snowflake/cli/_plugins/stage/commands.py

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

snowflake/cli/_plugins/stage/manager.py

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

snowflake/cli/_plugins/streamlit/commands.py

@@ -46,13 +46,12 @@ from snowflake.cli.api.output.types import (
     MessageResult,
     SingleQueryResult,
 )
+from snowflake.cli.api.project.definition_conversion import (
+    convert_project_definition_to_v2,
+)
 from snowflake.cli.api.project.schemas.entities.streamlit_entity_model import (
     StreamlitEntityModel,
 )
-from snowflake.cli.api.project.schemas.project_definition import (
-    ProjectDefinition,
-    ProjectDefinitionV2,
-)
 
 app = SnowTyperFactory(
     name="streamlit",
@@ -139,7 +138,7 @@ def streamlit_deploy(
             raise NoProjectDefinitionError(
                 project_type="streamlit", project_root=cli_context.project_root
             )
-        pd = migrate_v1_streamlit_to_v2(pd)
+        pd = convert_project_definition_to_v2(cli_context.project_root, pd)
 
     streamlits: Dict[str, StreamlitEntityModel] = pd.get_entities_by_type(
         entity_type="streamlit"
@@ -171,64 +170,6 @@ def streamlit_deploy(
     return MessageResult(f"Streamlit successfully deployed and available under {url}")
 
 
-def migrate_v1_streamlit_to_v2(pd: ProjectDefinition):
-    default_env_file = "environment.yml"
-    default_pages_dir = "pages"
-
-    # Process env file
-    environment_file = pd.streamlit.env_file
-    if environment_file and not Path(environment_file).exists():
-        raise ClickException(f"Provided file {environment_file} does not exist")
-    elif environment_file is None and Path(default_env_file).exists():
-        environment_file = default_env_file
-    # Process pages dir
-    pages_dir = pd.streamlit.pages_dir
-    if pages_dir and not Path(pages_dir).exists():
-        raise ClickException(f"Provided file {pages_dir} does not exist")
-    elif pages_dir is None and Path(default_pages_dir).exists():
-        pages_dir = default_pages_dir
-
-    # Build V2 definition
-    artifacts = [
-        pd.streamlit.main_file,
-        environment_file,
-        pages_dir,
-    ]
-    artifacts = [a for a in artifacts if a is not None]
-    if pd.streamlit.additional_source_files:
-        artifacts.extend(pd.streamlit.additional_source_files)
-
-    identifier = {"name": pd.streamlit.name}
-    if pd.streamlit.schema_name:
-        identifier["schema"] = pd.streamlit.schema_name
-    if pd.streamlit.database:
-        identifier["database"] = pd.streamlit.database
-
-    if pd.streamlit.name.startswith("<%") and pd.streamlit.name.endswith("%>"):
-        streamlit_name = "streamlit_entity_1"
-    else:
-        streamlit_name = pd.streamlit.name
-
-    data = {
-        "definition_version": "2",
-        "entities": {
-            streamlit_name: {
-                "type": "streamlit",
-                "identifier": identifier,
-                "title": pd.streamlit.title,
-                "query_warehouse": pd.streamlit.query_warehouse,
-                "main_file": str(pd.streamlit.main_file),
-                "pages_dir": str(pd.streamlit.pages_dir),
-                "stage": pd.streamlit.stage,
-                "artifacts": artifacts,
-            }
-        },
-    }
-    if hasattr(pd, "env") and pd.env:
-        data["env"] = {k: v for k, v in pd.env.items()}
-    return ProjectDefinitionV2(**data)
-
-
 @app.command("get-url", requires_connection=True)
 def get_url(
     name: FQN = StreamlitNameArgument,

snowflake/cli/_plugins/streamlit/manager.py

@@ -18,11 +18,13 @@ import logging
 from pathlib import Path
 from typing import List, Optional
 
+from click import ClickException
 from snowflake.cli._plugins.connection.util import (
     MissingConnectionAccountError,
     MissingConnectionRegionError,
     make_snowsight_url,
 )
+from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli.api.commands.experimental_behaviour import (
     experimental_behaviour_enabled,
@@ -57,6 +59,10 @@ class StreamlitManager(SqlExecutionMixin):
         stage_manager = StageManager()
         for file in artifacts:
             if file.is_dir():
+                if not any(file.iterdir()):
+                    cli_console.warning(f"Skipping empty directory: {file}")
+                    continue
+
                 stage_manager.put(
                     f"{file.joinpath('*')}", f"{root_location}/{file}", 4, True
                 )
@@ -108,6 +114,13 @@ class StreamlitManager(SqlExecutionMixin):
 
     def deploy(self, streamlit: StreamlitEntityModel, replace: bool = False):
         streamlit_id = streamlit.fqn.using_connection(self._conn)
+        if (
+            ObjectManager().object_exists(object_type="streamlit", fqn=streamlit_id)
+            and not replace
+        ):
+            raise ClickException(
+                f"Streamlit {streamlit.fqn} already exist. If you want to replace it use --replace flag."
+            )
 
         # for backwards compatibility - quoted stage path might be case-sensitive
         # https://docs.snowflake.com/en/sql-reference/identifiers-syntax#double-quoted-identifiers

snowflake/cli/_plugins/workspace/action_context.py

@@ -1,5 +1,8 @@
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Callable, Optional
+
+from snowflake.cli.api.console.abc import AbstractConsole
 
 
 @dataclass
@@ -8,4 +11,8 @@ class ActionContext:
     An object that is passed to each action when called by WorkspaceManager
     """
 
+    console: AbstractConsole
     project_root: Path
+    default_role: str
+    default_warehouse: Optional[str]
+    get_entity: Callable

snowflake/cli/_plugins/workspace/commands.py

@@ -15,19 +15,28 @@
 from __future__ import annotations
 
 import logging
+from pathlib import Path
+from textwrap import dedent
+from typing import List, Optional
 
 import typer
 import yaml
-from click import ClickException
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
-from snowflake.cli._plugins.snowpark.commands import migrate_v1_snowpark_to_v2
-from snowflake.cli._plugins.streamlit.commands import migrate_v1_streamlit_to_v2
+from snowflake.cli._plugins.nativeapp.common_flags import (
+    ForceOption,
+    InteractiveOption,
+    ValidateOption,
+)
 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.snow_typer import SnowTyper
 from snowflake.cli.api.entities.common import EntityActions
+from snowflake.cli.api.exceptions import IncompatibleParametersError
 from snowflake.cli.api.output.types import MessageResult
+from snowflake.cli.api.project.definition_conversion import (
+    convert_project_definition_to_v2,
+)
 from snowflake.cli.api.project.definition_manager import DefinitionManager
 from snowflake.cli.api.secure_path import SecurePath
 
@@ -45,30 +54,14 @@ def migrate(
     ),
     **options,
 ):
-    """Migrates the Snowpark and Streamlit project definition files form V1 to V2."""
-    pd = DefinitionManager().unrendered_project_definition
+    """Migrates the Snowpark, Streamlit, and Native App project definition files from V1 to V2."""
+    manager = DefinitionManager()
+    pd = manager.unrendered_project_definition
 
     if pd.meets_version_requirement("2"):
         return MessageResult("Project definition is already at version 2.")
 
-    if "<% ctx." in str(pd):
-        if not accept_templates:
-            raise ClickException(
-                "Project definition contains templates. They may not be migrated correctly, and require manual migration."
-                "You can try again with --accept-templates  option, to attempt automatic migration."
-            )
-        log.warning(
-            "Your V1 definition contains templates. We cannot guarantee the correctness of the migration."
-        )
-
-    if pd.streamlit:
-        pd_v2 = migrate_v1_streamlit_to_v2(pd)
-    elif pd.snowpark:
-        pd_v2 = migrate_v1_snowpark_to_v2(pd)
-    else:
-        raise ValueError(
-            "Only Snowpark and Streamlit entities are supported for migration."
-        )
+    pd_v2 = convert_project_definition_to_v2(manager.project_root, pd, accept_templates)
 
     SecurePath("snowflake.yml").rename("snowflake_V1.yml")
     with open("snowflake.yml", "w") as file:
@@ -83,25 +76,80 @@ def migrate(
 
 @ws.command(requires_connection=True, hidden=True)
 @with_project_definition()
-def validate(
+def bundle(
+    entity_id: str = typer.Option(
+        help=f"""The ID of the entity you want to bundle.""",
+    ),
     **options,
 ):
-    """Validates the project definition file."""
-    # If we get to this point, @with_project_definition() has already validated the PDF schema
-    return MessageResult("Project definition is valid.")
+    """
+    Prepares a local folder with the configured artifacts of the specified entity.
+    """
+
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+
+    bundle_map: BundleMap = ws.perform_action(entity_id, EntityActions.BUNDLE)
+    return MessageResult(f"Bundle generated at {bundle_map.deploy_root()}")
 
 
 @ws.command(requires_connection=True, hidden=True)
 @with_project_definition()
-def bundle(
+def deploy(
     entity_id: str = typer.Option(
-        help=f"""The ID of the entity you want to bundle.""",
+        help=f"""The ID of the entity you want to deploy.""",
+    ),
+    # TODO The following options should be generated automatically, depending on the specified entity type
+    prune: Optional[bool] = typer.Option(
+        default=None,
+        help=f"""Whether to delete specified files from the stage if they don't exist locally. If set, the command deletes files that exist in the stage, but not in the local filesystem. This option cannot be used when paths are specified.""",
+    ),
+    recursive: Optional[bool] = typer.Option(
+        None,
+        "--recursive/--no-recursive",
+        "-r",
+        help=f"""Whether to traverse and deploy files from subdirectories. If set, the command deploys all files and subdirectories; otherwise, only files in the current directory are deployed.""",
     ),
+    paths: Optional[List[Path]] = typer.Argument(
+        default=None,
+        show_default=False,
+        help=dedent(
+            f"""
+            Paths, relative to the the project root, of files or directories you want to upload to a stage. If a file is
+            specified, it must match one of the artifacts src pattern entries in snowflake.yml. If a directory is
+            specified, it will be searched for subfolders or files to deploy based on artifacts src pattern entries. If
+            unspecified, the command syncs all local changes to the stage."""
+        ).strip(),
+    ),
+    from_release_directive: Optional[bool] = typer.Option(
+        False,
+        "--from-release-directive",
+        help=f"""Creates or upgrades an application object to the version and patch specified by the release directive applicable to your Snowflake account.
+        The command fails if no release directive exists for your Snowflake account for a given application package, which is determined from the project definition file. Default: unset.""",
+        is_flag=True,
+    ),
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
+    validate: bool = ValidateOption,
     **options,
 ):
     """
-    Prepares a local folder with the configured artifacts of the specified entity.
+    Deploys the specified entity.
     """
+    if prune is None and recursive is None and not paths:
+        prune = True
+        recursive = True
+    else:
+        if prune is None:
+            prune = False
+        if recursive is None:
+            recursive = False
+
+    if paths and prune:
+        raise IncompatibleParametersError(["paths", "--prune"])
 
     cli_context = get_cli_context()
     ws = WorkspaceManager(
@@ -109,5 +157,70 @@ def bundle(
         project_root=cli_context.project_root,
     )
 
-    bundle_map: BundleMap = ws.perform_action(entity_id, EntityActions.BUNDLE)
-    return MessageResult(f"Bundle generated at {bundle_map.deploy_root()}")
+    ws.perform_action(
+        entity_id,
+        EntityActions.DEPLOY,
+        prune=prune,
+        recursive=recursive,
+        paths=paths,
+        validate=validate,
+        from_release_directive=from_release_directive,
+        interactive=interactive,
+        force=force,
+    )
+    return MessageResult("Deployed successfully.")
+
+
+@ws.command(requires_connection=True, hidden=True)
+@with_project_definition()
+def drop(
+    entity_id: str = typer.Option(
+        help=f"""The ID of the entity you want to drop.""",
+    ),
+    # TODO The following options should be generated automatically, depending on the specified entity type
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
+    cascade: Optional[bool] = typer.Option(
+        None,
+        help=f"""Whether to drop all application objects owned by the application within the account. Default: false.""",
+        show_default=False,
+    ),
+    **options,
+):
+    """
+    Drops the specified entity.
+    """
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+
+    ws.perform_action(
+        entity_id,
+        EntityActions.DROP,
+        force_drop=force,
+        interactive=interactive,
+        cascade=cascade,
+    )
+
+
+@ws.command(requires_connection=True, hidden=True)
+@with_project_definition()
+def validate(
+    entity_id: str = typer.Option(
+        help=f"""The ID of the entity you want to validate.""",
+    ),
+    **options,
+):
+    """Validates the specified entity."""
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+
+    ws.perform_action(
+        entity_id,
+        EntityActions.VALIDATE,
+    )

snowflake/cli/_plugins/workspace/manager.py

@@ -2,8 +2,11 @@ from pathlib import Path
 from typing import Dict
 
 from snowflake.cli._plugins.workspace.action_context import ActionContext
-from snowflake.cli.api.entities.common import EntityActions
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.entities.common import EntityActions, get_sql_executor
 from snowflake.cli.api.exceptions import InvalidProjectDefinitionVersionError
+from snowflake.cli.api.project.definition import default_role
 from snowflake.cli.api.project.schemas.entities.entities import (
     Entity,
     v2_entity_model_to_entity_map,
@@ -12,6 +15,7 @@ from snowflake.cli.api.project.schemas.project_definition import (
     DefinitionV20,
     ProjectDefinition,
 )
+from snowflake.cli.api.project.util import to_identifier
 
 
 class WorkspaceManager:
@@ -27,6 +31,13 @@ class WorkspaceManager:
         self._entities_cache: Dict[str, Entity] = {}
         self._project_definition: DefinitionV20 = project_definition
         self._project_root = project_root
+        self._default_role = default_role()
+        if self._default_role is None:
+            self._default_role = get_sql_executor().current_role()
+        self.default_warehouse = None
+        cli_context = get_cli_context()
+        if cli_context.connection.warehouse:
+            self.default_warehouse = to_identifier(cli_context.connection.warehouse)
 
     def get_entity(self, entity_id: str):
         """
@@ -42,14 +53,20 @@ class WorkspaceManager:
         self._entities_cache[entity_id] = entity_cls(entity_model)
         return self._entities_cache[entity_id]
 
-    def perform_action(self, entity_id: str, action: EntityActions):
+    def perform_action(self, entity_id: str, action: EntityActions, *args, **kwargs):
         """
         Instantiates an entity of the given ID and calls the given action on it.
         """
         entity = self.get_entity(entity_id)
         if entity.supports(action):
-            action_ctx = ActionContext(project_root=self.project_root())
-            return entity.perform(action, action_ctx)
+            action_ctx = ActionContext(
+                console=cc,
+                project_root=self.project_root(),
+                default_role=self._default_role,
+                default_warehouse=self.default_warehouse,
+                get_entity=self.get_entity,
+            )
+            return entity.perform(action, action_ctx, *args, **kwargs)
         else:
             raise ValueError(f'This entity type does not support "{action.value}"')