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

snowflake/cli/_plugins/snowpark/snowpark_entity_model.py

@@ -1,173 +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 List, Literal, Optional, Union
-
-from pydantic import Field, field_validator
-from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.schemas.entities.common import (
-    EntityModelBase,
-    ExternalAccessBaseModel,
-    ImportsBaseModel,
-)
-from snowflake.cli.api.project.schemas.updatable_model import (
-    DiscriminatorField,
-    UpdatableModel,
-)
-from snowflake.cli.api.project.schemas.v1.snowpark.argument import Argument
-
-
-class PathMapping(UpdatableModel):
-    class Config:
-        frozen = True
-
-    src: Path = Field(title="Source path (relative to project root)", default=None)
-
-    dest: Optional[str] = Field(
-        title="Destination path on stage",
-        description="Paths are relative to stage root; paths ending with a slash indicate that the destination is a directory which source files should be copied into.",
-        default=None,
-    )
-
-
-class SnowparkEntityModel(EntityModelBase, ExternalAccessBaseModel, ImportsBaseModel):
-    handler: str = Field(
-        title="Function’s or procedure’s implementation of the object inside source module",
-        examples=["functions.hello_function"],
-    )
-    returns: str = Field(
-        title="Type of the result"
-    )  # TODO: again, consider Literal/Enum
-    signature: Union[str, List[Argument]] = Field(
-        title="The signature parameter describes consecutive arguments passed to the object"
-    )
-    runtime: Optional[Union[str, float]] = Field(
-        title="Python version to use when executing ", default=None
-    )
-    stage: str = Field(title="Stage in which artifacts will be stored")
-    artifacts: List[Union[PathMapping, str]] = Field(title="List of required sources")
-
-    @field_validator("artifacts")
-    @classmethod
-    def _convert_artifacts(cls, artifacts: Union[dict, str]):
-        _artifacts = []
-        for artefact in artifacts:
-            if isinstance(artefact, PathMapping):
-                _artifacts.append(artefact)
-            else:
-                _artifacts.append(PathMapping(src=artefact))
-        return _artifacts
-
-    @field_validator("runtime")
-    @classmethod
-    def convert_runtime(cls, runtime_input: Union[str, float]) -> str:
-        if isinstance(runtime_input, float):
-            return str(runtime_input)
-        return runtime_input
-
-    @field_validator("artifacts")
-    @classmethod
-    def validate_artifacts(cls, artifacts: List[Path]) -> List[Path]:
-        for artefact in artifacts:
-            if "*" in str(artefact):
-                raise ValueError("Glob patterns not supported for Snowpark artifacts.")
-        return artifacts
-
-    @property
-    def udf_sproc_identifier(self) -> UdfSprocIdentifier:
-        return UdfSprocIdentifier.from_definition(self)
-
-
-class ProcedureEntityModel(SnowparkEntityModel):
-    type: Literal["procedure"] = DiscriminatorField()  # noqa: A003
-    execute_as_caller: Optional[bool] = Field(
-        title="Determine whether the procedure is executed with the privileges of "
-        "the owner (you) or with the privileges of the caller",
-        default=False,
-    )
-
-
-class FunctionEntityModel(SnowparkEntityModel):
-    type: Literal["function"] = DiscriminatorField()  # noqa: A003
-
-
-class UdfSprocIdentifier:
-    def __init__(self, identifier: FQN, arg_names, arg_types, arg_defaults):
-        self._identifier = identifier
-        self._arg_names = arg_names
-        self._arg_types = arg_types
-        self._arg_defaults = arg_defaults
-
-    def _identifier_from_signature(self, sig: List[str], for_sql: bool = False):
-        signature = self._comma_join(sig)
-        id_ = self._identifier.sql_identifier if for_sql else self._identifier
-        return f"{id_}({signature})"
-
-    @staticmethod
-    def _comma_join(*args):
-        return ", ".join(*args)
-
-    @property
-    def identifier_with_arg_names(self):
-        return self._identifier_from_signature(self._arg_names)
-
-    @property
-    def identifier_with_arg_types(self):
-        return self._identifier_from_signature(self._arg_types)
-
-    @property
-    def identifier_with_arg_names_types(self):
-        sig = [f"{n} {t}" for n, t in zip(self._arg_names, self._arg_types)]
-        return self._identifier_from_signature(sig)
-
-    @property
-    def identifier_with_arg_names_types_defaults(self):
-        return self._identifier_from_signature(self._full_signature())
-
-    def _is_signature_type_a_string(self, sig_type: str) -> bool:
-        return sig_type.lower() in ["string", "varchar"]
-
-    def _full_signature(self):
-        sig = []
-        for name, _type, _default in zip(
-            self._arg_names, self._arg_types, self._arg_defaults
-        ):
-            s = f"{name} {_type}"
-            if _default:
-                if self._is_signature_type_a_string(_type):
-                    _default = f"'{_default}'"
-                s += f" default {_default}"
-            sig.append(s)
-        return sig
-
-    @property
-    def identifier_for_sql(self):
-        return self._identifier_from_signature(self._full_signature(), for_sql=True)
-
-    @classmethod
-    def from_definition(cls, udf_sproc: SnowparkEntityModel):
-        names = []
-        types = []
-        defaults = []
-        if udf_sproc.signature and udf_sproc.signature != "null":
-            for arg in udf_sproc.signature:
-                names.append(arg.name)  # type:ignore
-                types.append(arg.arg_type)  # type:ignore
-                defaults.append(arg.default)  # type:ignore
-
-        identifier = udf_sproc.fqn.using_context()
-        return cls(identifier, names, types, defaults)

snowflake/cli/_plugins/snowpark/snowpark_project_paths.py

@@ -1,109 +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 dataclasses import dataclass
-from pathlib import Path, PurePosixPath
-
-from snowflake.cli._plugins.snowpark.snowpark_entity_model import PathMapping
-from snowflake.cli._plugins.snowpark.zipper import zip_dir
-from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.constants import DEPLOYMENT_STAGE
-from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.secure_path import SecurePath
-
-
-@dataclass
-class SnowparkProjectPaths:
-    """
-    This class represents allows you to manage files paths related to given project.
-    """
-
-    project_root: Path
-
-    def path_relative_to_root(self, artifact_path: Path) -> Path:
-        if artifact_path.is_absolute():
-            return artifact_path
-        return (self.project_root / artifact_path).resolve()
-
-    def get_artefact_dto(self, artifact_path: PathMapping) -> Artefact:
-        return Artefact(
-            dest=artifact_path.dest,
-            path=self.path_relative_to_root(artifact_path.src),
-        )
-
-    def get_dependencies_artefact(self) -> Artefact:
-        return Artefact(dest=None, path=self.dependencies)
-
-    @property
-    def snowflake_requirements(self) -> SecurePath:
-        return SecurePath(
-            self.path_relative_to_root(Path("requirements.snowflake.txt"))
-        )
-
-    @property
-    def requirements(self) -> SecurePath:
-        return SecurePath(self.path_relative_to_root(Path("requirements.txt")))
-
-    @property
-    def dependencies(self) -> Path:
-        return self.path_relative_to_root(Path("dependencies.zip"))
-
-
-@dataclass(unsafe_hash=True)
-class Artefact:
-    """Helper for getting paths related to given artefact."""
-
-    path: Path
-    dest: str | None = None
-
-    @property
-    def _artefact_name(self) -> str:
-        if self.path.is_dir():
-            return self.path.stem + ".zip"
-        return self.path.name
-
-    @property
-    def post_build_path(self) -> Path:
-        """
-        Returns post-build artefact path. Directories are mapped to corresponding .zip files.
-        """
-        return self.path.parent / self._artefact_name
-
-    def upload_path(self, stage: FQN | str | None) -> str:
-        """
-        Path on stage to which the artefact should be uploaded.
-        """
-        stage = stage or DEPLOYMENT_STAGE
-        if isinstance(stage, str):
-            stage = FQN.from_stage(stage).using_context()
-
-        stage_path = PurePosixPath(f"@{stage}")
-        if self.dest:
-            stage_path = stage_path / self.dest
-        return str(stage_path) + "/"
-
-    def import_path(self, stage: FQN | str | None) -> str:
-        """Path for UDF/sproc imports clause."""
-        return self.upload_path(stage) + self._artefact_name
-
-    def build(self) -> None:
-        """Build the artefact. Applies only to directories. Files are untouched."""
-        if not self.path.is_dir():
-            return
-        cli_console.step(f"Creating: {self.post_build_path.name}")
-        zip_dir(
-            source=self.path,
-            dest_zip=self.post_build_path,
-        )

snowflake/cli/_plugins/snowpark/snowpark_shared.py

@@ -1,59 +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 typer
-
-AllowSharedLibrariesOption: bool = typer.Option(
-    False,
-    "--allow-shared-libraries",
-    help="Allows shared (.so) libraries, when using packages installed through PIP.",
-)
-
-
-IgnoreAnacondaOption: bool = typer.Option(
-    False,
-    "--ignore-anaconda",
-    help="Does not lookup packages on Snowflake Anaconda channel.",
-)
-
-SkipVersionCheckOption: bool = typer.Option(
-    False,
-    "--skip-version-check",
-    help="Skip comparing versions of dependencies between requirements and Anaconda.",
-)
-
-IndexUrlOption: str | None = typer.Option(
-    None,
-    "--index-url",
-    help="Base URL of the Python Package Index to use for package lookup. This should point to "
-    " a repository compliant with PEP 503 (the simple repository API) or a local directory laid"
-    " out in the same format.",
-    show_default=False,
-)
-
-ReturnsOption: str = typer.Option(
-    ...,
-    "--returns",
-    "-r",
-    help="Data type for the procedure to return.",
-)
-
-OverwriteOption: bool = typer.Option(
-    False,
-    "--overwrite",
-    "-o",
-    help="Replaces an existing procedure with this one.",
-)

snowflake/cli/_plugins/snowpark/zipper.py

@@ -1,89 +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 fnmatch
-import logging
-from pathlib import Path
-from typing import Dict, List, Literal
-from zipfile import ZIP_DEFLATED, ZipFile
-
-log = logging.getLogger(__name__)
-
-IGNORED_FILES = [
-    "**/.DS_Store",
-    "**/.git",
-    "**/.git/*",
-    "**/.gitignore",
-    "**/.env",
-    "**/.env/*",
-    "**/.venv",
-    "**/.venv/*",
-    "**/__pycache__",
-    "**/*.zip",
-    "**/*.pyc",
-    "**/env",
-    "**/env/*",
-    "**/ENV",
-    "**/ENV/*",
-    "**/venv",
-    "**/venv/*",
-    "**/requirements.txt",
-    "**/requirements.snowflake.txt",
-    "**/requirements.other.txt",
-    "**/snowflake.yml",
-]
-
-
-def add_file_to_existing_zip(zip_file: str, file: str):
-    """Adds another file to an existing zip file
-
-    Args:
-        zip_file (str): The existing zip file
-        file (str): The new file to add
-    """
-    with ZipFile(zip_file, mode="a") as myzip:
-        myzip.write(file, Path(file).name)
-
-
-def zip_dir(
-    source: Path | List[Path],
-    dest_zip: Path,
-    mode: Literal["r", "w", "x", "a"] = "w",
-) -> None:
-
-    if isinstance(source, Path):
-        source = [source]
-
-    files_to_pack: Dict[Path, List[Path]] = {
-        src: list(filter(_to_be_zipped, (f.absolute() for f in src.glob("**/*"))))
-        for src in source
-    }
-
-    with ZipFile(dest_zip, mode, ZIP_DEFLATED, allowZip64=True) as package_zip:
-        for src, files in files_to_pack.items():
-            for file in files:
-                log.debug("Adding %s to %s", file, dest_zip)
-                package_zip.write(file, arcname=file.relative_to(src))
-
-
-def _to_be_zipped(file: Path) -> bool:
-    for pattern in IGNORED_FILES:
-        # This has to be a string because of fnmatch
-        file_as_str = str(file)
-        if file_as_str == pattern or fnmatch.fnmatch(file_as_str, pattern):
-            return False
-
-    return True

snowflake/cli/_plugins/spcs/__init__.py

@@ -1,33 +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._plugins.spcs.compute_pool.commands import (
-    app as compute_pools_app,
-)
-from snowflake.cli._plugins.spcs.image_registry.commands import app as registry_app
-from snowflake.cli._plugins.spcs.image_repository.commands import (
-    app as image_repository_app,
-)
-from snowflake.cli._plugins.spcs.services.commands import app as services_app
-from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-
-app = SnowTyperFactory(
-    name="spcs",
-    help="Manages Snowpark Container Services compute pools, services, image registries, and image repositories.",
-)
-
-app.add_typer(compute_pools_app)
-app.add_typer(services_app)
-app.add_typer(registry_app)
-app.add_typer(image_repository_app)

snowflake/cli/_plugins/spcs/common.py

@@ -1,99 +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 sys
-from typing import TextIO
-
-from click import ClickException
-from snowflake.cli.api.constants import ObjectType
-from snowflake.cli.api.exceptions import ObjectAlreadyExistsError
-from snowflake.cli.api.project.util import unquote_identifier
-from snowflake.connector.errors import ProgrammingError
-
-if not sys.stdout.closed and sys.stdout.isatty():
-    GREEN = "\033[32m"
-    BLUE = "\033[34m"
-    ORANGE = "\033[38:2:238:76:44m"
-    GRAY = "\033[2m"
-    ENDC = "\033[0m"
-else:
-    GREEN = ""
-    ORANGE = ""
-    BLUE = ""
-    GRAY = ""
-    ENDC = ""
-
-
-def _prefix_line(prefix: str, line: str) -> str:
-    """
-    _prefix_line ensure the prefix is still present even when dealing with return characters
-    """
-    if "\r" in line:
-        line = line.replace("\r", f"\r{prefix}")
-    if "\n" in line[:-1]:
-        line = line[:-1].replace("\n", f"\n{prefix}") + line[-1:]
-    if not line.startswith("\r"):
-        line = f"{prefix}{line}"
-    return line
-
-
-def print_log_lines(file: TextIO, name, identifier, logs):
-    prefix = f"{GREEN}{name}/{identifier}{ENDC} "
-    logs = logs[0:-1]
-    for log in logs:
-        print(_prefix_line(prefix, log + "\n"), file=file, end="", flush=True)
-
-
-def strip_empty_lines(lines: list[str]) -> str:
-    return "\n".join(stripped for l in lines if (stripped := l.strip()))
-
-
-def validate_and_set_instances(min_instances, max_instances, instance_name):
-    """
-    Used to validate that min_instances is positive and that max_instances is not less than min_instances. In the
-    case that max_instances is none, sets it equal to min_instances by default. Used like `max_instances =
-    validate_and_set_instances(min_instances, max_instances, "name")`.
-    """
-    if min_instances < 1:
-        raise ClickException(f"min_{instance_name} must be positive")
-
-    if max_instances is None:
-        max_instances = min_instances
-    elif max_instances < min_instances:
-        raise ClickException(
-            f"max_{instance_name} must be greater or equal to min_{instance_name}"
-        )
-    return max_instances
-
-
-def handle_object_already_exists(
-    error: ProgrammingError,
-    object_type: ObjectType,
-    object_name: str,
-    replace_available: bool = False,
-):
-    if error.errno == 2002:
-        raise ObjectAlreadyExistsError(
-            object_type=object_type,
-            name=unquote_identifier(object_name),
-            replace_available=replace_available,
-        )
-    else:
-        raise error
-
-
-class NoPropertiesProvidedError(ClickException):
-    pass

snowflake/cli/_plugins/spcs/compute_pool/__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.