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

snowflake/cli/plugins/snowpark/package/anaconda_packages.py

@@ -1,233 +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 dataclasses import dataclass
-from typing import Dict, List, Set
-
-import requests
-from click import ClickException
-from packaging.requirements import InvalidRequirement
-from packaging.requirements import Requirement as PkgRequirement
-from packaging.version import InvalidVersion, parse
-from requests import HTTPError
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.api.sql_execution import SqlExecutionMixin
-from snowflake.cli.plugins.snowpark.models import Requirement
-from snowflake.connector import DictCursor
-
-log = logging.getLogger(__name__)
-
-
-@dataclass
-class FilterRequirementsResult:
-    """A dataclass to hold the results of parsing requirements files and dividing them into
-    snowflake-supported vs other packages.
-    """
-
-    in_snowflake: List[Requirement]
-    unavailable: List[Requirement]
-
-
-@dataclass
-class AvailablePackage:
-    snowflake_name: str
-    versions: Set[str]
-
-    def iter_versions(self):
-        for version in self.versions:
-            yield parse(version)
-
-    def is_required_version_available(self, requirement: Requirement) -> bool:
-        try:
-            package_specifiers = PkgRequirement(requirement.line).specifier
-            return any(
-                version in package_specifiers for version in self.iter_versions()
-            )
-        except (InvalidVersion, InvalidRequirement):
-            # fail-safe for non-pep508 formats
-            return False
-
-
-class AnacondaPackages:
-    def __init__(self, packages: Dict[str, AvailablePackage]):
-        """
-        [packages] should be a dictionary mapping package name to AnacondaPackageData object.
-        All package names should be provided in wheel escape format:
-        https://peps.python.org/pep-0491/#escaping-and-unicode
-        """
-        self._packages = packages
-
-    @classmethod
-    def empty(cls):
-        return cls({})
-
-    def is_package_available(
-        self, package: Requirement, skip_version_check: bool = False
-    ) -> bool:
-        """
-        Checks of a requirement is available in the Snowflake Anaconda Channel.
-
-        As Snowflake currently doesn't support extra syntax (ex. `jinja2[diagrams]`), if such
-        extra is present in the dependency, we mark it as unavailable.
-        """
-        if not package.name or package.extras:
-            return False
-        if package.name not in self._packages:
-            return False
-        if skip_version_check or not package.specs:
-            return True
-        return self._packages[package.name].is_required_version_available(package)
-
-    def package_latest_version(self, package: Requirement) -> str | None:
-        """Returns the latest version of the package or None if the latest version can't be determined."""
-        if package.name not in self._packages:
-            return None
-        try:
-            return str(max(self._packages[package.name].iter_versions()))
-        except InvalidVersion:
-            # fail-safe for non-pep8 versions
-            return None
-
-    def package_versions(self, package: Requirement) -> List[str]:
-        """Returns list of available versions of the package."""
-        if package.name not in self._packages:
-            return []
-        package_data = self._packages[package.name]
-        try:
-            return list(
-                str(x) for x in sorted(package_data.iter_versions(), reverse=True)
-            )
-        except InvalidVersion:
-            return list(sorted(package_data.versions, reverse=True))
-
-    def filter_available_packages(
-        self, packages: List[Requirement], skip_version_check: bool = False
-    ) -> FilterRequirementsResult:
-        """
-        Checks if a list of packages are available in the Snowflake Anaconda channel.
-        Returns an object with two attributes: 'snowflake' and 'other'.
-        Each key contains a list of Requirement object.
-
-        Parameters:
-            packages (List[Requirement]) - list of requirements to be checked
-            skip_version_check (bool) - skip comparing versions of packages
-
-        Returns:
-            result (FilterRequirementsResult) - object containing two arguments:
-              - in_snowflake - packages available in conda
-              - unavailable - packages not available in conda
-        """
-        result = FilterRequirementsResult([], [])
-        for package in packages:
-            if self.is_package_available(
-                package, skip_version_check=skip_version_check
-            ):
-                result.in_snowflake.append(package)
-            else:
-                log.info(
-                    "'%s' not found in Snowflake Anaconda channel (or ignored)...",
-                    package.name,
-                )
-                result.unavailable.append(package)
-        return result
-
-    def write_requirements_file_in_snowflake_format(
-        self,
-        file_path: SecurePath,
-        requirements: List[Requirement],
-    ):
-        """Saves requirements to a file in format accepted by Snowflake SQL commands."""
-        log.info("Writing requirements into file %s", file_path.path)
-        formatted_requirements = []
-        for requirement in requirements:
-            if requirement.name and requirement.name in self._packages:
-                snowflake_name = self._packages[requirement.name].snowflake_name
-                formatted_requirements.append(
-                    snowflake_name + requirement.formatted_specs
-                )
-
-        if formatted_requirements:
-            file_path.write_text("\n".join(formatted_requirements))
-
-
-class AnacondaPackagesManager(SqlExecutionMixin):
-    _snowflake_channel_url: str = (
-        "https://repo.anaconda.com/pkgs/snowflake/channeldata.json"
-    )
-
-    # TODO in v3.0: Keep only SQL query, remove fallback to JSON with channel's metadata
-    def find_packages_available_in_snowflake_anaconda(self) -> AnacondaPackages:
-        """
-        Finds python packages available in Snowflake to use in functions and stored procedures.
-        It tries to get the list of packages using SQL query
-        but if the try fails then the fallback is to parse JSON containing info about Snowflake's Anaconda channel.
-        """
-        try:
-            packages = self._query_snowflake_for_available_packages()
-        except Exception as ex:
-            log.warning(
-                "Cannot fetch available packages information from Snowflake. "
-                "Please check your connection configuration. "
-                "Fallback to Anaconda channel metadata."
-            )
-            log.debug("Available packages query failure: %s", ex.__str__(), exc_info=ex)
-            packages = self._get_available_packages_from_anaconda_channel_info()
-        return AnacondaPackages(packages)
-
-    def _query_snowflake_for_available_packages(self) -> dict[str, AvailablePackage]:
-        cursor = self._execute_query(
-            "select package_name, version from information_schema.packages where language = 'python'",
-            cursor_class=DictCursor,
-        )
-        if cursor.rowcount is None or cursor.rowcount == 0:
-            raise SnowflakeSQLExecutionError()
-        packages: dict[str, AvailablePackage] = {}
-        for row in cursor:
-            if not (package_name := row["PACKAGE_NAME"]):
-                continue
-            if not (version := row["VERSION"]):
-                continue
-            standardized_name = Requirement.standardize_name(package_name)
-            if standardized_name in packages:
-                packages[standardized_name].versions.add(version)
-            else:
-                packages[standardized_name] = AvailablePackage(
-                    snowflake_name=package_name, versions={version}
-                )
-        return packages
-
-    def _get_available_packages_from_anaconda_channel_info(
-        self,
-    ) -> dict[str, AvailablePackage]:
-        try:
-            response = requests.get(self._snowflake_channel_url)
-            response.raise_for_status()
-            packages = {}
-            for key, package in response.json()["packages"].items():
-                if not (version := package.get("version")):
-                    continue
-                package_name = package.get("name", key)
-                standardized_name = Requirement.standardize_name(package_name)
-                packages[standardized_name] = AvailablePackage(
-                    snowflake_name=package_name, versions={version}
-                )
-            return packages
-        except HTTPError as err:
-            raise ClickException(
-                f"Accessing Snowflake Anaconda channel failed. Reason {err}"
-            )

snowflake/cli/plugins/snowpark/package/commands.py

@@ -1,256 +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 pathlib import Path
-from textwrap import dedent
-from typing import Optional
-
-import typer
-from click import ClickException
-from snowflake.cli.api.commands.flags import (
-    deprecated_flag_callback,
-)
-from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.output.types import CommandResult, MessageResult
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.plugins.snowpark.models import (
-    Requirement,
-    YesNoAsk,
-)
-from snowflake.cli.plugins.snowpark.package.anaconda_packages import (
-    AnacondaPackages,
-    AnacondaPackagesManager,
-)
-from snowflake.cli.plugins.snowpark.package.manager import upload
-from snowflake.cli.plugins.snowpark.package_utils import (
-    detect_and_log_shared_libraries,
-    download_unavailable_packages,
-    get_package_name_from_pip_wheel,
-)
-from snowflake.cli.plugins.snowpark.snowpark_shared import (
-    AllowSharedLibrariesOption,
-    IgnoreAnacondaOption,
-    IndexUrlOption,
-    SkipVersionCheckOption,
-    deprecated_allow_native_libraries_option,
-    resolve_allow_shared_libraries_yes_no_ask,
-)
-from snowflake.cli.plugins.snowpark.zipper import zip_dir
-
-app = SnowTyperFactory(
-    name="package",
-    help="Manages custom Python packages for Snowpark",
-)
-log = logging.getLogger(__name__)
-
-
-lookup_install_option = typer.Option(
-    False,
-    "--pypi-download",
-    hidden=True,
-    callback=deprecated_flag_callback(
-        "Using --pypi-download is deprecated. Lookup command no longer checks for package in PyPi."
-    ),
-    help="Installs packages that are not available on the Snowflake Anaconda channel.",
-)
-
-lookup_deprecated_install_option = typer.Option(
-    False,
-    "--yes",
-    "-y",
-    hidden=True,
-    callback=deprecated_flag_callback(
-        "Using --yes is deprecated. Lookup command no longer checks for package in PyPi."
-    ),
-    help="Installs packages that are not available on the Snowflake Anaconda channel.",
-)
-
-
-@app.command("lookup", requires_connection=True)
-def package_lookup(
-    package_name: str = typer.Argument(
-        ..., help="Name of the package.", show_default=False
-    ),
-    # todo: remove with 3.0
-    _: bool = lookup_install_option,
-    __: bool = lookup_deprecated_install_option,
-    **options,
-) -> CommandResult:
-    """
-    Checks if a package is available on the Snowflake Anaconda channel.
-    """
-    anaconda_packages_manager = AnacondaPackagesManager()
-    anaconda_packages = (
-        anaconda_packages_manager.find_packages_available_in_snowflake_anaconda()
-    )
-
-    package = Requirement.parse(package_name)
-    if anaconda_packages.is_package_available(package=package):
-        msg = f"Package `{package_name}` is available in Anaconda"
-        if version := anaconda_packages.package_latest_version(package=package):
-            msg += f". Latest available version: {version}."
-        elif versions := anaconda_packages.package_versions(package=package):
-            msg += f" in versions: {', '.join(versions)}."
-        return MessageResult(msg)
-
-    return MessageResult(
-        dedent(
-            f"""
-        Package `{package_name}` is not available in Anaconda. To prepare Snowpark compatible package run:
-        snow snowpark package create {package_name}
-        """
-        )
-    )
-
-
-@app.command("upload", requires_connection=True)
-def package_upload(
-    file: Path = typer.Option(
-        ...,
-        "--file",
-        "-f",
-        help="Path to the file to upload.",
-        exists=False,
-    ),
-    stage: str = typer.Option(
-        ...,
-        "--stage",
-        "-s",
-        help="Name of the stage in which to upload the file, not including the @ symbol.",
-    ),
-    overwrite: bool = typer.Option(
-        False,
-        "--overwrite",
-        "-o",
-        help="Overwrites the file if it already exists.",
-    ),
-    **options,
-) -> CommandResult:
-    """
-    Uploads a Python package zip file to a Snowflake stage so it can be referenced in the imports of a procedure or function.
-    """
-    return MessageResult(upload(file=file, stage=stage, overwrite=overwrite))
-
-
-deprecated_pypi_download_option = typer.Option(
-    False,
-    "--pypi-download",
-    hidden=True,
-    callback=deprecated_flag_callback(
-        "Using --pypi-download is deprecated. Create command always checks for package in PyPi."
-    ),
-    help="Installs packages that are not available on the Snowflake Anaconda channel.",
-)
-
-deprecated_install_option = typer.Option(
-    False,
-    "--yes",
-    "-y",
-    hidden=True,
-    help="Installs packages that are not available on the Snowflake Anaconda channel.",
-    callback=deprecated_flag_callback(
-        "Using --yes is deprecated. Create command always checks for package in PyPi."
-    ),
-)
-
-
-@app.command("create", requires_connection=True)
-def package_create(
-    name: str = typer.Argument(
-        ...,
-        help="Name of the package to create.",
-    ),
-    ignore_anaconda: bool = IgnoreAnacondaOption,
-    index_url: Optional[str] = IndexUrlOption,
-    skip_version_check: bool = SkipVersionCheckOption,
-    allow_shared_libraries: bool = AllowSharedLibrariesOption,
-    deprecated_allow_native_libraries: YesNoAsk = deprecated_allow_native_libraries_option(
-        "--allow-native-libraries"
-    ),
-    _deprecated_install_option: bool = deprecated_install_option,
-    _deprecated_install_packages: bool = deprecated_pypi_download_option,
-    **options,
-) -> CommandResult:
-    """
-    Creates a Python package as a zip file that can be uploaded to a stage and imported for a Snowpark Python app.
-    """
-    with SecurePath.temporary_directory() as packages_dir:
-        package = Requirement.parse(name)
-        anaconda_packages_manager = AnacondaPackagesManager()
-        download_result = download_unavailable_packages(
-            requirements=[package],
-            target_dir=packages_dir,
-            anaconda_packages=(
-                AnacondaPackages.empty()
-                if ignore_anaconda
-                else anaconda_packages_manager.find_packages_available_in_snowflake_anaconda()
-            ),
-            skip_version_check=skip_version_check,
-            pip_index_url=index_url,
-        )
-        if not download_result.succeeded:
-            raise ClickException(download_result.error_message)
-
-        # check if package was detected as available
-        package_available_in_conda = any(
-            p.line == package.line for p in download_result.anaconda_packages
-        )
-        if package_available_in_conda:
-            return MessageResult(
-                f"Package {name} is already available in Snowflake Anaconda Channel."
-            )
-
-        # The package is not in anaconda, so we have to pack it
-        log.info("Checking to see if packages have shared (.so/.dll) libraries...")
-        if detect_and_log_shared_libraries(download_result.downloaded_packages_details):
-            # TODO: yes/no/ask logic should be removed in 3.0
-            if not (
-                allow_shared_libraries
-                or resolve_allow_shared_libraries_yes_no_ask(
-                    deprecated_allow_native_libraries
-                )
-            ):
-                raise ClickException(
-                    "Some packages contain shared (.so/.dll) libraries. "
-                    "Try again with --allow-shared-libraries."
-                )
-
-        # The package is not in anaconda, so we have to pack it
-        # the package was downloaded once, pip wheel should use cache
-        zip_file = f"{get_package_name_from_pip_wheel(name, index_url=index_url)}.zip"
-        zip_dir(dest_zip=Path(zip_file), source=packages_dir.path)
-        message = dedent(
-            f"""
-        Package {zip_file} created. You can now upload it to a stage using
-        snow snowpark package upload -f {zip_file} -s <stage-name>`
-        and reference it in your procedure or function.
-        Remember to add it to imports in the procedure or function definition.
-        """
-        )
-        if download_result.anaconda_packages:
-            message += dedent(
-                f"""
-                The package {name} is successfully created, but depends on the following
-                Anaconda libraries. They need to be included in project requirements,
-                as their are not included in .zip.
-                """
-            )
-            message += "\n".join(
-                (req.line for req in download_result.anaconda_packages)
-            )
-
-        return MessageResult(message)

snowflake/cli/plugins/snowpark/package/manager.py

@@ -1,43 +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 pathlib import Path
-
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.plugins.snowpark.package.utils import prepare_app_zip
-from snowflake.cli.plugins.stage.manager import StageManager
-
-log = logging.getLogger(__name__)
-
-
-def upload(file: Path, stage: str, overwrite: bool):
-    log.info("Uploading %s to Snowflake @%s/%s...", file, stage, file)
-    with SecurePath.temporary_directory() as temp_dir:
-        temp_app_zip_path = prepare_app_zip(SecurePath(file), temp_dir)
-        sm = StageManager()
-
-        sm.create(sm.get_stage_from_path(stage))
-        put_response = sm.put(
-            temp_app_zip_path.path, stage, overwrite=overwrite
-        ).fetchone()
-
-    message = f"Package {file} {put_response[6]} to Snowflake @{stage}/{file}."
-
-    if put_response[6] == "SKIPPED":
-        message = "Package already exists on stage. Consider using --overwrite to overwrite the file."
-
-    return message

snowflake/cli/plugins/snowpark/package/utils.py

@@ -1,26 +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 snowflake.cli.api.secure_path import SecurePath
-
-
-def prepare_app_zip(file_path: SecurePath, temp_dir: SecurePath) -> SecurePath:
-    # get filename from file path (e.g. app.zip from /path/to/app.zip)
-    # TODO: think if no file exceptions are handled correctly
-    file_name = file_path.path.name
-    temp_path = temp_dir / file_name
-    file_path.copy(temp_path.path)
-    return temp_path