snowflake-cli-labs 2.8.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

snowflake/cli/plugins/nativeapp/v2_conversions/v2_to_v1_decorator.py

@@ -1,135 +0,0 @@
-# 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
-
-from functools import wraps
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-from click import ClickException
-from snowflake.cli.api.cli_global_context import cli_context, cli_context_manager
-from snowflake.cli.api.project.schemas.entities.application_entity import (
-    ApplicationEntity,
-)
-from snowflake.cli.api.project.schemas.entities.application_package_entity import (
-    ApplicationPackageEntity,
-)
-from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
-from snowflake.cli.api.project.schemas.project_definition import (
-    DefinitionV11,
-    DefinitionV20,
-)
-from snowflake.cli.api.utils.definition_rendering import render_definition_template
-
-
-def _convert_v2_artifact_to_v1_dict(
-    v2_artifact: Union[PathMapping, Path]
-) -> Union[Dict, str]:
-    if isinstance(v2_artifact, PathMapping):
-        return {
-            "src": v2_artifact.src,
-            "dest": v2_artifact.dest,
-            "processors": v2_artifact.processors,
-        }
-    return str(v2_artifact)
-
-
-def _pdf_v2_to_v1(v2_definition: DefinitionV20) -> DefinitionV11:
-    pdfv1: Dict[str, Any] = {"definition_version": "1.1", "native_app": {}}
-
-    app_package_definition: ApplicationPackageEntity = None
-    app_definition: Optional[ApplicationEntity] = None
-
-    for key, entity in v2_definition.entities.items():
-        if entity.get_type() == ApplicationPackageEntity.get_type():
-            if app_package_definition:
-                raise ClickException(
-                    "More than one application package entity exists in the project definition file."
-                )
-            app_package_definition = entity
-        elif entity.get_type() == ApplicationEntity.get_type():
-            if app_definition:
-                raise ClickException(
-                    "More than one application entity exists in the project definition file."
-                )
-            app_definition = entity
-    if not app_package_definition:
-        raise ClickException(
-            "Could not find an application package entity in the project definition file."
-        )
-
-    # NativeApp
-    if app_definition and app_definition.name:
-        pdfv1["native_app"]["name"] = app_definition.name
-    else:
-        pdfv1["native_app"]["name"] = app_package_definition.name.split("_pkg_")[0]
-    pdfv1["native_app"]["artifacts"] = [
-        _convert_v2_artifact_to_v1_dict(a) for a in app_package_definition.artifacts
-    ]
-    pdfv1["native_app"]["source_stage"] = app_package_definition.stage
-    pdfv1["native_app"]["bundle_root"] = str(app_package_definition.bundle_root)
-    pdfv1["native_app"]["generated_root"] = str(app_package_definition.generated_root)
-    pdfv1["native_app"]["deploy_root"] = str(app_package_definition.deploy_root)
-
-    # Package
-    pdfv1["native_app"]["package"] = {}
-    pdfv1["native_app"]["package"]["name"] = app_package_definition.name
-    if app_package_definition.distribution:
-        pdfv1["native_app"]["package"][
-            "distribution"
-        ] = app_package_definition.distribution
-    if app_package_definition.meta and app_package_definition.meta.post_deploy:
-        pdfv1["native_app"]["package"][
-            "post_deploy"
-        ] = app_package_definition.meta.post_deploy
-
-    # Application
-    if app_definition:
-        pdfv1["native_app"]["application"] = {}
-        pdfv1["native_app"]["application"]["name"] = app_definition.name
-        if app_definition.meta and app_definition.meta.role:
-            pdfv1["native_app"]["application"]["role"] = app_definition.meta.role
-        if app_definition.meta and app_definition.meta.post_deploy:
-            pdfv1["native_app"]["application"][
-                "post_deploy"
-            ] = app_definition.meta.post_deploy
-
-    result = render_definition_template(pdfv1, {})
-    # Override the definition object in global context
-    return result.project_definition
-
-
-def nativeapp_definition_v2_to_v1(func):
-    """
-    A command decorator that attempts to automatically convert a native app project from
-    definition v2 to v1.1. Assumes with_project_definition() has already been called.
-    The definition object in CliGlobalContext will be replaced with the converted object.
-    Exactly one application package entity type is expected, and up to one application
-    entity type is expected.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        original_pdf: DefinitionV20 = cli_context.project_definition
-        if not original_pdf:
-            raise ValueError(
-                "Project definition could not be found. The nativeapp_definition_v2_to_v1 command decorator assumes with_project_definition() was called before it."
-            )
-        if original_pdf.definition_version == "2":
-            pdfv1 = _pdf_v2_to_v1(original_pdf)
-            cli_context_manager.set_project_definition(pdfv1)
-        return func(*args, **kwargs)
-
-    return wrapper

snowflake/cli/plugins/nativeapp/version/version_processor.py

@@ -1,362 +0,0 @@
-# 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
-
-from pathlib import Path
-from textwrap import dedent
-from typing import Dict, List, Optional
-
-import typer
-from click import BadOptionUsage, ClickException
-from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
-from snowflake.cli.api.project.util import unquote_identifier
-from snowflake.cli.api.utils.cursor import (
-    find_all_rows,
-    find_first_row,
-)
-from snowflake.cli.plugins.nativeapp.artifacts import (
-    BundleMap,
-    find_version_info_in_manifest_file,
-)
-from snowflake.cli.plugins.nativeapp.constants import VERSION_COL
-from snowflake.cli.plugins.nativeapp.exceptions import (
-    ApplicationPackageAlreadyExistsError,
-    ApplicationPackageDoesNotExistError,
-)
-from snowflake.cli.plugins.nativeapp.manager import (
-    NativeAppCommandProcessor,
-    NativeAppManager,
-    ensure_correct_owner,
-)
-from snowflake.cli.plugins.nativeapp.policy import PolicyBase
-from snowflake.cli.plugins.nativeapp.run_processor import NativeAppRunProcessor
-from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor
-
-
-def check_index_changes_in_git_repo(
-    project_root: Path, policy: PolicyBase, is_interactive: bool
-) -> None:
-    """
-    Checks if the project root, i.e. the native apps project is a git repository. If it is a git repository,
-    it also checks if there any local changes to the directory that may not be on the application package stage.
-    """
-    from git import Repo
-    from git.exc import InvalidGitRepositoryError
-
-    try:
-        repo = Repo(project_root, search_parent_directories=True)
-        assert repo.git_dir is not None
-
-        # Check if the repo has any changes, including untracked files
-        if repo.is_dirty(untracked_files=True):
-            cc.warning(
-                "Changes detected in the git repository. "
-                "(Rerun your command with --skip-git-check flag to ignore this check)"
-            )
-            repo.git.execute(["git", "status"])
-
-            user_prompt = (
-                "You have local changes in this repository that are not part of a previous commit. "
-                "Do you still want to continue?"
-            )
-            if not policy.should_proceed(user_prompt):
-                if is_interactive:
-                    cc.message("Not creating a new version.")
-                    raise typer.Exit(0)
-                else:
-                    cc.message(
-                        "Cannot create a new version non-interactively without --force."
-                    )
-                    raise typer.Exit(1)
-
-    except InvalidGitRepositoryError:
-        pass  # not a git repository, which is acceptable
-
-
-class NativeAppVersionCreateProcessor(NativeAppRunProcessor):
-    def __init__(self, project_definition: Dict, project_root: Path):
-        super().__init__(project_definition, project_root)
-
-    def get_existing_release_directive_info_for_version(
-        self, version: str
-    ) -> List[dict]:
-        """
-        Get all existing release directives, if present, set on the version defined in an application package.
-        It executes a 'show release directives in application package' query and returns the filtered results, if they exist.
-        """
-        with self.use_role(self.package_role):
-            show_obj_query = (
-                f"show release directives in application package {self.package_name}"
-            )
-            show_obj_cursor = self._execute_query(
-                show_obj_query, cursor_class=DictCursor
-            )
-
-            if show_obj_cursor.rowcount is None:
-                raise SnowflakeSQLExecutionError(show_obj_query)
-
-            show_obj_rows = find_all_rows(
-                show_obj_cursor,
-                lambda row: row[VERSION_COL] == unquote_identifier(version),
-            )
-
-            return show_obj_rows
-
-    def add_new_version(self, version: str) -> None:
-        """
-        Defines a new version in an existing application package.
-        """
-        with self.use_role(self.package_role):
-            cc.step(
-                f"Defining a new version {version} in application package {self.package_name}"
-            )
-            add_version_query = dedent(
-                f"""\
-                    alter application package {self.package_name}
-                        add version {version}
-                        using @{self.stage_fqn}
-                """
-            )
-            self._execute_query(add_version_query, cursor_class=DictCursor)
-            cc.message(
-                f"Version {version} created for application package {self.package_name}."
-            )
-
-    def add_new_patch_to_version(self, version: str, patch: Optional[int] = None):
-        """
-        Add a new patch, optionally a custom one, to an existing version in an application package.
-        """
-        with self.use_role(self.package_role):
-            cc.step(
-                f"Adding new patch to version {version} defined in application package {self.package_name}"
-            )
-            add_version_query = dedent(
-                f"""\
-                    alter application package {self.package_name}
-                        add patch {patch if patch else ""} for version {version}
-                        using @{self.stage_fqn}
-                """
-            )
-            result_cursor = self._execute_query(
-                add_version_query, cursor_class=DictCursor
-            )
-
-            show_row = find_first_row(
-                result_cursor,
-                lambda row: row[VERSION_COL] == unquote_identifier(version),
-            )
-
-            new_patch = show_row["patch"]
-            cc.message(
-                f"Patch {new_patch} created for version {version} defined in application package {self.package_name}."
-            )
-
-    def process(
-        self,
-        bundle_map: BundleMap,
-        version: Optional[str],
-        patch: Optional[int],
-        policy: PolicyBase,
-        git_policy: PolicyBase,
-        is_interactive: bool,
-        *args,
-        **kwargs,
-    ):
-        """
-        Perform bundle, application package creation, stage upload, version and/or patch to an application package.
-        """
-
-        # Make sure version is not None before proceeding any further.
-        # This will raise an exception if version information is not found. Patch can be None.
-        if not version:
-            cc.message(
-                "Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead."
-            )
-
-            version, patch = find_version_info_in_manifest_file(self.deploy_root)
-            if not version:
-                raise ClickException(
-                    "Manifest.yml file does not contain a value for the version field."
-                )
-
-        # Check if --patch needs to throw a bad option error, either if application package does not exist or if version does not exist
-        if patch:
-            try:
-                if not self.get_existing_version_info(version):
-                    raise BadOptionUsage(
-                        option_name="patch",
-                        message=f"Cannot create a custom patch when version {version} is not defined in the application package {self.package_name}. Try again without using --patch.",
-                    )
-            except ApplicationPackageDoesNotExistError as app_err:
-                raise BadOptionUsage(
-                    option_name="patch",
-                    message=f"Cannot create a custom patch when application package {self.package_name} does not exist. Try again without using --patch.",
-                )
-
-        if git_policy.should_proceed():
-            check_index_changes_in_git_repo(
-                project_root=self.project_root,
-                policy=policy,
-                is_interactive=is_interactive,
-            )
-
-        # TODO: consider using self.deploy() instead
-
-        try:
-            self.create_app_package()
-        except ApplicationPackageAlreadyExistsError as e:
-            cc.warning(e.message)
-            if not policy.should_proceed("Proceed with using this package?"):
-                raise typer.Abort() from e
-
-        with self.use_role(self.package_role):
-            # Now that the application package exists, create shared data
-            self._apply_package_scripts()
-
-            # Upload files from deploy root local folder to the above stage
-            self.sync_deploy_root_with_stage(
-                bundle_map=bundle_map,
-                role=self.package_role,
-                prune=True,
-                recursive=True,
-                stage_fqn=self.stage_fqn,
-            )
-            with self.use_package_warehouse():
-                self.execute_package_post_deploy_hooks()
-
-        # Warn if the version exists in a release directive(s)
-        existing_release_directives = (
-            self.get_existing_release_directive_info_for_version(version)
-        )
-        if existing_release_directives:
-            release_directive_names = ", ".join(
-                row["name"] for row in existing_release_directives
-            )
-            cc.warning(
-                dedent(
-                    f"""\
-                    Version {version} already defined in application package {self.package_name} and in release directive(s): {release_directive_names}.
-                    """
-                )
-            )
-
-            user_prompt = (
-                f"Are you sure you want to create a new patch for version {version} in application "
-                f"package {self.package_name}? Once added, this operation cannot be undone."
-            )
-            if not policy.should_proceed(user_prompt):
-                if is_interactive:
-                    cc.message("Not creating a new patch.")
-                    raise typer.Exit(0)
-                else:
-                    cc.message(
-                        "Cannot create a new patch non-interactively without --force."
-                    )
-                    raise typer.Exit(1)
-
-        # Define a new version in the application package
-        if not self.get_existing_version_info(version):
-            self.add_new_version(version=version)
-            return  # A new version created automatically has patch 0, we do not need to further increment the patch.
-
-        # Add a new patch to an existing (old) version
-        self.add_new_patch_to_version(version=version, patch=patch)
-
-
-class NativeAppVersionDropProcessor(NativeAppManager, NativeAppCommandProcessor):
-    def __init__(self, project_definition: NativeApp, project_root: Path):
-        super().__init__(project_definition, project_root)
-
-    def process(
-        self,
-        version: Optional[str],
-        policy: PolicyBase,
-        is_interactive: bool,
-        *args,
-        **kwargs,
-    ):
-        """
-        Drops a version defined in an application package. If --force is provided, then no user prompts will be executed.
-        """
-
-        # 1. Check for existing an existing application package
-        show_obj_row = self.get_existing_app_pkg_info()
-        if show_obj_row:
-            # Check for the right owner role
-            ensure_correct_owner(
-                row=show_obj_row, role=self.package_role, obj_name=self.package_name
-            )
-        else:
-            raise ApplicationPackageDoesNotExistError(self.package_name)
-
-        # 2. Check distribution of the existing application package
-        actual_distribution = self.get_app_pkg_distribution_in_snowflake
-        if not self.verify_project_distribution(actual_distribution):
-            cc.warning(
-                f"Continuing to execute `snow app version drop` on application package {self.package_name} with distribution '{actual_distribution}'."
-            )
-
-        # 3. If the user did not pass in a version string, determine from manifest.yml
-        if not version:
-            cc.message(
-                dedent(
-                    f"""\
-                        Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead.
-                        This step will bundle your app artifacts to determine the location of the manifest.yml file.
-                    """
-                )
-            )
-            self.build_bundle()
-            version, _ = find_version_info_in_manifest_file(self.deploy_root)
-            if not version:
-                raise ClickException(
-                    "Manifest.yml file does not contain a value for the version field."
-                )
-
-        cc.step(
-            dedent(
-                f"""\
-                    About to drop version {version} in application package {self.package_name}.
-                """
-            )
-        )
-
-        # If user did not provide --force, ask for confirmation
-        user_prompt = (
-            f"Are you sure you want to drop version {version} in application package {self.package_name}? Once dropped, this operation cannot be undone.",
-        )
-        if not policy.should_proceed(user_prompt):
-            if is_interactive:
-                cc.message("Not dropping version.")
-                raise typer.Exit(0)
-            else:
-                cc.message("Cannot drop version non-interactively without --force.")
-                raise typer.Exit(1)
-
-        # Drop the version
-        with self.use_role(self.package_role):
-            try:
-                self._execute_query(
-                    f"alter application package {self.package_name} drop version {version}"
-                )
-            except ProgrammingError as err:
-                raise err  # e.g. version is referenced in a release directive(s)
-
-        cc.message(
-            f"Version {version} in application package {self.package_name} dropped successfully."
-        )

snowflake/cli/plugins/object_stage_deprecated/__init__.py

@@ -1,15 +0,0 @@
-# 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.
-
-# TODO 3.0: remove this file

snowflake/cli/plugins/object_stage_deprecated/commands.py

@@ -1,122 +0,0 @@
-# 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.
-
-# TODO 3.0: remove these commands
-
-from __future__ import annotations
-
-import typer
-from snowflake.cli.api.commands.flags import (
-    PatternOption,
-)
-from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.plugins.command import CommandPath
-from snowflake.cli.plugins.stage.commands import (
-    StageNameArgument,
-    copy,
-    stage_create,
-    stage_diff,
-    stage_list_files,
-    stage_remove,
-)
-
-_deprecated_command_msg = (
-    f"`{CommandPath(['object', 'stage'])}` command group is deprecated."
-    f" Please use `{CommandPath(['stage'])}` instead."
-)
-
-app = SnowTyperFactory(name="stage", help="Manages stages.", deprecated=True)
-
-
-@app.callback()
-def warn_command_deprecated() -> None:
-    cli_console.warning(_deprecated_command_msg)
-
-
-@app.command("list", requires_connection=True, deprecated=True)
-def deprecated_stage_list(
-    stage_name: str = StageNameArgument, pattern=PatternOption, **options
-):
-    """
-    Lists the stage contents.
-    """
-    return stage_list_files(stage_name=stage_name, pattern=pattern, **options)
-
-
-@app.command("copy", requires_connection=True, deprecated=True)
-def deprecated_copy(
-    source_path: str = typer.Argument(
-        help="Source path for copy operation. Can be either stage path or local."
-    ),
-    destination_path: str = typer.Argument(
-        help="Target directory path for copy operation. Should be stage if source is local or local if source is stage.",
-    ),
-    overwrite: bool = typer.Option(
-        False,
-        help="Overwrites existing files in the target path.",
-    ),
-    parallel: int = typer.Option(
-        4,
-        help="Number of parallel threads to use when uploading files.",
-    ),
-    recursive: bool = typer.Option(
-        False,
-        help="Copy files recursively with directory structure.",
-    ),
-    **options,
-):
-    """
-    Copies all files from target path to target directory. This works for both uploading
-    to and downloading files from the stage.
-    """
-    copy(
-        source_path=source_path,
-        destination_path=destination_path,
-        overwrite=overwrite,
-        parallel=parallel,
-        recursive=recursive,
-    )
-
-
-@app.command("create", requires_connection=True, deprecated=True)
-def deprecated_stage_create(stage_name: str = StageNameArgument, **options):
-    """
-    Creates a named stage if it does not already exist.
-    """
-    stage_create(stage_name=stage_name, **options)
-
-
-@app.command("remove", requires_connection=True, deprecated=True)
-def deprecated_stage_remove(
-    stage_name: str = StageNameArgument,
-    file_name: str = typer.Argument(..., help="Name of the file to remove."),
-    **options,
-):
-    """
-    Removes a file from a stage.
-    """
-    stage_remove(stage_name=stage_name, file_name=file_name)
-
-
-@app.command("diff", hidden=True, requires_connection=True, deprecated=True)
-def deprecated_stage_diff(
-    stage_name: str = typer.Argument(None, help="Fully qualified name of a stage"),
-    folder_name: str = typer.Argument(None, help="Path to local folder"),
-    **options,
-):
-    """
-    Diffs a stage with a local folder.
-    """
-    return stage_diff(stage_name=stage_name, folder_name=folder_name, **options)

snowflake/cli/plugins/object_stage_deprecated/plugin_spec.py

@@ -1,32 +0,0 @@
-# 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.
-
-# TODO 3.0: remove this file
-
-from snowflake.cli.api.plugins.command import (
-    CommandPath,
-    CommandSpec,
-    CommandType,
-    plugin_hook_impl,
-)
-from snowflake.cli.plugins.object_stage_deprecated import commands
-
-
-@plugin_hook_impl
-def command_spec():
-    return CommandSpec(
-        parent_command_path=CommandPath(["object"]),
-        command_type=CommandType.COMMAND_GROUP,
-        typer_instance=commands.app.create_instance(),
-    )