snowflake-cli 3.0.1__py3-none-any.whl → 3.1.0__py3-none-any.whl

snowflake/cli/_plugins/snowpark/package_utils.py

@@ -21,7 +21,6 @@ import os
 import re
 import subprocess
 from pathlib import Path
-from textwrap import dedent
 from typing import Dict, List, Optional
 
 from click import ClickException
@@ -97,6 +96,7 @@ def get_package_name_from_pip_wheel(package: str, index_url: str | None = None)
             download_dir=tmp_dir.path,
             index_url=index_url,
             dependencies=False,
+            raise_on_error=False,
         )
         file_list = [
             f.path.name for f in tmp_dir.iterdir() if f.path.name.endswith(".whl")
@@ -117,7 +117,6 @@ def _write_requirements_file(file_path: SecurePath, requirements: List[Requireme
 
 @dataclasses.dataclass
 class DownloadUnavailablePackagesResult:
-    succeeded: bool
     error_message: str | None = None
     anaconda_packages: List[Requirement] = dataclasses.field(default_factory=list)
     downloaded_packages_details: List[RequirementWithFiles] = dataclasses.field(
@@ -151,8 +150,7 @@ def download_unavailable_packages(
     if not requirements:
         # all packages are available in Snowflake
         return DownloadUnavailablePackagesResult(
-            succeeded=True,
-            anaconda_packages=packages_in_snowflake,
+            anaconda_packages=packages_in_snowflake
         )
 
     # download all packages with their dependencies
@@ -160,19 +158,14 @@ def download_unavailable_packages(
         # This is a Windows workaround where use TemporaryDirectory instead of NamedTemporaryFile
         requirements_file = downloads_dir / "requirements.txt"
         _write_requirements_file(requirements_file, requirements)  # type: ignore
-        pip_wheel_result = pip_wheel(
+        pip_wheel(
             package_name=None,
             requirements_file=requirements_file.path,  # type: ignore
             download_dir=downloads_dir.path,
             index_url=pip_index_url,
             dependencies=True,
+            raise_on_error=True,
         )
-        if pip_wheel_result != 0:
-            log.info(_pip_failed_log_msg(pip_wheel_result))
-            return DownloadUnavailablePackagesResult(
-                succeeded=False,
-                error_message=_pip_failed_log_msg(pip_wheel_result),
-            )
 
         # scan all downloaded packages and filter out ones available on Anaconda
         dependencies = split_downloaded_dependencies(
@@ -196,7 +189,6 @@ def download_unavailable_packages(
         for package in dependencies.unavailable_dependencies_wheels:
             package.extract_files(target_dir.path)
         return DownloadUnavailablePackagesResult(
-            succeeded=True,
             anaconda_packages=packages_in_snowflake,
             downloaded_packages_details=[
                 RequirementWithFiles(requirement=dep.requirement, files=dep.namelist())
@@ -211,7 +203,8 @@ def pip_wheel(
     download_dir: Path,
     index_url: Optional[str],
     dependencies: bool = True,
-):
+    raise_on_error: bool = True,
+) -> int:
     command = ["-m", "pip", "wheel", "-w", str(download_dir)]
     if package_name:
         command.append(package_name)
@@ -222,23 +215,30 @@ def pip_wheel(
     if not dependencies:
         command.append("--no-deps")
 
-    try:
+    log.info(
+        "Running pip wheel with command: %s",
+        " ".join([str(com) for com in command]),
+    )
+    result = subprocess.run(
+        ["python", *command],
+        capture_output=True,
+        text=True,
+        encoding=locale.getpreferredencoding(),
+    )
+    if result.returncode != 0:
         log.info(
-            "Running pip wheel with command: %s",
-            " ".join([str(com) for com in command]),
-        )
-        process = subprocess.run(
-            ["python", *command],
-            capture_output=True,
-            text=True,
-            encoding=locale.getpreferredencoding(),
+            "pip wheel finished with error code %d. Details: %s",
+            result.returncode,
+            result.stdout + result.stderr,
         )
-    except subprocess.CalledProcessError as e:
-        log.error("Encountered error %s", e.stderr)
-        raise ClickException(f"Encountered error while running pip wheel.")
+        if raise_on_error:
+            raise ClickException(
+                f"pip wheel finished with error code {result.returncode}. Please re-run with --verbose or --debug for more details."
+            )
+    else:
+        log.info("pip wheel command executed successfully")
 
-    log.info("Pip wheel command executed successfully")
-    return process.returncode
+    return result.returncode
 
 
 @dataclasses.dataclass
@@ -341,14 +341,3 @@ def _log_dependencies_found_in_conda(available_dependencies: List[Requirement])
         )
     else:
         log.info("None of the package dependencies were found on Anaconda")
-
-
-def _pip_failed_log_msg(return_code: int) -> str:
-    return dedent(
-        f"""
-        pip failed with return code {return_code}. Most likely reasons:
-         * incorrect package name or version
-         * package isn't compatible with host architecture (most probably due to .so libraries)
-         * pip is not installed correctly
-        """
-    )

snowflake/cli/_plugins/snowpark/snowpark_entity_model.py

@@ -147,8 +147,11 @@ class UdfSprocIdentifier:
             self._arg_names, self._arg_types, self._arg_defaults
         ):
             s = f"{name} {_type}"
-            if _default:
-                if self._is_signature_type_a_string(_type):
+            if _default is not None:
+                if (
+                    self._is_signature_type_a_string(_type)
+                    and _default.lower() != "null"
+                ):
                     _default = f"'{_default}'"
                 s += f" default {_default}"
             sig.append(s)

snowflake/cli/_plugins/spcs/image_repository/commands.py

@@ -39,6 +39,7 @@ from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
     CollectionResult,
     MessageResult,
+    QueryResult,
     SingleQueryResult,
 )
 from snowflake.cli.api.project.util import is_valid_object_name
@@ -99,44 +100,10 @@ def list_images(
     **options,
 ) -> CollectionResult:
     """Lists images in the given repository."""
-    repository_manager = ImageRepositoryManager()
-    database = repository_manager.get_database()
-    schema = repository_manager.get_schema()
-    url = repository_manager.get_repository_url(name.identifier)
-    api_url = repository_manager.get_repository_api_url(url)
-    bearer_login = RegistryManager().login_to_registry(api_url)
-    repos = []
-    query: Optional[str] = f"{api_url}/_catalog?n=10"
-
-    while query:
-        # Make paginated catalog requests
-        response = requests.get(
-            query, headers={"Authorization": f"Bearer {bearer_login}"}
-        )
-
-        if response.status_code != 200:
-            raise ClickException(f"Call to the registry failed {response.text}")
-
-        data = json.loads(response.text)
-        if "repositories" in data:
-            repos.extend(data["repositories"])
-
-        if "Link" in response.headers:
-            # There are more results
-            query = f"{api_url}/_catalog?n=10&last={repos[-1]}"
-        else:
-            query = None
-
-    images = []
-    for repo in repos:
-        prefix = f"/{database}/{schema}/{name}/"
-        repo = repo.replace("baserepo/", prefix)
-        images.append({"image": repo})
-
-    return CollectionResult(images)
+    return QueryResult(ImageRepositoryManager().list_images(name.identifier))
 
 
-@app.command("list-tags", requires_connection=True)
+@app.command("list-tags", requires_connection=True, deprecated=True)
 def list_tags(
     name: FQN = REPO_NAME_ARGUMENT,
     image_name: str = typer.Option(
@@ -149,7 +116,7 @@ def list_tags(
     ),
     **options,
 ) -> CollectionResult:
-    """Lists tags for the given image in a repository."""
+    """Lists tags for the given image in a repository. This command is deprecated and will be removed in a future release. Use `list-images` instead."""
 
     repository_manager = ImageRepositoryManager()
     url = repository_manager.get_repository_url(name.identifier)

snowflake/cli/_plugins/spcs/image_repository/manager.py

@@ -18,6 +18,7 @@ from snowflake.cli._plugins.spcs.common import handle_object_already_exists
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
 
@@ -32,7 +33,6 @@ class ImageRepositoryManager(SqlExecutionMixin):
         return self._conn.role
 
     def get_repository_url(self, repo_name: str, with_scheme: bool = True):
-
         repo_row = self.show_specific_object(
             "image repositories", repo_name, check_schema=True
         )
@@ -82,3 +82,6 @@ class ImageRepositoryManager(SqlExecutionMixin):
             handle_object_already_exists(
                 e, ObjectType.IMAGE_REPOSITORY, name, replace_available=True
             )
+
+    def list_images(self, repo_name: str) -> SnowflakeCursor:
+        return self._execute_query(f"show images in image repository {repo_name}")

snowflake/cli/_plugins/spcs/services/commands.py

@@ -131,7 +131,7 @@ def create(
     external_access_integrations: Optional[List[str]] = typer.Option(
         None,
         "--eai-name",
-        help="Identifies External Access Integrations(EAI) that the service can access. This option may be specified multiple times for multiple EAIs.",
+        help="Identifies external access integrations (EAI) that the service can access. This option may be specified multiple times for multiple EAIs.",
     ),
     query_warehouse: Optional[str] = QueryWarehouseOption(),
     tags: Optional[List[Tag]] = TagOption(help="Tag for the service."),
@@ -174,7 +174,7 @@ def execute_job(
     external_access_integrations: Optional[List[str]] = typer.Option(
         None,
         "--eai-name",
-        help="Identifies External Access Integrations(EAI) that the job service can access. This option may be specified multiple times for multiple EAIs.",
+        help="Identifies external access integrations (EAI) that the job service can access. This option may be specified multiple times for multiple EAIs.",
     ),
     query_warehouse: Optional[str] = QueryWarehouseOption(),
     comment: Optional[str] = CommentOption(help=_COMMENT_HELP),
@@ -194,10 +194,10 @@ def execute_job(
     return SingleQueryResult(cursor)
 
 
-@app.command(requires_connection=True)
+@app.command(requires_connection=True, deprecated=True)
 def status(name: FQN = ServiceNameArgument, **options) -> CommandResult:
     """
-    Retrieves the status of a service.
+    Retrieves the status of a service. This command is deprecated and will be removed in a future release. Use `describe` instead to get service status and use `list-instances` and `list-containers` to get more detailed information about service instances and containers.
     """
     cursor = ServiceManager().status(service_name=name.identifier)
     return QueryJsonValueResult(cursor)
@@ -259,6 +259,32 @@ def list_endpoints(name: FQN = ServiceNameArgument, **options):
     return QueryResult(ServiceManager().list_endpoints(service_name=name.identifier))
 
 
+@app.command("list-instances", requires_connection=True)
+def list_service_instances(name: FQN = ServiceNameArgument, **options) -> CommandResult:
+    """
+    Lists all service instances in a service.
+    """
+    return QueryResult(ServiceManager().list_instances(service_name=name.identifier))
+
+
+@app.command("list-containers", requires_connection=True)
+def list_service_containers(
+    name: FQN = ServiceNameArgument, **options
+) -> CommandResult:
+    """
+    Lists all service containers in a service.
+    """
+    return QueryResult(ServiceManager().list_containers(service_name=name.identifier))
+
+
+@app.command("list-roles", requires_connection=True)
+def list_service_roles(name: FQN = ServiceNameArgument, **options) -> CommandResult:
+    """
+    Lists all service roles in a service.
+    """
+    return QueryResult(ServiceManager().list_roles(service_name=name.identifier))
+
+
 @app.command(requires_connection=True)
 def suspend(name: FQN = ServiceNameArgument, **options) -> CommandResult:
     """
@@ -282,6 +308,11 @@ def set_property(
     max_instances: Optional[int] = MaxInstancesOption(show_default=False),
     query_warehouse: Optional[str] = QueryWarehouseOption(show_default=False),
     auto_resume: Optional[bool] = AutoResumeOption(default=None, show_default=False),
+    external_access_integrations: Optional[List[str]] = typer.Option(
+        None,
+        "--eai-name",
+        help="Identifies external access integrations (EAI) that the service can access. This option may be specified multiple times for multiple EAIs.",
+    ),
     comment: Optional[str] = CommentOption(help=_COMMENT_HELP, show_default=False),
     **options,
 ):
@@ -294,6 +325,7 @@ def set_property(
         max_instances=max_instances,
         query_warehouse=query_warehouse,
         auto_resume=auto_resume,
+        external_access_integrations=external_access_integrations,
         comment=comment,
     )
     return SingleQueryResult(cursor)

snowflake/cli/_plugins/spcs/services/manager.py

@@ -147,6 +147,15 @@ class ServiceManager(SqlExecutionMixin):
     def list_endpoints(self, service_name: str) -> SnowflakeCursor:
         return self._execute_query(f"show endpoints in service {service_name}")
 
+    def list_instances(self, service_name: str) -> SnowflakeCursor:
+        return self._execute_query(f"show service instances in service {service_name}")
+
+    def list_containers(self, service_name: str) -> SnowflakeCursor:
+        return self._execute_query(f"show service containers in service {service_name}")
+
+    def list_roles(self, service_name: str) -> SnowflakeCursor:
+        return self._execute_query(f"show roles in service {service_name}")
+
     def suspend(self, service_name: str):
         return self._execute_query(f"alter service {service_name} suspend")
 
@@ -160,6 +169,7 @@ class ServiceManager(SqlExecutionMixin):
         max_instances: Optional[int],
         query_warehouse: Optional[str],
         auto_resume: Optional[bool],
+        external_access_integrations: Optional[List[str]],
         comment: Optional[str],
     ):
         property_pairs = [
@@ -167,6 +177,7 @@ class ServiceManager(SqlExecutionMixin):
             ("max_instances", max_instances),
             ("query_warehouse", query_warehouse),
             ("auto_resume", auto_resume),
+            ("external_access_integrations", external_access_integrations),
             ("comment", comment),
         ]
 
@@ -175,10 +186,31 @@ class ServiceManager(SqlExecutionMixin):
             raise NoPropertiesProvidedError(
                 f"No properties specified for service '{service_name}'. Please provide at least one property to set."
             )
-        query: List[str] = [f"alter service {service_name} set"]
-        for property_name, value in property_pairs:
-            if value is not None:
-                query.append(f"{property_name} = {value}")
+        query: List[str] = [f"alter service {service_name} set "]
+
+        if min_instances is not None:
+            query.append(f" min_instances = {min_instances}")
+
+        if max_instances is not None:
+            query.append(f" max_instances = {max_instances}")
+
+        if query_warehouse is not None:
+            query.append(f" query_warehouse = {query_warehouse}")
+
+        if auto_resume is not None:
+            query.append(f" auto_resume = {auto_resume}")
+
+        if external_access_integrations is not None:
+            external_access_integration_list = ",".join(
+                f"{e}" for e in external_access_integrations
+            )
+            query.append(
+                f"external_access_integrations = ({external_access_integration_list})"
+            )
+
+        if comment is not None:
+            query.append(f" comment = {comment}")
+
         return self._execute_query(strip_empty_lines(query))
 
     def unset_property(

snowflake/cli/_plugins/stage/commands.py

@@ -38,6 +38,7 @@ from snowflake.cli.api.commands.flags import (
     OnErrorOption,
     PatternOption,
     identifier_stage_argument,
+    identifier_stage_path_argument,
     like_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
@@ -60,6 +61,10 @@ app = SnowTyperFactory(
 )
 
 StageNameArgument = identifier_stage_argument(sf_object="stage", example="@my_stage")
+StagePathArgument = identifier_stage_path_argument(
+    sf_object="stage", example="@my_stage/path"
+)
+
 
 add_object_command_aliases(
     app=app,
@@ -74,7 +79,7 @@ add_object_command_aliases(
 
 @app.command("list-files", requires_connection=True)
 def stage_list_files(
-    stage_name: str = StageNameArgument, pattern=PatternOption, **options
+    stage_name: str = StagePathArgument, pattern=PatternOption, **options
 ) -> CommandResult:
     """
     Lists the stage contents.
@@ -208,11 +213,11 @@ def execute(
     **options,
 ):
     """
-    Execute immediate all files from the stage path. Files can be filtered with glob like pattern,
+    Execute immediate all files from the stage path. Files can be filtered with a glob-like pattern,
     e.g. `@stage/*.sql`, `@stage/dev/*`. Only files with `.sql` extension will be executed.
     """
     results = StageManager().execute(
-        stage_path=stage_path, on_error=on_error, variables=variables
+        stage_path_str=stage_path, on_error=on_error, variables=variables
     )
     return CollectionResult(results)
 

snowflake/cli/_plugins/stage/diff.py

@@ -30,7 +30,7 @@ from .md5 import UnknownMD5FormatError, file_matches_md5sum
 
 log = logging.getLogger(__name__)
 
-StagePath = PurePosixPath  # alias PurePosixPath as StagePath for clarity
+StagePathType = PurePosixPath  # alias PurePosixPath as StagePath for clarity
 
 
 @dataclass
@@ -39,16 +39,16 @@ class DiffResult:
     Each collection is a list of stage paths ('/'-separated, regardless of the platform), relative to the stage root.
     """
 
-    identical: List[StagePath] = field(default_factory=list)
+    identical: List[StagePathType] = field(default_factory=list)
     "Files with matching md5sums"
 
-    different: List[StagePath] = field(default_factory=list)
+    different: List[StagePathType] = field(default_factory=list)
     "Files that may be different between the stage and the local directory"
 
-    only_local: List[StagePath] = field(default_factory=list)
+    only_local: List[StagePathType] = field(default_factory=list)
     "Files that only exist in the local directory"
 
-    only_on_stage: List[StagePath] = field(default_factory=list)
+    only_on_stage: List[StagePathType] = field(default_factory=list)
     "Files that only exist on the stage"
 
     def has_changes(self) -> bool:
@@ -83,12 +83,12 @@ def enumerate_files(path: Path) -> List[Path]:
     return paths
 
 
-def strip_stage_name(path: str) -> StagePath:
+def strip_stage_name(path: str) -> StagePathType:
     """Returns the given stage path without the stage name as the first part."""
-    return StagePath(*path.split("/")[1:])
+    return StagePathType(*path.split("/")[1:])
 
 
-def build_md5_map(list_stage_cursor: DictCursor) -> Dict[StagePath, Optional[str]]:
+def build_md5_map(list_stage_cursor: DictCursor) -> Dict[StagePathType, Optional[str]]:
     """
     Returns a mapping of relative stage paths to their md5sums.
     """
@@ -99,7 +99,7 @@ def build_md5_map(list_stage_cursor: DictCursor) -> Dict[StagePath, Optional[str
 
 
 def preserve_from_diff(
-    diff: DiffResult, stage_paths_to_sync: Collection[StagePath]
+    diff: DiffResult, stage_paths_to_sync: Collection[StagePathType]
 ) -> DiffResult:
     """
     Returns a filtered version of the provided diff, keeping only the provided stage paths.
@@ -163,7 +163,7 @@ def compute_stage_diff(
     return result
 
 
-def get_stage_subpath(stage_path: StagePath) -> str:
+def get_stage_subpath(stage_path: StagePathType) -> str:
     """
     Returns the parent portion of a stage path, as a string, for inclusion in the fully qualified stage path. Note that
     '.' treated specially here, and so the return value of this call is not a `StagePath` instance.
@@ -172,21 +172,21 @@ def get_stage_subpath(stage_path: StagePath) -> str:
     return "" if parent == "." else parent
 
 
-def to_stage_path(filename: Path) -> StagePath:
+def to_stage_path(filename: Path) -> StagePathType:
     """
     Returns the stage file name, with the path separator suitably transformed if needed.
     """
-    return StagePath(*filename.parts)
+    return StagePathType(*filename.parts)
 
 
-def to_local_path(stage_path: StagePath) -> Path:
+def to_local_path(stage_path: StagePathType) -> Path:
     return Path(*stage_path.parts)
 
 
 def delete_only_on_stage_files(
     stage_manager: StageManager,
     stage_fqn: str,
-    only_on_stage: List[StagePath],
+    only_on_stage: List[StagePathType],
     role: Optional[str] = None,
 ):
     """
@@ -200,7 +200,7 @@ def put_files_on_stage(
     stage_manager: StageManager,
     stage_fqn: str,
     deploy_root_path: Path,
-    stage_paths: List[StagePath],
+    stage_paths: List[StagePathType],
     role: Optional[str] = None,
     overwrite: bool = False,
 ):
@@ -254,7 +254,7 @@ def sync_local_diff_with_stage(
 
 
 def _to_src_dest_pair(
-    stage_path: StagePath, bundle_map: Optional[BundleMap]
+    stage_path: StagePathType, bundle_map: Optional[BundleMap]
 ) -> Tuple[Optional[str], str]:
     if not bundle_map:
         return None, str(stage_path)