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

snowflake/cli/_plugins/workspace/commands.py

@@ -0,0 +1,194 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from textwrap import dedent
+from typing import List, Optional
+
+import typer
+import yaml
+from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
+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
+
+ws = SnowTyper(
+    name="ws",
+    help="Deploy and interact with snowflake.yml-based entities.",
+)
+log = logging.getLogger(__name__)
+
+
+@ws.command()
+def migrate(
+    accept_templates: bool = typer.Option(
+        False, "-t", "--accept-templates", help="Allows the migration of templates."
+    ),
+    **options,
+):
+    """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.")
+
+    pd_v2 = convert_project_definition_to_v2(pd, accept_templates)
+
+    SecurePath("snowflake.yml").rename("snowflake_V1.yml")
+    with open("snowflake.yml", "w") as file:
+        yaml.dump(
+            pd_v2.model_dump(
+                exclude_unset=True, exclude_none=True, mode="json", by_alias=True
+            ),
+            file,
+        )
+    return MessageResult("Project definition migrated to version 2.")
+
+
+@ws.command(requires_connection=True, hidden=True)
+@with_project_definition()
+def validate(
+    **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.")
+
+
+@ws.command(requires_connection=True, hidden=True)
+@with_project_definition()
+def bundle(
+    entity_id: str = typer.Option(
+        help=f"""The ID of the entity you want to bundle.""",
+    ),
+    **options,
+):
+    """
+    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)
+@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

@@ -0,0 +1,73 @@
+from pathlib import Path
+from typing import Dict
+
+from snowflake.cli._plugins.workspace.action_context import ActionContext
+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,
+)
+from snowflake.cli.api.project.schemas.project_definition import (
+    DefinitionV20,
+    ProjectDefinition,
+)
+from snowflake.cli.api.project.util import to_identifier
+
+
+class WorkspaceManager:
+    """
+    Instantiates entity instances from entity models, providing higher-order functionality on entity compositions.
+    """
+
+    def __init__(self, project_definition: ProjectDefinition, project_root: Path):
+        if not project_definition.meets_version_requirement("2"):
+            raise InvalidProjectDefinitionVersionError(
+                "2.x", project_definition.definition_version
+            )
+        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):
+        """
+        Returns an entity instance with the given ID. If exists, reuses the previously returned instance, or instantiates a new one otherwise.
+        """
+        if entity_id in self._entities_cache:
+            return self._entities_cache[entity_id]
+        entity_model = self._project_definition.entities.get(entity_id, None)
+        if entity_model is None:
+            raise ValueError(f"No such entity ID: {entity_id}")
+        entity_model_cls = entity_model.__class__
+        entity_cls = v2_entity_model_to_entity_map[entity_model_cls]
+        self._entities_cache[entity_id] = entity_cls(entity_model)
+        return self._entities_cache[entity_id]
+
+    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(
+                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}"')
+
+    def project_root(self) -> Path:
+        return self._project_root

snowflake/cli/{plugins → _plugins}/workspace/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.workspace import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.workspace import commands
 
 
 @plugin_hook_impl

snowflake/cli/api/cli_global_context.py

@@ -15,13 +15,17 @@
 from __future__ import annotations
 
 import re
+import warnings
 from pathlib import Path
-from typing import Callable, Optional
+from typing import TYPE_CHECKING, Callable, Optional
 
 from snowflake.cli.api.exceptions import InvalidSchemaError
 from snowflake.cli.api.output.formats import OutputFormat
-from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
 from snowflake.connector import SnowflakeConnection
+from snowflake.connector.compat import IS_WINDOWS
+
+if TYPE_CHECKING:
+    from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
 
 schema_pattern = re.compile(r".+\..+")
 
@@ -38,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
@@ -121,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]:
@@ -202,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,
@@ -213,7 +217,16 @@ class _ConnectionContext:
         }
 
     def _build_connection(self):
-        from snowflake.cli.app.snow_connector import connect_to_snowflake
+        from snowflake.cli._app.snow_connector import connect_to_snowflake
+
+        # Ignore warnings about bad owner or permissions on Windows
+        # Telemetry omit our warning filter from config.py
+        if IS_WINDOWS:
+            warnings.filterwarnings(
+                action="ignore",
+                message="Bad owner or permissions.*",
+                module="snowflake.connector.config_manager",
+            )
 
         return connect_to_snowflake(
             temporary_connection=self.temporary_connection,
@@ -367,8 +380,8 @@ class _CliGlobalContextAccess:
         return self._manager.project_definition
 
     @property
-    def project_root(self):
-        return self._manager.project_root
+    def project_root(self) -> Path:
+        return Path(self._manager.project_root)
 
     @property
     def template_context(self) -> dict:
@@ -386,5 +399,19 @@ class _CliGlobalContextAccess:
         return self._manager.output_format == OutputFormat.JSON
 
 
-cli_context_manager: _CliGlobalContextManager = _CliGlobalContextManager()
-cli_context: _CliGlobalContextAccess = _CliGlobalContextAccess(cli_context_manager)
+_CLI_CONTEXT_MANAGER: _CliGlobalContextManager | None = None
+_CLI_CONTEXT: _CliGlobalContextAccess | None = None
+
+
+def get_cli_context_manager() -> _CliGlobalContextManager:
+    global _CLI_CONTEXT_MANAGER
+    if _CLI_CONTEXT_MANAGER is None:
+        _CLI_CONTEXT_MANAGER = _CliGlobalContextManager()
+    return _CLI_CONTEXT_MANAGER
+
+
+def get_cli_context() -> _CliGlobalContextAccess:
+    global _CLI_CONTEXT
+    if _CLI_CONTEXT is None:
+        _CLI_CONTEXT = _CliGlobalContextAccess(get_cli_context_manager())
+    return _CLI_CONTEXT

snowflake/cli/api/commands/common.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class OnErrorType(Enum):
+    """
+    Command option values for what to do when an error occurs.
+    """
+
+    BREAK = "break"
+    CONTINUE = "continue"
+
+
+@dataclass
+class Variable:
+    """
+    Key-value pair dataclass, returned after parsing "key=value" command options.
+    """
+
+    key: str
+    value: str
+
+    def __init__(self, key: str, value: str):
+        self.key = key
+        self.value = value

snowflake/cli/api/commands/decorators.py

@@ -19,7 +19,7 @@ from functools import wraps
 from inspect import Signature
 from typing import Callable, Dict, List, Optional, get_type_hints
 
-from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.flags import (
     AccountOption,
     AuthenticatorOption,
@@ -125,8 +125,9 @@ def with_experimental_behaviour(
 
 
 def _execute_before_command_using_global_options(**options):
-    from snowflake.cli.app.loggers import create_loggers
+    from snowflake.cli._app.loggers import create_loggers
 
+    cli_context = get_cli_context()
     create_loggers(cli_context.verbose, cli_context.enable_tracebacks)
 
 
@@ -234,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,
@@ -342,7 +343,7 @@ GLOBAL_OPTIONS = [
 
 
 def with_output(func):
-    from snowflake.cli.app.printing import print_result
+    from snowflake.cli._app.printing import print_result
 
     @wraps(func)
     def wrapper(*args, **kwargs):

snowflake/cli/api/commands/experimental_behaviour.py

@@ -11,9 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
-from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.cli_global_context import get_cli_context
 
 
 def experimental_behaviour_enabled() -> bool:
-    return cli_context.experimental
+    return get_cli_context().experimental