snowflake-cli-labs 2.8.0rc1__py3-none-any.whl → 2.8.2__py3-none-any.whl

snowflake/cli/plugins/git/commands.py

@@ -1,305 +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 itertools
-import logging
-from os import path
-from pathlib import Path
-from typing import List, Optional
-
-import typer
-from click import ClickException
-from snowflake.cli.api.commands.flags import (
-    ExecuteVariablesOption,
-    OnErrorOption,
-    PatternOption,
-    identifier_argument,
-    like_option,
-)
-from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.console.console import cli_console
-from snowflake.cli.api.constants import ObjectType
-from snowflake.cli.api.output.types import CollectionResult, CommandResult, QueryResult
-from snowflake.cli.api.utils.path_utils import is_stage_path
-from snowflake.cli.plugins.git.manager import GitManager
-from snowflake.cli.plugins.object.command_aliases import (
-    add_object_command_aliases,
-    scope_option,
-)
-from snowflake.cli.plugins.object.manager import ObjectManager
-from snowflake.cli.plugins.stage.manager import OnErrorType
-
-app = SnowTyperFactory(
-    name="git",
-    help="Manages git repositories in Snowflake.",
-)
-log = logging.getLogger(__name__)
-
-
-def _repo_path_argument_callback(path):
-    # All repository paths must start with repository scope:
-    # "@repo_name/tag/example_tag/*"
-    if not is_stage_path(path) or path.count("/") < 3:
-        raise ClickException(
-            "REPOSITORY_PATH should be a path to git repository stage with scope provided."
-            " Path to the repository root must end with '/'."
-            " For example: @my_repo/branches/main/"
-        )
-
-    return path
-
-
-RepoNameArgument = identifier_argument(sf_object="git repository", example="my_repo")
-RepoPathArgument = typer.Argument(
-    metavar="REPOSITORY_PATH",
-    help=(
-        "Path to git repository stage with scope provided."
-        " Path to the repository root must end with '/'."
-        " For example: @my_repo/branches/main/"
-    ),
-    callback=_repo_path_argument_callback,
-)
-add_object_command_aliases(
-    app=app,
-    object_type=ObjectType.GIT_REPOSITORY,
-    name_argument=RepoNameArgument,
-    like_option=like_option(
-        help_example='`list --like "my%"` lists all git repositories with name that begin with “my”',
-    ),
-    scope_option=scope_option(help_example="`list --in database my_db`"),
-)
-
-
-def _assure_repository_does_not_exist(om: ObjectManager, repository_name: str) -> None:
-    if om.object_exists(
-        object_type=ObjectType.GIT_REPOSITORY.value.cli_name, name=repository_name
-    ):
-        raise ClickException(f"Repository '{repository_name}' already exists")
-
-
-def _validate_origin_url(url: str) -> None:
-    if not url.startswith("https://"):
-        raise ClickException("Url address should start with 'https'")
-
-
-@app.command("setup", requires_connection=True)
-def setup(
-    repository_name: str = RepoNameArgument,
-    **options,
-) -> CommandResult:
-    """
-    Sets up a git repository object.
-
-    You will be prompted for:
-
-    * url - address of repository to be used for git clone operation
-
-    * secret - Snowflake secret containing authentication credentials. Not needed if origin repository does not require
-    authentication for RO operations (clone, fetch)
-
-    * API integration - object allowing Snowflake to interact with git repository.
-    """
-    manager = GitManager()
-    om = ObjectManager()
-    _assure_repository_does_not_exist(om, repository_name)
-
-    url = typer.prompt("Origin url")
-    _validate_origin_url(url)
-
-    secret_needed = typer.confirm("Use secret for authentication?")
-    should_create_secret = False
-    secret_name = None
-    if secret_needed:
-        secret_name = f"{repository_name}_secret"
-        secret_name = typer.prompt(
-            "Secret identifier (will be created if not exists)", default=secret_name
-        )
-        if om.object_exists(
-            object_type=ObjectType.SECRET.value.cli_name, name=secret_name
-        ):
-            cli_console.step(f"Using existing secret '{secret_name}'")
-        else:
-            should_create_secret = True
-            cli_console.step(f"Secret '{secret_name}' will be created")
-            secret_username = typer.prompt("username")
-            secret_password = typer.prompt("password/token", hide_input=True)
-
-    api_integration = f"{repository_name}_api_integration"
-    api_integration = typer.prompt(
-        "API integration identifier (will be created if not exists)",
-        default=api_integration,
-    )
-
-    if should_create_secret:
-        manager.create_password_secret(
-            name=secret_name, username=secret_username, password=secret_password
-        )
-        cli_console.step(f"Secret '{secret_name}' successfully created.")
-
-    if not om.object_exists(
-        object_type=ObjectType.INTEGRATION.value.cli_name, name=api_integration
-    ):
-        manager.create_api_integration(
-            name=api_integration,
-            api_provider="git_https_api",
-            allowed_prefix=url,
-            secret=secret_name,
-        )
-        cli_console.step(f"API integration '{api_integration}' successfully created.")
-    else:
-        cli_console.step(f"Using existing API integration '{api_integration}'.")
-
-    return QueryResult(
-        manager.create(
-            repo_name=repository_name,
-            url=url,
-            api_integration=api_integration,
-            secret=secret_name,
-        )
-    )
-
-
-@app.command(
-    "list-branches",
-    requires_connection=True,
-)
-def list_branches(
-    repository_name: str = RepoNameArgument,
-    like=like_option(
-        help_example='`list-branches --like "%_test"` lists all branches that end with "_test"'
-    ),
-    **options,
-) -> CommandResult:
-    """
-    List all branches in the repository.
-    """
-    return QueryResult(GitManager().show_branches(repo_name=repository_name, like=like))
-
-
-@app.command(
-    "list-tags",
-    requires_connection=True,
-)
-def list_tags(
-    repository_name: str = RepoNameArgument,
-    like=like_option(
-        help_example='`list-tags --like "v2.0%"` lists all tags that start with "v2.0"'
-    ),
-    **options,
-) -> CommandResult:
-    """
-    List all tags in the repository.
-    """
-    return QueryResult(GitManager().show_tags(repo_name=repository_name, like=like))
-
-
-@app.command(
-    "list-files",
-    requires_connection=True,
-)
-def list_files(
-    repository_path: str = RepoPathArgument,
-    pattern=PatternOption,
-    **options,
-) -> CommandResult:
-    """
-    List files from given state of git repository.
-    """
-    return QueryResult(
-        GitManager().list_files(stage_name=repository_path, pattern=pattern)
-    )
-
-
-@app.command(
-    "fetch",
-    requires_connection=True,
-)
-def fetch(
-    repository_name: str = RepoNameArgument,
-    **options,
-) -> CommandResult:
-    """
-    Fetch changes from origin to Snowflake repository.
-    """
-    return QueryResult(GitManager().fetch(repo_name=repository_name))
-
-
-@app.command(
-    "copy",
-    requires_connection=True,
-)
-def copy(
-    repository_path: str = RepoPathArgument,
-    destination_path: str = typer.Argument(
-        help="Target path for copy operation. Should be a path to a directory on remote stage or local file system.",
-    ),
-    parallel: int = typer.Option(
-        4,
-        help="Number of parallel threads to use when downloading files.",
-    ),
-    **options,
-):
-    """
-    Copies all files from given state of repository to local directory or stage.
-
-    If the source path ends with '/', the command copies contents of specified directory.
-    Otherwise, it creates a new directory or file in the destination directory.
-    """
-    is_copy = is_stage_path(destination_path)
-    if is_copy:
-        return QueryResult(
-            GitManager().copy_files(
-                source_path=repository_path, destination_path=destination_path
-            )
-        )
-    return get(
-        source_path=repository_path,
-        destination_path=destination_path,
-        parallel=parallel,
-    )
-
-
-@app.command("execute", requires_connection=True)
-def execute(
-    repository_path: str = RepoPathArgument,
-    on_error: OnErrorType = OnErrorOption,
-    variables: Optional[List[str]] = ExecuteVariablesOption,
-    **options,
-):
-    """
-    Execute immediate all files from the repository path. Files can be filtered with glob like pattern,
-    e.g. `@my_repo/branches/main/*.sql`, `@my_repo/branches/main/dev/*`. Only files with `.sql`
-    extension will be executed.
-    """
-    results = GitManager().execute(
-        stage_path=repository_path, on_error=on_error, variables=variables
-    )
-    return CollectionResult(results)
-
-
-def get(source_path: str, destination_path: str, parallel: int):
-    target = Path(destination_path).resolve()
-
-    cursors = GitManager().get_recursive(
-        stage_path=source_path, dest_path=target, parallel=parallel
-    )
-    results = [list(QueryResult(c).result) for c in cursors]
-    flattened_results = list(itertools.chain.from_iterable(results))
-    sorted_results = sorted(
-        flattened_results,
-        key=lambda e: (path.dirname(e["file"]), path.basename(e["file"])),
-    )
-    return CollectionResult(sorted_results)

snowflake/cli/plugins/git/manager.py

@@ -1,96 +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 List
-
-from snowflake.cli.plugins.stage.manager import (
-    USER_STAGE_PREFIX,
-    StageManager,
-    StagePathParts,
-    UserStagePathParts,
-)
-from snowflake.connector.cursor import SnowflakeCursor
-
-
-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
-        git_repo_name = stage_path_parts[0].split(".")[-1]
-        if git_repo_name.startswith("@"):
-            git_repo_name = git_repo_name[1:]
-        self.stage_name = "/".join([git_repo_name, *stage_path_parts[1:3], ""])
-        self.directory = "/".join(stage_path_parts[3:])
-        self.is_directory = True if stage_path.endswith("/") else False
-
-    @property
-    def path(self) -> str:
-        return (
-            f"{self.stage_name}{self.directory}"
-            if self.stage_name.endswith("/")
-            else f"{self.stage_name}/{self.directory}"
-        )
-
-    def add_stage_prefix(self, file_path: str) -> str:
-        stage = Path(self.stage).parts[0]
-        file_path_without_prefix = Path(file_path).parts[1:]
-        return f"{stage}/{'/'.join(file_path_without_prefix)}"
-
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        stage_path_length = len(Path(self.directory).parts)
-        return list(Path(file_path).parts[3 + stage_path_length : -1])
-
-
-class GitManager(StageManager):
-    def show_branches(self, repo_name: str, like: str) -> SnowflakeCursor:
-        return self._execute_query(f"show git branches like '{like}' in {repo_name}")
-
-    def show_tags(self, repo_name: str, like: str) -> SnowflakeCursor:
-        return self._execute_query(f"show git tags like '{like}' in {repo_name}")
-
-    def fetch(self, repo_name: str) -> SnowflakeCursor:
-        return self._execute_query(f"alter git repository {repo_name} fetch")
-
-    def create(
-        self, repo_name: str, api_integration: str, url: str, secret: str
-    ) -> SnowflakeCursor:
-        query = dedent(
-            f"""
-            create git repository {repo_name}
-            api_integration = {api_integration}
-            origin = '{url}'
-            """
-        )
-        if secret is not None:
-            query += f"git_credentials = {secret}\n"
-        return self._execute_query(query)
-
-    @staticmethod
-    def get_stage_from_path(path: str):
-        """
-        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])}/"
-
-    @staticmethod
-    def _stage_path_part_factory(stage_path: str) -> StagePathParts:
-        stage_path = StageManager.get_standard_stage_prefix(stage_path)
-        if stage_path.startswith(USER_STAGE_PREFIX):
-            return UserStagePathParts(stage_path)
-        return GitStagePathParts(stage_path)

snowflake/cli/plugins/git/plugin_spec.py

@@ -1,30 +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 snowflake.cli.api.plugins.command import (
-    SNOWCLI_ROOT_COMMAND_PATH,
-    CommandSpec,
-    CommandType,
-    plugin_hook_impl,
-)
-from snowflake.cli.plugins.git import commands
-
-
-@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/plugins/init/__init__.py

@@ -1,13 +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.

snowflake/cli/plugins/init/commands.py

@@ -1,244 +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 logging
-from typing import Any, Dict, List, Optional
-
-import typer
-import yaml
-from click import ClickException
-from snowflake.cli.__about__ import VERSION
-from snowflake.cli.api.commands.flags import (
-    NoInteractiveOption,
-    parse_key_value_variables,
-    variables_option,
-)
-from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
-from snowflake.cli.api.exceptions import InvalidTemplate
-from snowflake.cli.api.output.types import (
-    CommandResult,
-    MessageResult,
-)
-from snowflake.cli.api.project.schemas.template import Template, TemplateVariable
-from snowflake.cli.api.rendering.project_templates import render_template_files
-from snowflake.cli.api.secure_path import SecurePath
-
-# simple Typer with defaults because it won't become a command group as it contains only one command
-app = SnowTyperFactory()
-
-
-DEFAULT_SOURCE = "https://github.com/snowflakedb/snowflake-cli-templates"
-
-log = logging.getLogger(__name__)
-
-
-def _path_argument_callback(path: str) -> str:
-    if SecurePath(path).exists():
-        raise ClickException(
-            f"The directory {path} already exists. Please specify a different path for the project."
-        )
-    return path
-
-
-PathArgument = typer.Argument(
-    ...,
-    help="Directory to be initialized with the project. This directory must not already exist",
-    show_default=False,
-    callback=_path_argument_callback,
-)
-TemplateOption = typer.Option(
-    None,
-    "--template",
-    help="which template (subdirectory of --template-source) should be used. If not provided,"
-    " whole source will be used as the template.",
-    show_default=False,
-)
-SourceOption = typer.Option(
-    default=DEFAULT_SOURCE,
-    help=f"local path to template directory or URL to git repository with templates.",
-)
-VariablesOption = variables_option(
-    "String in `key=value` format. Provided variables will not be prompted for."
-)
-
-TEMPLATE_METADATA_FILE_NAME = "template.yml"
-
-
-def _fetch_local_template(
-    template_source: SecurePath, path: Optional[str], destination: SecurePath
-) -> SecurePath:
-    """Copies local template to [dest] and returns path to the template root.
-    Ends with an error of the template does not exist."""
-
-    template_source.assert_exists()
-    template_origin = template_source / path if path else template_source
-    log.info("Copying local template from %s", template_origin.path)
-    if not template_origin.exists():
-        raise ClickException(
-            f"Template '{path}' cannot be found under {template_source}"
-        )
-
-    template_origin.copy(destination.path)
-    return destination / template_origin.name
-
-
-def _fetch_remote_template(
-    url: str, path: Optional[str], destination: SecurePath
-) -> SecurePath:
-    """Downloads remote repository template to [dest],
-    and returns path to the template root.
-    Ends with an error of the template does not exist."""
-    from git import GitCommandError
-    from git import rmtree as git_rmtree
-
-    # TODO: during nativeapp refactor get rid of this dependency
-    from snowflake.cli.plugins.nativeapp.utils import shallow_git_clone
-
-    log.info("Downloading remote template from %s", url)
-    try:
-        shallow_git_clone(url, to_path=destination.path)
-    except GitCommandError as err:
-        import re
-
-        if re.search("fatal: repository '.*' not found", err.stderr):
-            raise ClickException(f"Repository '{url}' does not exist")
-        raise
-
-    if path:
-        # template is a subdirectoruy of the repository
-        template_root = destination / path
-    else:
-        # template is a whole repository
-        # removing .git directory not to copy it to the template
-        template_root = destination
-        git_rmtree((template_root / ".git").path)
-    if not template_root.exists():
-        raise ClickException(f"Template '{path}' cannot be found under {url}")
-
-    return template_root
-
-
-def _read_template_metadata(template_root: SecurePath) -> Template:
-    """Parse template.yml file."""
-    template_metadata_path = template_root / TEMPLATE_METADATA_FILE_NAME
-    log.debug("Reading template metadata from %s", template_metadata_path.path)
-    if not template_metadata_path.exists():
-        raise InvalidTemplate(
-            f"Template does not have {TEMPLATE_METADATA_FILE_NAME} file."
-        )
-    with template_metadata_path.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
-        yaml_contents = yaml.safe_load(fd) or {}
-    return Template(template_root, **yaml_contents)
-
-
-def _remove_template_metadata_file(template_root: SecurePath) -> None:
-    (template_root / TEMPLATE_METADATA_FILE_NAME).unlink()
-
-
-def _determine_variable_values(
-    variables_metadata: List[TemplateVariable],
-    variables_from_flags: Dict[str, Any],
-    no_interactive: bool,
-) -> Dict[str, Any]:
-    """
-    Prompt user for values not provided in [variables_from_flags].
-    If [no_interactive] is True, fill not provided variables with their default values.
-    """
-    result = {}
-
-    log.debug(
-        "Resolving values of variables: %s",
-        ", ".join(v.name for v in variables_metadata),
-    )
-    for variable in variables_metadata:
-        if variable.name in variables_from_flags:
-            value = variable.python_type(variables_from_flags[variable.name])
-        else:
-            value = variable.prompt_user_for_value(no_interactive)
-
-        result[variable.name] = value
-
-    return result
-
-
-def _validate_cli_version(required_version: str) -> None:
-    from packaging.version import parse
-
-    if parse(required_version) > parse(VERSION):
-        raise ClickException(
-            f"Snowflake CLI version ({VERSION}) is too low - minimum version required"
-            f" by template is {required_version}. Please upgrade before continuing."
-        )
-
-
-@app.command(no_args_is_help=True)
-def init(
-    path: str = PathArgument,
-    template: Optional[str] = TemplateOption,
-    template_source: Optional[str] = SourceOption,
-    variables: Optional[List[str]] = VariablesOption,
-    no_interactive: bool = NoInteractiveOption,
-    **options,
-) -> CommandResult:
-    """
-    Creates project directory from template.
-    """
-    variables_from_flags = {
-        v.key: v.value for v in parse_key_value_variables(variables)
-    }
-    is_remote = any(
-        template_source.startswith(prefix) for prefix in ["git@", "http://", "https://"]  # type: ignore
-    )
-
-    # copy/download template into tmpdir, so it is going to be removed in case command ends with an error
-    with SecurePath.temporary_directory() as tmpdir:
-        if is_remote:
-            template_root = _fetch_remote_template(
-                url=template_source, path=template, destination=tmpdir  # type: ignore
-            )
-        else:
-            template_root = _fetch_local_template(
-                template_source=SecurePath(template_source),
-                path=template,
-                destination=tmpdir,
-            )
-
-        template_metadata = _read_template_metadata(template_root)
-        if template_metadata.minimum_cli_version:
-            _validate_cli_version(template_metadata.minimum_cli_version)
-
-        variable_values = _determine_variable_values(
-            variables_metadata=template_metadata.variables,
-            variables_from_flags=variables_from_flags,
-            no_interactive=no_interactive,
-        ) | {
-            "project_dir_name": SecurePath(path).name,
-            "snowflake_cli_version": VERSION,
-        }
-        log.debug(
-            "Rendering template files: %s", ", ".join(template_metadata.files_to_render)
-        )
-        render_template_files(
-            template_root=template_root,
-            files_to_render=template_metadata.files_to_render,
-            data=variable_values,
-        )
-        _remove_template_metadata_file(template_root)
-        SecurePath(path).parent.mkdir(exist_ok=True, parents=True)
-        template_root.copy(path)
-
-    return MessageResult(f"Initialized the new project in {path}")