snowflake-cli-labs 3.0.0rc4__py3-none-any.whl → 3.0.1__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/project_model.py

@@ -1,211 +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 cached_property
-from pathlib import Path
-from typing import List, Optional
-
-from snowflake.cli._plugins.nativeapp.artifacts import resolve_without_follow
-from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
-from snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.entities.common import get_sql_executor
-from snowflake.cli.api.project.definition import (
-    default_app_package,
-    default_application,
-    default_role,
-)
-from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
-from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
-from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
-from snowflake.cli.api.project.util import (
-    append_test_resource_suffix,
-    extract_schema,
-    to_identifier,
-)
-
-
-class NativeAppProjectModel:
-    """
-    Exposes properties of a native app project defined in a Snowflake Project Definition file. Whenever
-    appropriate, APIs defined in this class provide suitable defaults or fallback logic to access properties
-    of the project.
-    """
-
-    def __init__(
-        self,
-        project_definition: NativeApp,
-        project_root: Path,
-    ):
-        self._project_definition = project_definition
-        self._project_root = resolve_without_follow(project_root)
-
-    @property
-    def project_root(self) -> Path:
-        return self._project_root
-
-    @property
-    def definition(self) -> NativeApp:
-        return self._project_definition
-
-    @cached_property
-    def artifacts(self) -> List[PathMapping]:
-        return self.definition.artifacts
-
-    @cached_property
-    def bundle_root(self) -> Path:
-        return self.project_root / self.definition.bundle_root
-
-    @cached_property
-    def deploy_root(self) -> Path:
-        return self.project_root / self.definition.deploy_root
-
-    @cached_property
-    def generated_root(self) -> Path:
-        return self.deploy_root / self.definition.generated_root
-
-    @cached_property
-    def package_scripts(self) -> List[str]:
-        """
-        Relative paths to package scripts from the project root.
-        """
-        if self.definition.package and self.definition.package.scripts:
-            return self.definition.package.scripts
-        else:
-            return []
-
-    @cached_property
-    def stage_fqn(self) -> str:
-        return f"{self.package_name}.{self.definition.source_stage}"
-
-    @cached_property
-    def scratch_stage_fqn(self) -> str:
-        return f"{self.package_name}.{self.definition.scratch_stage}"
-
-    @cached_property
-    def stage_schema(self) -> Optional[str]:
-        return extract_schema(self.stage_fqn)
-
-    @cached_property
-    def package_warehouse(self) -> Optional[str]:
-        if self.definition.package and self.definition.package.warehouse:
-            return to_identifier(self.definition.package.warehouse)
-        else:
-            cli_context = get_cli_context()
-            if cli_context.connection.warehouse:
-                return to_identifier(cli_context.connection.warehouse)
-            return None
-
-    @cached_property
-    def application_warehouse(self) -> Optional[str]:
-        if self.definition.application and self.definition.application.warehouse:
-            return to_identifier(self.definition.application.warehouse)
-        else:
-            cli_context = get_cli_context()
-            if cli_context.connection.warehouse:
-                return to_identifier(cli_context.connection.warehouse)
-            return None
-
-    @cached_property
-    def project_identifier(self) -> str:
-        # name is expected to be a valid Snowflake identifier, but YAML parsers will
-        # sometimes strip out double quotes, so we try to get them back here.
-        return to_identifier(self.definition.name)
-
-    @property
-    def package_name(self) -> str:
-        if self.definition.package and self.definition.package.name:
-            return to_identifier(self.definition.package.name)
-        else:
-            # V1.0 PDF doesn't support templating, so if the identifier isn't
-            # explicitly specified, the default is generated here,
-            # so we have to append the test resource suffix here
-            name = default_app_package(self.project_identifier)
-            return to_identifier(append_test_resource_suffix(name))
-
-    @cached_property
-    def package_role(self) -> str:
-        if self.definition.package and self.definition.package.role:
-            return self.definition.package.role
-        else:
-            return self._default_role
-
-    @cached_property
-    def package_distribution(self) -> str:
-        if self.definition.package and self.definition.package.distribution:
-            return self.definition.package.distribution.lower()
-        else:
-            return "internal"
-
-    @property
-    def app_name(self) -> str:
-        if self.definition.application and self.definition.application.name:
-            return to_identifier(self.definition.application.name)
-        else:
-            # V1.0 PDF doesn't support templating, so if the identifier isn't
-            # explicitly specified, the default is generated here,
-            # so we have to append the test resource suffix here
-            name = default_application(self.project_identifier)
-            return to_identifier(append_test_resource_suffix(name))
-
-    @cached_property
-    def app_role(self) -> str:
-        if self.definition.application and self.definition.application.role:
-            return self.definition.application.role
-        else:
-            return self._default_role
-
-    @cached_property
-    def app_post_deploy_hooks(self) -> Optional[List[PostDeployHook]]:
-        """
-        List of application instance post deploy hooks.
-        """
-        if self.definition.application and self.definition.application.post_deploy:
-            return self.definition.application.post_deploy
-        else:
-            return None
-
-    @cached_property
-    def package_post_deploy_hooks(self) -> Optional[List[PostDeployHook]]:
-        """
-        List of application package post deploy hooks.
-        """
-        if self.definition.package and self.definition.package.post_deploy:
-            return self.definition.package.post_deploy
-        else:
-            return None
-
-    @cached_property
-    def _default_role(self) -> str:
-        role = default_role()
-        if role is None:
-            role = get_sql_executor().current_role()
-        return role
-
-    @cached_property
-    def debug_mode(self) -> Optional[bool]:
-        if self.definition.application:
-            return self.definition.application.debug
-        return None
-
-    def get_bundle_context(self) -> BundleContext:
-        return BundleContext(
-            package_name=self.package_name,
-            artifacts=self.artifacts,
-            project_root=self.project_root,
-            bundle_root=self.bundle_root,
-            deploy_root=self.deploy_root,
-            generated_root=self.generated_root,
-        )

snowflake/cli/_plugins/nativeapp/run_processor.py

@@ -1,184 +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 typing import Optional
-
-import typer
-from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
-from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntity
-from snowflake.cli._plugins.nativeapp.entities.application_package import (
-    ApplicationPackageEntity,
-)
-from snowflake.cli._plugins.nativeapp.manager import (
-    NativeAppCommandProcessor,
-    NativeAppManager,
-)
-from snowflake.cli._plugins.nativeapp.policy import PolicyBase
-from snowflake.cli._plugins.nativeapp.same_account_install_method import (
-    SameAccountInstallMethod,
-)
-from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.entities.common import get_sql_executor
-from snowflake.cli.api.entities.utils import (
-    generic_sql_error_handler,
-)
-from snowflake.cli.api.errno import (
-    APPLICATION_NO_LONGER_AVAILABLE,
-    APPLICATION_OWNS_EXTERNAL_OBJECTS,
-)
-from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
-from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import SnowflakeCursor
-
-
-class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
-    def __init__(self, project_definition: NativeApp, project_root: Path):
-        super().__init__(project_definition, project_root)
-
-    def get_all_existing_versions(self) -> SnowflakeCursor:
-        return ApplicationPackageEntity.version_list(
-            self.package_name, self.package_role
-        )
-
-    def get_existing_version_info(self, version: str) -> Optional[dict]:
-        return ApplicationPackageEntity.get_existing_version_info(
-            version=version,
-            package_name=self.package_name,
-            package_role=self.package_role,
-        )
-
-    def drop_application_before_upgrade(
-        self, policy: PolicyBase, is_interactive: bool, cascade: bool = False
-    ):
-        """
-        This method will attempt to drop an application object if a previous upgrade fails.
-        """
-        if cascade:
-            try:
-                if application_objects := self.get_objects_owned_by_application():
-                    application_objects_str = self._application_objects_to_str(
-                        application_objects
-                    )
-                    cc.message(
-                        f"The following objects are owned by application {self.app_name} and need to be dropped:\n{application_objects_str}"
-                    )
-            except ProgrammingError as err:
-                if err.errno != APPLICATION_NO_LONGER_AVAILABLE:
-                    generic_sql_error_handler(err)
-                cc.warning(
-                    "The application owns other objects but they could not be determined."
-                )
-            user_prompt = "Do you want the Snowflake CLI to drop these objects, then drop the existing application object and recreate it?"
-        else:
-            user_prompt = "Do you want the Snowflake CLI to drop the existing application object and recreate it?"
-
-        if not policy.should_proceed(user_prompt):
-            if is_interactive:
-                cc.message("Not upgrading the application object.")
-                raise typer.Exit(0)
-            else:
-                cc.message(
-                    "Cannot upgrade the application object non-interactively without --force."
-                )
-                raise typer.Exit(1)
-        try:
-            cascade_msg = " (cascade)" if cascade else ""
-            cc.step(f"Dropping application object {self.app_name}{cascade_msg}.")
-            cascade_sql = " cascade" if cascade else ""
-            sql_executor = get_sql_executor()
-            sql_executor.execute_query(f"drop application {self.app_name}{cascade_sql}")
-        except ProgrammingError as err:
-            if err.errno == APPLICATION_OWNS_EXTERNAL_OBJECTS and not cascade:
-                # We need to cascade the deletion, let's try again (only if we didn't try with cascade already)
-                return self.drop_application_before_upgrade(
-                    policy, is_interactive, cascade=True
-                )
-            else:
-                generic_sql_error_handler(err)
-
-    def create_or_upgrade_app(
-        self,
-        policy: PolicyBase,
-        install_method: SameAccountInstallMethod,
-        is_interactive: bool = False,
-    ):
-        def drop_app():
-            self.drop_application_before_upgrade(policy, is_interactive)
-
-        return ApplicationEntity.create_or_upgrade_app(
-            console=cc,
-            project_root=self.project_root,
-            package_name=self.package_name,
-            package_role=self.package_role,
-            app_name=self.app_name,
-            app_role=self.app_role,
-            app_warehouse=self.application_warehouse,
-            stage_schema=self.stage_schema,
-            stage_fqn=self.stage_fqn,
-            debug_mode=self.debug_mode,
-            policy=policy,
-            install_method=install_method,
-            is_interactive=is_interactive,
-            post_deploy_hooks=self.app_post_deploy_hooks,
-            drop_application_before_upgrade=drop_app,
-        )
-
-    def process(
-        self,
-        bundle_map: BundleMap,
-        policy: PolicyBase,
-        version: Optional[str] = None,
-        patch: Optional[int] = None,
-        from_release_directive: bool = False,
-        is_interactive: bool = False,
-        validate: bool = True,
-        *args,
-        **kwargs,
-    ):
-        def deploy_package():
-            self.deploy(
-                bundle_map=bundle_map,
-                prune=True,
-                recursive=True,
-                validate=validate,
-                policy=policy,
-            )
-
-        def drop_app():
-            self.drop_application_before_upgrade(policy, is_interactive)
-
-        ApplicationEntity.deploy(
-            console=cc,
-            project_root=self.project_root,
-            app_name=self.app_name,
-            app_role=self.app_role,
-            app_warehouse=self.application_warehouse,
-            package_name=self.package_name,
-            package_role=self.package_role,
-            stage_schema=self.stage_schema,
-            stage_fqn=self.stage_fqn,
-            debug_mode=self.debug_mode,
-            validate=validate,
-            from_release_directive=from_release_directive,
-            is_interactive=is_interactive,
-            policy=policy,
-            version=version,
-            patch=patch,
-            post_deploy_hooks=self.app_post_deploy_hooks,
-            deploy_package=deploy_package,
-            drop_application_before_upgrade=drop_app,
-        )

snowflake/cli/_plugins/nativeapp/same_account_install_method.py

@@ -1,70 +0,0 @@
-from typing import Optional
-
-from snowflake.cli._plugins.nativeapp.constants import (
-    ALLOWED_SPECIAL_COMMENTS,
-    COMMENT_COL,
-)
-from snowflake.cli._plugins.nativeapp.exceptions import (
-    ApplicationCreatedExternallyError,
-)
-
-# from snowflake.cli._plugins.nativeapp.project_model import NativeAppProjectModel
-from snowflake.cli._plugins.stage.manager import StageManager
-
-
-class SameAccountInstallMethod:
-    _requires_created_by_cli: bool
-    _from_release_directive: bool
-    version: Optional[str]
-    patch: Optional[int]
-
-    def __init__(
-        self,
-        requires_created_by_cli: bool,
-        version: Optional[str] = None,
-        patch: Optional[int] = None,
-        from_release_directive: bool = False,
-    ):
-        self._requires_created_by_cli = requires_created_by_cli
-        self.version = version
-        self.patch = patch
-        self._from_release_directive = from_release_directive
-
-    @classmethod
-    def unversioned_dev(cls):
-        """aka. stage dev aka loose files"""
-        return cls(True)
-
-    @classmethod
-    def versioned_dev(cls, version: str, patch: Optional[int] = None):
-        return cls(False, version, patch)
-
-    @classmethod
-    def release_directive(cls):
-        return cls(False, from_release_directive=True)
-
-    @property
-    def is_dev_mode(self) -> bool:
-        return not self._from_release_directive
-
-    def using_clause(
-        self,
-        stage_fqn: str,
-    ) -> str:
-        if self._from_release_directive:
-            return ""
-
-        if self.version:
-            patch_clause = f"patch {self.patch}" if self.patch else ""
-            return f"using version {self.version} {patch_clause}"
-
-        stage_name = StageManager.quote_stage_name(stage_fqn)
-        return f"using {stage_name}"
-
-    def ensure_app_usable(self, app_name: str, app_role: str, show_app_row: dict):
-        """Raise an exception if we cannot proceed with install given the pre-existing application object"""
-
-        if self._requires_created_by_cli:
-            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS:
-                # this application object was not created by this tooling
-                raise ApplicationCreatedExternallyError(app_name)

snowflake/cli/_plugins/nativeapp/teardown_processor.py

@@ -1,70 +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 typing import Dict, Optional
-
-from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntity
-from snowflake.cli._plugins.nativeapp.entities.application_package import (
-    ApplicationPackageEntity,
-)
-from snowflake.cli._plugins.nativeapp.manager import (
-    NativeAppCommandProcessor,
-    NativeAppManager,
-)
-from snowflake.cli.api.console import cli_console as cc
-
-
-class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
-    def __init__(self, project_definition: Dict, project_root: Path):
-        super().__init__(project_definition, project_root)
-
-    def drop_application(
-        self, auto_yes: bool, interactive: bool = False, cascade: Optional[bool] = None
-    ):
-        return ApplicationEntity.drop(
-            console=cc,
-            app_name=self.app_name,
-            app_role=self.app_role,
-            auto_yes=auto_yes,
-            interactive=interactive,
-            cascade=cascade,
-        )
-
-    def drop_package(self, auto_yes: bool):
-        return ApplicationPackageEntity.drop(
-            console=cc,
-            package_name=self.package_name,
-            package_role=self.package_role,
-            force_drop=auto_yes,
-        )
-
-    def process(
-        self,
-        interactive: bool,
-        force_drop: bool = False,
-        cascade: Optional[bool] = None,
-        *args,
-        **kwargs,
-    ):
-
-        # Drop the application object
-        self.drop_application(
-            auto_yes=force_drop, interactive=interactive, cascade=cascade
-        )
-
-        # Drop the application package
-        self.drop_package(auto_yes=force_drop)

snowflake/cli/_plugins/nativeapp/utils.py

@@ -1,98 +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
-
-import os
-from pathlib import Path
-from sys import stdin, stdout
-from typing import Iterable, Optional, Union
-
-from click import ClickException
-
-
-def needs_confirmation(needs_confirm: bool, auto_yes: bool) -> bool:
-    return needs_confirm and not auto_yes
-
-
-def is_tty_interactive():
-    return stdin.isatty() and stdout.isatty()
-
-
-def get_first_paragraph_from_markdown_file(file_path: Path) -> Optional[str]:
-    """
-    Reads a Markdown file at the given file path and finds the first paragraph
-
-    Parameters:
-        file_path (Path): Path to Markdown file
-
-    Returns:
-        Optional[str]: the first paragraph as a string, or None
-        if no paragraph could be found
-
-    Raises:
-        FileNotFoundError: if file_path to Markdown file does not exist
-    """
-    if not file_path.exists():
-        raise FileNotFoundError(file_path)
-
-    with open(file_path, "r") as markdown_file:
-        paragraph_text = None
-
-        for line in markdown_file:
-            stripped_line = line.strip()
-            if not stripped_line.startswith("#") and stripped_line:
-                paragraph_text = stripped_line
-                break
-
-        return paragraph_text
-
-
-def shallow_git_clone(url: Union[str, os.PathLike], to_path: Union[str, os.PathLike]):
-    """
-    Performs a shallow clone of the repository at the provided url to the path specified
-
-    Parameters:
-        url (str | PathLike): Valid git url.
-        to_path (str | PathLike): Path to which the repository should be cloned to.
-
-    Returns:
-        Repo: the repository that was cloned
-    """
-    from git import Repo
-
-    # Clone the repository in the directory with options.
-    repo = Repo.clone_from(
-        url=url,
-        to_path=to_path,
-        filter=["tree:0"],
-        depth=1,
-    )
-    # Close repo to avoid issues with permissions on Windows
-    repo.close()
-
-    return repo
-
-
-def verify_no_directories(paths_to_sync: Iterable[Path]):
-    for path in paths_to_sync:
-        if path.is_dir():
-            raise ClickException(
-                f"{path} is a directory. Add the -r flag to deploy directories."  #
-            )
-
-
-def verify_exists(path: Path):
-    if not path.exists():
-        raise ClickException(f"The following path does not exist: {path}")