snowflake-cli-labs 3.0.0rc0__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/teardown_processor.py

@@ -15,273 +15,44 @@
 from __future__ import annotations
 
 from pathlib import Path
-from textwrap import dedent
 from typing import Dict, Optional
 
-import typer
-from snowflake.cli._plugins.nativeapp.constants import (
-    ALLOWED_SPECIAL_COMMENTS,
-    COMMENT_COL,
-    EXTERNAL_DISTRIBUTION,
-    INTERNAL_DISTRIBUTION,
-    OWNER_COL,
-)
-from snowflake.cli._plugins.nativeapp.exceptions import (
-    CouldNotDropApplicationPackageWithVersions,
-)
 from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
 )
-from snowflake.cli._plugins.nativeapp.utils import (
-    needs_confirmation,
-)
 from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.entities.utils import ensure_correct_owner
-from snowflake.cli.api.errno import APPLICATION_NO_LONGER_AVAILABLE
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor
+from snowflake.cli.api.entities.application_entity import (
+    ApplicationEntity,
+)
+from snowflake.cli.api.entities.application_package_entity import (
+    ApplicationPackageEntity,
+)
 
 
 class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
     def __init__(self, project_definition: Dict, project_root: Path):
         super().__init__(project_definition, project_root)
 
-    def drop_generic_object(
-        self, object_type: str, object_name: str, role: str, cascade: bool = False
-    ):
-        """
-        Drop object using the given role.
-        """
-        with self.use_role(role):
-            cc.step(f"Dropping {object_type} {object_name} now.")
-            drop_query = f"drop {object_type} {object_name}"
-            if cascade:
-                drop_query += " cascade"
-            try:
-                self._execute_query(drop_query)
-            except:
-                raise SnowflakeSQLExecutionError(drop_query)
-
-            cc.message(f"Dropped {object_type} {object_name} successfully.")
-
     def drop_application(
         self, auto_yes: bool, interactive: bool = False, cascade: Optional[bool] = None
     ):
-        """
-        Attempts to drop the application object if all validations and user prompts allow so.
-        """
-
-        needs_confirm = True
-
-        # 1. If existing application is not found, exit gracefully
-        show_obj_row = self.get_existing_app_info()
-        if show_obj_row is None:
-            cc.warning(
-                f"Role {self.app_role} does not own any application object with the name {self.app_name}, or the application object does not exist."
-            )
-            return
-
-        # 2. Check for the right owner
-        ensure_correct_owner(
-            row=show_obj_row, role=self.app_role, obj_name=self.app_name
-        )
-
-        # 3. Check if created by the Snowflake CLI
-        row_comment = show_obj_row[COMMENT_COL]
-        if row_comment not in ALLOWED_SPECIAL_COMMENTS and needs_confirmation(
-            needs_confirm, auto_yes
-        ):
-            should_drop_object = typer.confirm(
-                dedent(
-                    f"""\
-                        Application object {self.app_name} was not created by Snowflake CLI.
-                        Application object details:
-                        Name: {self.app_name}
-                        Created on: {show_obj_row["created_on"]}
-                        Source: {show_obj_row["source"]}
-                        Owner: {show_obj_row[OWNER_COL]}
-                        Comment: {show_obj_row[COMMENT_COL]}
-                        Version: {show_obj_row["version"]}
-                        Patch: {show_obj_row["patch"]}
-                        Are you sure you want to drop it?
-                    """
-                )
-            )
-            if not should_drop_object:
-                cc.message(f"Did not drop application object {self.app_name}.")
-                # The user desires to keep the app, therefore we can't proceed since it would
-                # leave behind an orphan app when we get to dropping the package
-                raise typer.Abort()
-
-        # 4. Check for application objects owned by the application
-        # This query will fail if the application package has already been dropped, so handle this case gracefully
-        has_objects_to_drop = False
-        message_prefix = ""
-        cascade_true_message = ""
-        cascade_false_message = ""
-        interactive_prompt = ""
-        non_interactive_abort = ""
-        try:
-            if application_objects := self.get_objects_owned_by_application():
-                has_objects_to_drop = True
-                message_prefix = (
-                    f"The following objects are owned by application {self.app_name}"
-                )
-                cascade_true_message = f"{message_prefix} and will be dropped:"
-                cascade_false_message = f"{message_prefix} and will NOT be dropped:"
-                interactive_prompt = "Would you like to drop these objects in addition to the application? [y/n/ABORT]"
-                non_interactive_abort = "Re-run teardown again with --cascade or --no-cascade to specify whether these objects should be dropped along with the application"
-        except ProgrammingError as e:
-            if e.errno != APPLICATION_NO_LONGER_AVAILABLE:
-                raise
-            application_objects = []
-            message_prefix = f"Could not determine which objects are owned by application {self.app_name}"
-            has_objects_to_drop = True  # potentially, but we don't know what they are
-            cascade_true_message = (
-                f"{message_prefix}, an unknown number of objects will be dropped."
-            )
-            cascade_false_message = f"{message_prefix}, they will NOT be dropped."
-            interactive_prompt = f"Would you like to drop an unknown set of objects in addition to the application? [y/n/ABORT]"
-            non_interactive_abort = f"Re-run teardown again with --cascade or --no-cascade to specify whether any objects should be dropped along with the application."
-
-        if has_objects_to_drop:
-            if cascade is True:
-                # If the user explicitly passed the --cascade flag
-                cc.message(cascade_true_message)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-            elif cascade is False:
-                # If the user explicitly passed the --no-cascade flag
-                cc.message(cascade_false_message)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-            elif interactive:
-                # If the user didn't pass any cascade flag and the session is interactive
-                cc.message(message_prefix)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-                user_response = typer.prompt(
-                    interactive_prompt,
-                    show_default=False,
-                    default="ABORT",
-                ).lower()
-                if user_response in ["y", "yes"]:
-                    cascade = True
-                elif user_response in ["n", "no"]:
-                    cascade = False
-                else:
-                    raise typer.Abort()
-            else:
-                # Else abort since we don't know what to do and can't ask the user
-                cc.message(message_prefix)
-                with cc.indented():
-                    for obj in application_objects:
-                        cc.message(self._application_object_to_str(obj))
-                cc.message(non_interactive_abort)
-                raise typer.Abort()
-        elif cascade is None:
-            # If there's nothing to drop, set cascade to an explicit False value
-            cascade = False
-
-        # 5. All validations have passed, drop object
-        self.drop_generic_object(
-            object_type="application",
-            object_name=self.app_name,
-            role=self.app_role,
+        return ApplicationEntity.drop(
+            console=cc,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            auto_yes=auto_yes,
+            interactive=interactive,
             cascade=cascade,
         )
-        return  # The application object was successfully dropped, therefore exit gracefully
 
     def drop_package(self, auto_yes: bool):
-        """
-        Attempts to drop application package unless user specifies otherwise.
-        """
-        needs_confirm = True
-
-        # 1. If existing application package is not found, exit gracefully
-        show_obj_row = self.get_existing_app_pkg_info()
-        if show_obj_row is None:
-            cc.warning(
-                f"Role {self.package_role} does not own any application package with the name {self.package_name}, or the application package does not exist."
-            )
-            return
-
-        # 2. Check for the right owner
-        ensure_correct_owner(
-            row=show_obj_row, role=self.package_role, obj_name=self.package_name
-        )
-
-        with self.use_role(self.package_role):
-            # 3. Check for versions in the application package
-            show_versions_query = (
-                f"show versions in application package {self.package_name}"
-            )
-            show_versions_cursor = self._execute_query(
-                show_versions_query, cursor_class=DictCursor
-            )
-            if show_versions_cursor.rowcount is None:
-                raise SnowflakeSQLExecutionError(show_versions_query)
-
-            if show_versions_cursor.rowcount > 0:
-                # allow dropping a package with versions when --force is set
-                if not auto_yes:
-                    raise CouldNotDropApplicationPackageWithVersions(
-                        "Drop versions first, or use --force to override."
-                    )
-
-        # 4. Check distribution of the existing application package
-        actual_distribution = self.get_app_pkg_distribution_in_snowflake
-        if not self.verify_project_distribution(actual_distribution):
-            cc.warning(
-                f"Continuing to execute `snow app teardown` on application package {self.package_name} with distribution '{actual_distribution}'."
-            )
-
-        # 5. If distribution is internal, check if created by the Snowflake CLI
-        row_comment = show_obj_row[COMMENT_COL]
-        if actual_distribution == INTERNAL_DISTRIBUTION:
-            if row_comment in ALLOWED_SPECIAL_COMMENTS:
-                needs_confirm = False
-            else:
-                if needs_confirmation(needs_confirm, auto_yes):
-                    cc.warning(
-                        f"Application package {self.package_name} was not created by Snowflake CLI."
-                    )
-        else:
-            if needs_confirmation(needs_confirm, auto_yes):
-                cc.warning(
-                    f"Application package {self.package_name} in your Snowflake account has distribution property '{EXTERNAL_DISTRIBUTION}' and could be associated with one or more of your listings on Snowflake Marketplace."
-                )
-
-        if needs_confirmation(needs_confirm, auto_yes):
-            should_drop_object = typer.confirm(
-                dedent(
-                    f"""\
-                        Application package details:
-                        Name: {self.app_name}
-                        Created on: {show_obj_row["created_on"]}
-                        Distribution: {actual_distribution}
-                        Owner: {show_obj_row[OWNER_COL]}
-                        Comment: {show_obj_row[COMMENT_COL]}
-                        Are you sure you want to drop it?
-                    """
-                )
-            )
-            if not should_drop_object:
-                cc.message(f"Did not drop application package {self.package_name}.")
-                return  # The user desires to keep the application package, therefore exit gracefully
-
-        # All validations have passed, drop object
-        self.drop_generic_object(
-            object_type="application package",
-            object_name=self.package_name,
-            role=self.package_role,
+        return ApplicationPackageEntity.drop(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            force_drop=auto_yes,
         )
-        return  # The application package was successfully dropped, therefore exit gracefully
 
     def process(
         self,

snowflake/cli/_plugins/nativeapp/v2_conversions/v2_to_v1_decorator.py

@@ -14,14 +14,17 @@
 
 from __future__ import annotations
 
+import inspect
 from functools import wraps
 from typing import Any, Dict, Optional, Union
 
+import typer
 from click import ClickException
 from snowflake.cli.api.cli_global_context import (
     get_cli_context,
     get_cli_context_manager,
 )
+from snowflake.cli.api.commands.decorators import _options_decorator_factory
 from snowflake.cli.api.project.schemas.entities.application_entity_model import (
     ApplicationEntityModel,
 )
@@ -48,28 +51,75 @@ def _convert_v2_artifact_to_v1_dict(
     return v2_artifact
 
 
-def _pdf_v2_to_v1(v2_definition: DefinitionV20) -> DefinitionV11:
+def _pdf_v2_to_v1(
+    v2_definition: DefinitionV20,
+    package_entity_id: str = "",
+    app_entity_id: str = "",
+) -> DefinitionV11:
     pdfv1: Dict[str, Any] = {"definition_version": "1.1", "native_app": {}}
 
     app_package_definition: Optional[ApplicationPackageEntityModel] = None
     app_definition: Optional[ApplicationEntityModel] = None
 
-    for key, entity in v2_definition.entities.items():
-        if entity.get_type() == ApplicationPackageEntityModel.get_type():
-            if app_package_definition:
-                raise ClickException(
-                    "More than one application package entity exists in the project definition file."
-                )
-            app_package_definition = entity
-        elif entity.get_type() == ApplicationEntityModel.get_type():
-            if app_definition:
+    # Enumerate all application package and application entities in the project definition
+    packages: dict[
+        str, ApplicationPackageEntityModel
+    ] = v2_definition.get_entities_by_type(ApplicationPackageEntityModel.get_type())
+    apps: dict[str, ApplicationEntityModel] = v2_definition.get_entities_by_type(
+        ApplicationEntityModel.get_type()
+    )
+
+    # Determine the application entity to convert, there can be zero or one
+    if app_entity_id:
+        # If the user specified an app entity ID, use that one directly
+        app_definition = apps.get(app_entity_id)
+    elif len(apps) == 1:
+        # Otherwise, if there is only one app entity, fall back to that one
+        app_definition = next(iter(apps.values()))
+    elif len(apps) > 1:
+        # If there are multiple app entities, the user must specify which one to use
+        raise ClickException(
+            "More than one application entity exists in the project definition file, "
+            "specify --app-entity-id to choose which one to operate on."
+        )
+
+    # Infer or verify the package if we have an app entity to convert
+    if app_definition:
+        target_package = app_definition.from_.target
+        if package_entity_id:
+            # If the user specified a package entity ID,
+            # check that the app entity targets the user-specified package entity
+            if target_package != package_entity_id:
                 raise ClickException(
-                    "More than one application entity exists in the project definition file."
+                    f"The application entity {app_definition.entity_id} does not "
+                    f"target the application package entity {package_entity_id}. Either"
+                    f"use --package-entity-id {target_package} to target the correct package entity, "
+                    f"or omit the --package-entity-id flag to automatically use the package entity "
+                    f"that the application entity targets."
                 )
-            app_definition = entity
+        elif target_package in packages:
+            # If the user didn't target a specific package entity, use the one the app entity targets
+            package_entity_id = target_package
+
+    # Determine the package entity to convert, there must be one
+    if package_entity_id:
+        # If the user specified a package entity ID (or we inferred one from the app entity), use that one directly
+        app_package_definition = packages.get(package_entity_id)
+    elif len(packages) == 1:
+        # Otherwise, if there is only one package entity, fall back to that one
+        app_package_definition = next(iter(packages.values()))
+    elif len(packages) > 1:
+        # If there are multiple package entities, the user must specify which one to use
+        raise ClickException(
+            "More than one application package entity exists in the project definition file, "
+            "specify --package-entity-id to choose which one to operate on."
+        )
+
+    # If we don't have a package entity to convert, error out since it's not optional
     if not app_package_definition:
+        with_id = f'with ID "{package_entity_id}" ' if package_entity_id else ""
         raise ClickException(
-            "Could not find an application package entity in the project definition file."
+            f"Could not find an application package entity {with_id}in the project definition file."
         )
 
     # NativeApp
@@ -141,14 +191,38 @@ def nativeapp_definition_v2_to_v1(func):
 
     @wraps(func)
     def wrapper(*args, **kwargs):
-        original_pdf: DefinitionV20 = get_cli_context().project_definition
+        original_pdf: Optional[DefinitionV20] = get_cli_context().project_definition
         if not original_pdf:
             raise ValueError(
                 "Project definition could not be found. The nativeapp_definition_v2_to_v1 command decorator assumes with_project_definition() was called before it."
             )
         if original_pdf.definition_version == "2":
-            pdfv1 = _pdf_v2_to_v1(original_pdf)
-            get_cli_context_manager().set_project_definition(pdfv1)
+            package_entity_id = kwargs.get("package_entity_id", "")
+            app_entity_id = kwargs.get("app_entity_id", "")
+            pdfv1 = _pdf_v2_to_v1(original_pdf, package_entity_id, app_entity_id)
+            get_cli_context_manager().override_project_definition = pdfv1
         return func(*args, **kwargs)
 
-    return wrapper
+    return _options_decorator_factory(
+        wrapper,
+        additional_options=[
+            inspect.Parameter(
+                "package_entity_id",
+                inspect.Parameter.KEYWORD_ONLY,
+                annotation=Optional[str],
+                default=typer.Option(
+                    default="",
+                    help="The ID of the package entity on which to operate when definition_version is 2 or higher.",
+                ),
+            ),
+            inspect.Parameter(
+                "app_entity_id",
+                inspect.Parameter.KEYWORD_ONLY,
+                annotation=Optional[str],
+                default=typer.Option(
+                    default="",
+                    help="The ID of the application entity on which to operate when definition_version is 2 or higher.",
+                ),
+            ),
+        ],
+    )

snowflake/cli/_plugins/snowpark/commands.py

@@ -75,7 +75,6 @@ from snowflake.cli.api.constants import (
     DEFAULT_SIZE_LIMIT_MB,
 )
 from snowflake.cli.api.exceptions import (
-    NoProjectDefinitionError,
     SecretsWithoutExternalAccessIntegrationError,
 )
 from snowflake.cli.api.identifiers import FQN
@@ -85,6 +84,9 @@ from snowflake.cli.api.output.types import (
     MessageResult,
     SingleQueryResult,
 )
+from snowflake.cli.api.project.definition_conversion import (
+    convert_project_definition_to_v2,
+)
 from snowflake.cli.api.project.schemas.entities.snowpark_entity import (
     FunctionEntityModel,
     ProcedureEntityModel,
@@ -93,10 +95,6 @@ from snowflake.cli.api.project.schemas.project_definition import (
     ProjectDefinition,
     ProjectDefinitionV2,
 )
-from snowflake.cli.api.project.schemas.snowpark.callable import (
-    FunctionSchema,
-    ProcedureSchema,
-)
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import DictCursor, ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
@@ -123,7 +121,7 @@ LikeOption = like_option(
 )
 
 
-@app.command("deploy", requires_connection=True)
+@app.command("deploy", requires_connection=True, require_warehouse=True)
 @with_project_definition()
 def deploy(
     replace: bool = ReplaceOption(
@@ -445,66 +443,8 @@ def describe(
     )
 
 
-def migrate_v1_snowpark_to_v2(pd: ProjectDefinition):
-    if not pd.snowpark:
-        raise NoProjectDefinitionError(
-            project_type="snowpark", project_root=get_cli_context().project_root
-        )
-
-    artifact_mapping = {"src": pd.snowpark.src}
-    if pd.snowpark.project_name:
-        artifact_mapping["dest"] = pd.snowpark.project_name
-
-    snowpark_shared_mixin = "snowpark_shared"
-    data: dict = {
-        "definition_version": "2",
-        "mixins": {
-            snowpark_shared_mixin: {
-                "stage": pd.snowpark.stage_name,
-                "artifacts": [artifact_mapping],
-            }
-        },
-        "entities": {},
-    }
-
-    for index, entity in enumerate([*pd.snowpark.procedures, *pd.snowpark.functions]):
-        identifier = {"name": entity.name}
-        if entity.database is not None:
-            identifier["database"] = entity.database
-        if entity.schema_name is not None:
-            identifier["schema"] = entity.schema_name
-
-        if entity.name.startswith("<%") and entity.name.endswith("%>"):
-            entity_name = f"snowpark_entity_{index}"
-        else:
-            entity_name = entity.name
-
-        v2_entity = {
-            "type": "function" if isinstance(entity, FunctionSchema) else "procedure",
-            "stage": pd.snowpark.stage_name,
-            "handler": entity.handler,
-            "returns": entity.returns,
-            "signature": entity.signature,
-            "runtime": entity.runtime,
-            "external_access_integrations": entity.external_access_integrations,
-            "secrets": entity.secrets,
-            "imports": entity.imports,
-            "identifier": identifier,
-            "meta": {"use_mixins": [snowpark_shared_mixin]},
-        }
-        if isinstance(entity, ProcedureSchema):
-            v2_entity["execute_as_caller"] = entity.execute_as_caller
-
-        data["entities"][entity_name] = v2_entity
-
-    if hasattr(pd, "env") and pd.env:
-        data["env"] = {k: v for k, v in pd.env.items()}
-
-    return ProjectDefinitionV2(**data)
-
-
 def _get_v2_project_definition(cli_context) -> ProjectDefinitionV2:
     pd = cli_context.project_definition
     if not pd.meets_version_requirement("2"):
-        pd = migrate_v1_snowpark_to_v2(pd)
+        pd = convert_project_definition_to_v2(cli_context.project_root, pd)
     return pd

snowflake/cli/_plugins/snowpark/common.py

@@ -23,7 +23,13 @@ from click import UsageError
 from snowflake.cli._plugins.snowpark.models import Requirement
 from snowflake.cli._plugins.snowpark.snowpark_project_paths import Artefact
 from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.constants import (
+    INIT_TEMPLATE_VARIABLE_CLOSING,
+    INIT_TEMPLATE_VARIABLE_OPENING,
+    PROJECT_TEMPLATE_VARIABLE_CLOSING,
+    PROJECT_TEMPLATE_VARIABLE_OPENING,
+    ObjectType,
+)
 from snowflake.cli.api.project.schemas.entities.snowpark_entity import (
     ProcedureEntityModel,
     SnowparkEntityModel,
@@ -250,3 +256,13 @@ def _compare_imports(
         }
 
     return project_imports != object_imports
+
+
+def is_name_a_templated_one(name: str) -> bool:
+    return (
+        PROJECT_TEMPLATE_VARIABLE_OPENING in name
+        and PROJECT_TEMPLATE_VARIABLE_CLOSING in name
+    ) or (
+        INIT_TEMPLATE_VARIABLE_OPENING in name
+        and INIT_TEMPLATE_VARIABLE_CLOSING in name
+    )

snowflake/cli/_plugins/snowpark/models.py

@@ -121,13 +121,14 @@ class WheelMetadata:
                 if line.startswith(dep_keyword)
             ]
             name = cls._get_name_from_wheel_filename(wheel_path.name)
+
             return cls(name=name, wheel_path=wheel_path, dependencies=dependencies)
 
     @staticmethod
     def _get_name_from_wheel_filename(wheel_filename: str) -> str:
         # wheel filename is in format {name}-{version}[-{extra info}]
         # https://peps.python.org/pep-0491/#file-name-convention
-        return wheel_filename.split("-")[0]
+        return wheel_filename.split("-")[0].lower()
 
     @staticmethod
     def to_wheel_name_format(package_name: str) -> str:

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

@@ -18,12 +18,9 @@ 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._plugins.snowpark.models import Requirement
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.secure_path import SecurePath
@@ -170,23 +167,13 @@ class AnacondaPackagesManager(SqlExecutionMixin):
         "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()
+        packages = self._query_snowflake_for_available_packages()
         return AnacondaPackages(packages)
 
     def _query_snowflake_for_available_packages(self) -> dict[str, AvailablePackage]:
@@ -210,24 +197,3 @@ class AnacondaPackagesManager(SqlExecutionMixin):
                     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/sql/commands.py

@@ -73,8 +73,7 @@ def execute_sql(
     Query to execute can be specified using query option, filename option (all queries from file will be executed)
     or via stdin by piping output from other command. For example `cat my.sql | snow sql -i`.
 
-    The command supports variable substitution that happens on client-side. Both &VARIABLE or &{ VARIABLE }
-    syntax are supported.
+    The command supports variable substitution that happens on client-side.
     """
 
     data = {}