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

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "3.0.0rc2"
+VERSION = "3.0.0rc3"

snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -15,6 +15,7 @@
 from snowflake.cli._plugins.connection import plugin_spec as connection_plugin_spec
 from snowflake.cli._plugins.cortex import plugin_spec as cortex_plugin_spec
 from snowflake.cli._plugins.git import plugin_spec as git_plugin_spec
+from snowflake.cli._plugins.helpers import plugin_spec as migrate_plugin_spec
 from snowflake.cli._plugins.init import plugin_spec as init_plugin_spec
 from snowflake.cli._plugins.nativeapp import plugin_spec as nativeapp_plugin_spec
 from snowflake.cli._plugins.notebook import plugin_spec as notebook_plugin_spec
@@ -31,6 +32,7 @@ from snowflake.cli._plugins.workspace import plugin_spec as workspace_plugin_spe
 def get_builtin_plugin_name_to_plugin_spec():
     plugin_specs = {
         "connection": connection_plugin_spec,
+        "helpers": migrate_plugin_spec,
         "spcs": spcs_plugin_spec,
         "nativeapp": nativeapp_plugin_spec,
         "object": object_plugin_spec,

snowflake/cli/_app/secret.py

@@ -0,0 +1,9 @@
+class SecretType:
+    def __init__(self, value):
+        self.value = value
+
+    def __repr__(self):
+        return "SecretType(***)"
+
+    def __str___(self):
+        return "***"

snowflake/cli/_app/snow_connector.py

@@ -24,6 +24,7 @@ from click.exceptions import ClickException
 from snowflake.cli._app.constants import (
     PARAM_APPLICATION_NAME,
 )
+from snowflake.cli._app.secret import SecretType
 from snowflake.cli._app.telemetry import command_info
 from snowflake.cli.api.config import (
     get_connection_dict,
@@ -205,7 +206,7 @@ def _load_private_key(connection_parameters: Dict, private_key_var_name: str) ->
             connection_parameters[private_key_var_name]
         )
         private_key = _load_pem_to_der(private_key_pem)
-        connection_parameters["private_key"] = private_key
+        connection_parameters["private_key"] = private_key.value
         del connection_parameters[private_key_var_name]
     else:
         raise ClickException(
@@ -217,10 +218,11 @@ def _load_private_key_from_parameters(
     connection_parameters: Dict, private_key_var_name: str
 ) -> None:
     if connection_parameters.get("authenticator") == "SNOWFLAKE_JWT":
-        private_key_pem = connection_parameters[private_key_var_name]
-        private_key_pem = private_key_pem.encode("utf-8")
+        private_key_pem = _load_pem_from_parameters(
+            connection_parameters[private_key_var_name]
+        )
         private_key = _load_pem_to_der(private_key_pem)
-        connection_parameters["private_key"] = private_key
+        connection_parameters["private_key"] = private_key.value
         del connection_parameters[private_key_var_name]
     else:
         raise ClickException(
@@ -236,43 +238,49 @@ def _update_connection_application_name(connection_parameters: Dict):
     connection_parameters.update(connection_application_params)
 
 
-def _load_pem_from_file(private_key_file: str) -> bytes:
+def _load_pem_from_file(private_key_file: str) -> SecretType:
     with SecurePath(private_key_file).open(
         "rb", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
     ) as f:
-        private_key_pem = f.read()
+        private_key_pem = SecretType(f.read())
     return private_key_pem
 
 
-def _load_pem_to_der(private_key_pem: bytes) -> bytes:
+def _load_pem_from_parameters(private_key_raw: str) -> SecretType:
+    return SecretType(private_key_raw.encode("utf-8"))
+
+
+def _load_pem_to_der(private_key_pem: SecretType) -> SecretType:
     """
     Given a private key file path (in PEM format), decode key data into DER
     format
     """
-    private_key_passphrase = os.getenv("PRIVATE_KEY_PASSPHRASE", None)
+    private_key_passphrase = SecretType(os.getenv("PRIVATE_KEY_PASSPHRASE", None))
     if (
-        private_key_pem.startswith(ENCRYPTED_PKCS8_PK_HEADER)
-        and private_key_passphrase is None
+        private_key_pem.value.startswith(ENCRYPTED_PKCS8_PK_HEADER)
+        and private_key_passphrase.value is None
     ):
         raise ClickException(
             "Encrypted private key, you must provide the"
             "passphrase in the environment variable PRIVATE_KEY_PASSPHRASE"
         )
 
-    if not private_key_pem.startswith(
+    if not private_key_pem.value.startswith(
         ENCRYPTED_PKCS8_PK_HEADER
-    ) and not private_key_pem.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
+    ) and not private_key_pem.value.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
         raise ClickException(
             "Private key provided is not in PKCS#8 format. Please use correct format."
         )
 
-    if private_key_pem.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
-        private_key_passphrase = None
+    if private_key_pem.value.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
+        private_key_passphrase = SecretType(None)
 
     return prepare_private_key(private_key_pem, private_key_passphrase)
 
 
-def prepare_private_key(private_key_pem, private_key_passphrase=None):
+def prepare_private_key(
+    private_key_pem: SecretType, private_key_passphrase: SecretType = SecretType(None)
+):
     from cryptography.hazmat.backends import default_backend
     from cryptography.hazmat.primitives.serialization import (
         Encoding,
@@ -281,17 +289,21 @@ def prepare_private_key(private_key_pem, private_key_passphrase=None):
         load_pem_private_key,
     )
 
-    private_key = load_pem_private_key(
-        private_key_pem,
-        (
-            str.encode(private_key_passphrase)
-            if private_key_passphrase is not None
-            else private_key_passphrase
-        ),
-        default_backend(),
+    private_key = SecretType(
+        load_pem_private_key(
+            private_key_pem.value,
+            (
+                str.encode(private_key_passphrase.value)
+                if private_key_passphrase.value is not None
+                else private_key_passphrase.value
+            ),
+            default_backend(),
+        )
     )
-    return private_key.private_bytes(
-        encoding=Encoding.DER,
-        format=PrivateFormat.PKCS8,
-        encryption_algorithm=NoEncryption(),
+    return SecretType(
+        private_key.value.private_bytes(
+            encoding=Encoding.DER,
+            format=PrivateFormat.PKCS8,
+            encryption_algorithm=NoEncryption(),
+        )
     )

snowflake/cli/_plugins/git/manager.py

@@ -14,10 +14,11 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from textwrap import dedent
 from typing import List
 
+from click import UsageError
 from snowflake.cli._plugins.stage.manager import (
     USER_STAGE_PREFIX,
     StageManager,
@@ -27,16 +28,22 @@ from snowflake.cli._plugins.stage.manager import (
 from snowflake.cli.api.identifiers import FQN
 from snowflake.connector.cursor import SnowflakeCursor
 
+# Replace magic numbers with constants
+OMIT_FIRST = slice(1, None)
+OMIT_STAGE = slice(3, None)
+OMIT_STAGE_IN_NEW_LIST_FILES = slice(2, None)
+ONLY_STAGE = slice(3)
+
 
 class GitStagePathParts(StagePathParts):
     def __init__(self, stage_path: str):
         self.stage = GitManager.get_stage_from_path(stage_path)
-        stage_path_parts = Path(stage_path).parts
+        stage_path_parts = GitManager.split_git_path(stage_path)
         git_repo_name = stage_path_parts[0].split(".")[-1]
         if git_repo_name.startswith("@"):
-            git_repo_name = git_repo_name[1:]
+            git_repo_name = git_repo_name[OMIT_FIRST]
         self.stage_name = "/".join([git_repo_name, *stage_path_parts[1:3], ""])
-        self.directory = "/".join(stage_path_parts[3:])
+        self.directory = "/".join(stage_path_parts[OMIT_STAGE])
         self.is_directory = True if stage_path.endswith("/") else False
 
     @property
@@ -45,7 +52,12 @@ class GitStagePathParts(StagePathParts):
 
     @classmethod
     def get_directory(cls, stage_path: str) -> str:
-        return "/".join(Path(stage_path).parts[3:])
+        git_path_parts = GitManager.split_git_path(stage_path)
+        # New file list does not have a stage name at the beginning
+        if stage_path.startswith("/"):
+            return "/".join(git_path_parts[OMIT_STAGE_IN_NEW_LIST_FILES])
+        else:
+            return "/".join(git_path_parts[OMIT_STAGE])
 
     @property
     def full_path(self) -> str:
@@ -53,7 +65,7 @@ class GitStagePathParts(StagePathParts):
 
     def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
-        file_path_without_prefix = Path(file_path).parts[1:]
+        file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
     def add_stage_prefix(self, file_path: str) -> str:
@@ -95,7 +107,8 @@ class GitManager(StageManager):
         Returns stage name from potential path on stage. For example
         repo/branches/main/foo/bar -> repo/branches/main/
         """
-        return f"{'/'.join(Path(path).parts[0:3])}/"
+        path_parts = GitManager.split_git_path(path)
+        return f"{'/'.join(path_parts[ONLY_STAGE])}/"
 
     @staticmethod
     def _stage_path_part_factory(stage_path: str) -> StagePathParts:
@@ -103,3 +116,36 @@ class GitManager(StageManager):
         if stage_path.startswith(USER_STAGE_PREFIX):
             return UserStagePathParts(stage_path)
         return GitStagePathParts(stage_path)
+
+    @staticmethod
+    def split_git_path(path: str):
+        # Check if path contains quotes and split it accordingly
+        if '/"' in path and '"/' in path:
+            if path.count('"') > 2:
+                raise UsageError(
+                    f'Invalid string {path}, too much " in path, expected 2.'
+                )
+
+            path_parts = path.split('"')
+            before_quoted_part = GitManager._split_path_without_empty_parts(
+                path_parts[0]
+            )
+
+            if path_parts[2] == "/":
+                after_quoted_part = []
+            else:
+                after_quoted_part = GitManager._split_path_without_empty_parts(
+                    path_parts[2]
+                )
+
+            return [
+                *before_quoted_part,
+                f'"{path_parts[1]}"',
+                *after_quoted_part,
+            ]
+        else:
+            return GitManager._split_path_without_empty_parts(path)
+
+    @staticmethod
+    def _split_path_without_empty_parts(path: str):
+        return [e for e in PurePosixPath(path).parts if e != "/"]

snowflake/cli/_plugins/helpers/commands.py

@@ -0,0 +1,57 @@
+# 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 typer
+import yaml
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+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
+
+app = SnowTyperFactory(
+    name="helpers",
+    help="Helper commands.",
+)
+
+
+@app.command()
+def v1_to_v2(
+    accept_templates: bool = typer.Option(
+        False, "-t", "--accept-templates", help="Allows the migration of templates."
+    ),
+    **options,
+):
+    """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.")
+
+    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:
+        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.")

snowflake/cli/{api/project/schemas/snowpark/__init__.py → _plugins/helpers/plugin_spec.py}

@@ -11,3 +11,20 @@
 # 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._plugins.helpers import commands
+from snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=commands.app.create_instance(),
+    )

snowflake/cli/{api/entities → _plugins/nativeapp}/application_entity.py

@@ -5,6 +5,15 @@ from typing import Callable, List, Optional, TypedDict
 
 import typer
 from click import ClickException, UsageError
+from snowflake.cli._plugins.nativeapp.application_entity_model import (
+    ApplicationEntityModel,
+)
+from snowflake.cli._plugins.nativeapp.application_package_entity import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli._plugins.nativeapp.application_package_entity_model import (
+    ApplicationPackageEntityModel,
+)
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
     InteractiveOption,
@@ -15,9 +24,7 @@ from snowflake.cli._plugins.nativeapp.constants import (
     COMMENT_COL,
     NAME_COL,
     OWNER_COL,
-    PATCH_COL,
     SPECIAL_COMMENT,
-    VERSION_COL,
 )
 from snowflake.cli._plugins.nativeapp.exceptions import (
     ApplicationPackageDoesNotExistError,
@@ -36,13 +43,9 @@ from snowflake.cli._plugins.nativeapp.utils import (
 )
 from snowflake.cli._plugins.workspace.action_context import ActionContext
 from snowflake.cli.api.console.abc import AbstractConsole
-from snowflake.cli.api.entities.application_package_entity import (
-    ApplicationPackageEntity,
-)
 from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
 from snowflake.cli.api.entities.utils import (
     drop_generic_object,
-    ensure_correct_owner,
     execute_post_deploy_hooks,
     generic_sql_error_handler,
     print_messages,
@@ -54,22 +57,11 @@ from snowflake.cli.api.errno import (
     NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
     ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
 )
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.cli.api.project.schemas.entities.application_entity_model import (
-    ApplicationEntityModel,
-)
-from snowflake.cli.api.project.schemas.entities.application_package_entity_model import (
-    ApplicationPackageEntityModel,
-)
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.project.util import (
     extract_schema,
-    identifier_to_show_like_pattern,
-    unquote_identifier,
 )
-from snowflake.cli.api.utils.cursor import find_all_rows
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor
 
 # Reasons why an `alter application ... upgrade` might fail
 UPGRADE_RESTRICTION_CODES = {
@@ -108,9 +100,9 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         app_name = model.fqn.identifier
         debug_mode = model.debug
         if model.meta:
-            app_role = getattr(model.meta, "role", ctx.default_role)
-            app_warehouse = getattr(model.meta, "warehouse", ctx.default_warehouse)
-            post_deploy_hooks = getattr(model.meta, "post_deploy", None)
+            app_role = model.meta.role or ctx.default_role
+            app_warehouse = model.meta.warehouse or ctx.default_warehouse
+            post_deploy_hooks = model.meta.post_deploy
         else:
             app_role = ctx.default_role
             app_warehouse = ctx.default_warehouse
@@ -147,6 +139,8 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 paths=[],
                 validate=validate,
                 stage_fqn=stage_fqn,
+                interactive=interactive,
+                force=force,
             )
 
         self.deploy(
@@ -221,10 +215,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             )
             return
 
-        # 2. Check for the right owner
-        ensure_correct_owner(row=show_obj_row, role=app_role, obj_name=app_name)
-
-        # 3. Check if created by the Snowflake CLI
+        # 2. Check if created by the Snowflake CLI
         row_comment = show_obj_row[COMMENT_COL]
         if row_comment not in ALLOWED_SPECIAL_COMMENTS and needs_confirmation(
             needs_confirm, auto_yes
@@ -251,7 +242,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 # leave behind an orphan app when we get to dropping the package
                 raise typer.Abort()
 
-        # 4. Check for application objects owned by the application
+        # 3. Check for application objects owned by the application
         # This query will fail if the application package has already been dropped, so handle this case gracefully
         has_objects_to_drop = False
         message_prefix = ""
@@ -329,7 +320,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             # If there's nothing to drop, set cascade to an explicit False value
             cascade = False
 
-        # 5. All validations have passed, drop object
+        # 4. All validations have passed, drop object
         drop_generic_object(
             console=console,
             object_type="application",
@@ -425,7 +416,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         # versioned dev
         if version:
             try:
-                version_exists = cls.get_existing_version_info(
+                version_exists = ApplicationPackageEntity.get_existing_version_info(
                     version=version,
                     package_name=package_name,
                     package_role=package_role,
@@ -658,40 +649,3 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             return sql_executor.show_specific_object(
                 "applications", app_name, name_col=NAME_COL
             )
-
-    @staticmethod
-    def get_existing_version_info(
-        version: str,
-        package_name: str,
-        package_role: str,
-    ) -> Optional[dict]:
-        """
-        Get the latest patch on an existing version by name in the application package.
-        Executes 'show versions like ... in application package' query and returns
-        the latest patch in the version as a single row, if one exists. Otherwise,
-        returns None.
-        """
-        sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
-            try:
-                query = f"show versions like {identifier_to_show_like_pattern(version)} in application package {package_name}"
-                cursor = sql_executor.execute_query(query, cursor_class=DictCursor)
-
-                if cursor.rowcount is None:
-                    raise SnowflakeSQLExecutionError(query)
-
-                matching_rows = find_all_rows(
-                    cursor, lambda row: row[VERSION_COL] == unquote_identifier(version)
-                )
-
-                if not matching_rows:
-                    return None
-
-                return max(matching_rows, key=lambda row: row[PATCH_COL])
-
-            except ProgrammingError as err:
-                if err.msg.__contains__("does not exist or not authorized"):
-                    raise ApplicationPackageDoesNotExistError(package_name)
-                else:
-                    generic_sql_error_handler(err=err, role=package_role)
-                    return None

snowflake/cli/{api/project/schemas/entities → _plugins/nativeapp}/application_entity_model.py

@@ -17,14 +17,14 @@ from __future__ import annotations
 from typing import Literal, Optional
 
 from pydantic import Field, field_validator
-from snowflake.cli.api.project.schemas.entities.application_package_entity_model import (
+from snowflake.cli._plugins.nativeapp.application_package_entity_model import (
     ApplicationPackageEntityModel,
 )
 from snowflake.cli.api.project.schemas.entities.common import (
     EntityModelBase,
+    Identifier,
     TargetField,
 )
-from snowflake.cli.api.project.schemas.identifier_model import Identifier
 from snowflake.cli.api.project.schemas.updatable_model import (
     DiscriminatorField,
 )