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

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(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

@@ -57,6 +57,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
                 )

snowflake/cli/_plugins/workspace/action_context.py

@@ -1,5 +1,8 @@
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Optional
+
+from snowflake.cli.api.console.abc import AbstractConsole
 
 
 @dataclass
@@ -8,4 +11,7 @@ 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]

snowflake/cli/_plugins/workspace/commands.py

@@ -15,19 +15,27 @@
 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,
+    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 +53,13 @@ def migrate(
     ),
     **options,
 ):
-    """Migrates the Snowpark and Streamlit project definition files form V1 to V2."""
+    """Migrates the Snowpark and Streamlit project definition files from V1 to V2."""
     pd = DefinitionManager().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(pd, accept_templates)
 
     SecurePath("snowflake.yml").rename("snowflake_V1.yml")
     with open("snowflake.yml", "w") as file:
@@ -111,3 +102,93 @@ def bundle(
 
     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)
+@with_project_definition()
+def deploy(
+    entity_id: str = typer.Option(
+        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(),
+    ),
+    validate: bool = ValidateOption,
+    **options,
+):
+    """
+    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(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+
+    ws.perform_action(
+        entity_id,
+        EntityActions.DEPLOY,
+        prune=prune,
+        recursive=recursive,
+        paths=paths,
+        validate=validate,
+    )
+    return MessageResult("Deployed successfully.")
+
+
+@ws.command(requires_connection=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
+    force: Optional[bool] = ForceOption,
+    **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,
+    )

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,19 @@ 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,
+            )
+            return entity.perform(action, action_ctx, *args, **kwargs)
         else:
             raise ValueError(f'This entity type does not support "{action.value}"')
 

snowflake/cli/api/cli_global_context.py

@@ -42,7 +42,7 @@ class _ConnectionContext:
         self._user: Optional[str] = None
         self._password: Optional[str] = None
         self._authenticator: Optional[str] = None
-        self._private_key_path: Optional[str] = None
+        self._private_key_file: Optional[str] = None
         self._warehouse: Optional[str] = None
         self._mfa_passcode: Optional[str] = None
         self._enable_diag: Optional[bool] = False
@@ -125,11 +125,11 @@ class _ConnectionContext:
         self._authenticator = value
 
     @property
-    def private_key_path(self) -> Optional[str]:
-        return self._private_key_path
+    def private_key_file(self) -> Optional[str]:
+        return self._private_key_file
 
-    def set_private_key_path(self, value: Optional[str]):
-        self._private_key_path = value
+    def set_private_key_file(self, value: Optional[str]):
+        self._private_key_file = value
 
     @property
     def warehouse(self) -> Optional[str]:
@@ -206,7 +206,7 @@ class _ConnectionContext:
             "user": self.user,
             "password": self.password,
             "authenticator": self.authenticator,
-            "private_key_path": self.private_key_path,
+            "private_key_file": self.private_key_file,
             "database": self.database,
             "schema": self.schema,
             "role": self.role,

snowflake/cli/api/commands/decorators.py

@@ -235,7 +235,7 @@ GLOBAL_CONNECTION_OPTIONS = [
         default=AuthenticatorOption,
     ),
     inspect.Parameter(
-        "private_key_path",
+        "private_key_file",
         inspect.Parameter.KEYWORD_ONLY,
         annotation=Optional[str],
         default=PrivateKeyPathOption,

snowflake/cli/api/commands/flags.py

@@ -134,11 +134,12 @@ AuthenticatorOption = typer.Option(
 
 PrivateKeyPathOption = typer.Option(
     None,
+    "--private-key-file",
     "--private-key-path",
-    help="Snowflake private key path. Overrides the value specified for the connection.",
+    help="Snowflake private key file path. Overrides the value specified for the connection.",
     hide_input=True,
     callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_private_key_path
+        lambda: get_cli_context_manager().connection_context.set_private_key_file
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -440,18 +441,43 @@ def experimental_option(
     )
 
 
+class IdentifierType(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        return FQN.from_string(value)
+
+
+class IdentifierStageType(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        return FQN.from_stage(value)
+
+
 def identifier_argument(
-    sf_object: str, example: str, callback: Callable | None = None
+    sf_object: str,
+    example: str,
+    click_type: click.ParamType = IdentifierType(),
+    callback: Callable | None = None,
 ) -> typer.Argument:
     return typer.Argument(
         ...,
         help=f"Identifier of the {sf_object}. For example: {example}",
         show_default=False,
-        click_type=IdentifierType(),
+        click_type=click_type,
         callback=callback,
     )
 
 
+def identifier_stage_argument(
+    sf_object: str, example: str, callback: Callable | None = None
+) -> typer.Argument:
+    return identifier_argument(
+        sf_object, example, click_type=IdentifierStageType(), callback=callback
+    )
+
+
 def execution_identifier_argument(sf_object: str, example: str) -> typer.Argument:
     return typer.Argument(
         ...,
@@ -506,7 +532,7 @@ def project_env_overrides_option():
     return typer.Option(
         [],
         "--env",
-        help="String in format of key=value. Overrides variables from env section used for templating.",
+        help="String in format of key=value. Overrides variables from env section used for templates.",
         callback=_callback(lambda: project_env_overrides_callback),
         show_default=False,
     )
@@ -530,10 +556,3 @@ def deprecated_flag_callback_enum(msg: str):
         return value.value
 
     return _warning_callback
-
-
-class IdentifierType(click.ParamType):
-    name = "TEXT"
-
-    def convert(self, value, param, ctx):
-        return FQN.from_string(value)

snowflake/cli/api/commands/snow_typer.py

@@ -20,6 +20,7 @@ from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 import typer
+from click import ClickException
 from snowflake.cli.api.commands.decorators import (
     global_options,
     global_options_with_connection,
@@ -33,6 +34,7 @@ from snowflake.cli.api.commands.typer_pre_execute import run_pre_execute_command
 from snowflake.cli.api.exceptions import CommandReturnTypeError
 from snowflake.cli.api.output.types import CommandResult
 from snowflake.cli.api.sanitizers import sanitize_for_terminal
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
 
 log = logging.getLogger(__name__)
 
@@ -71,6 +73,7 @@ class SnowTyper(typer.Typer):
         requires_global_options: bool = True,
         requires_connection: bool = False,
         is_enabled: Callable[[], bool] | None = None,
+        require_warehouse: bool = False,
         **kwargs,
     ):
         """
@@ -97,7 +100,7 @@ class SnowTyper(typer.Typer):
             def command_callable_decorator(*args, **kw):
                 """Wrapper around command callable. This is what happens at "runtime"."""
                 execution = ExecutionMetadata()
-                self.pre_execute(execution)
+                self.pre_execute(execution, require_warehouse=require_warehouse)
                 try:
                     result = command_callable(*args, **kw)
                     self.process_result(result)
@@ -116,7 +119,7 @@ class SnowTyper(typer.Typer):
         return custom_command
 
     @staticmethod
-    def pre_execute(execution: ExecutionMetadata):
+    def pre_execute(execution: ExecutionMetadata, require_warehouse: bool = False):
         """
         Callback executed before running any command callable (after context execution).
         Pay attention to make this method safe to use if performed operations are not necessary
@@ -127,6 +130,10 @@ class SnowTyper(typer.Typer):
         log.debug("Executing command pre execution callback")
         run_pre_execute_commands()
         log_command_usage(execution)
+        if require_warehouse and not SqlExecutionMixin().session_has_warehouse():
+            raise ClickException(
+                "The command requires warehouse. No warehouse found in current connection."
+            )
 
     @staticmethod
     def process_result(result):

snowflake/cli/api/config.py

@@ -30,7 +30,10 @@ from snowflake.cli.api.exceptions import (
     UnsupportedConfigSectionTypeError,
 )
 from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.api.secure_utils import file_permissions_are_strict
+from snowflake.cli.api.secure_utils import (
+    file_permissions_are_strict,
+    windows_get_not_whitelisted_users_with_access,
+)
 from snowflake.cli.api.utils.types import try_cast_to_bool
 from snowflake.connector.compat import IS_WINDOWS
 from snowflake.connector.config_manager import CONFIG_MANAGER
@@ -77,7 +80,7 @@ class ConnectionConfig:
     warehouse: Optional[str] = None
     role: Optional[str] = None
     authenticator: Optional[str] = None
-    private_key_path: Optional[str] = None
+    private_key_file: Optional[str] = None
     token_file_path: Optional[str] = None
 
     _other_settings: dict = field(default_factory=lambda: {})
@@ -160,6 +163,18 @@ def _read_config_file():
                 message="Bad owner or permissions.*",
                 module="snowflake.connector.config_manager",
             )
+
+            if not file_permissions_are_strict(CONFIG_MANAGER.file_path):
+                users = ", ".join(
+                    windows_get_not_whitelisted_users_with_access(
+                        CONFIG_MANAGER.file_path
+                    )
+                )
+                warnings.warn(
+                    f"Unauthorized users ({users}) have access to configuration file {CONFIG_MANAGER.file_path}.\n"
+                    f'Run `icacls "{CONFIG_MANAGER.file_path}" /deny <USER_ID>:F` on those users to restrict permissions.'
+                )
+
         try:
             CONFIG_MANAGER.read_config()
         except ConfigSourceError as exception:
@@ -322,8 +337,6 @@ def _dump_config(conf_file_cache: Dict):
 
 
 def _check_default_config_files_permissions() -> None:
-    if IS_WINDOWS:
-        return
     if CONNECTIONS_FILE.exists() and not file_permissions_are_strict(CONNECTIONS_FILE):
         raise ConfigFileTooWidePermissionsError(CONNECTIONS_FILE)
     if CONFIG_FILE.exists() and not file_permissions_are_strict(CONFIG_FILE):

snowflake/cli/api/constants.py

@@ -77,3 +77,14 @@ VALID_SCOPES = ["database", "schema", "compute-pool"]
 DEFAULT_SIZE_LIMIT_MB = 128
 
 SF_REST_API_URL_PREFIX = "/api/v2"
+
+PROJECT_TEMPLATE_VARIABLE_OPENING = "<%"
+PROJECT_TEMPLATE_VARIABLE_CLOSING = "%>"
+
+INIT_TEMPLATE_VARIABLE_OPENING = "<!"
+INIT_TEMPLATE_VARIABLE_CLOSING = "!>"
+
+SNOWPARK_SHARED_MIXIN = "snowpark_shared"
+
+DEFAULT_ENV_FILE = "environment.yml"
+DEFAULT_PAGES_DIR = "pages"