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

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "3.1.0"
+VERSION = "3.2.0"

snowflake/cli/_app/dev/docs/templates/usage.rst.jinja2

@@ -48,7 +48,7 @@ Options
         {%- if param.type.name != "choice" %}{{ ' {' }}{% else %} {% endif %}{{ param.make_metavar() }}{% if param.type.name != "choice" %}{{ '}' }}
         {%- endif %}
     {%- endif %}`
-{% if param.help %}{{ "  " + param.help | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default is not none %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
+{% if param.help %}{{ "  " + param.help | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default is not none and param.default != "" %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
 {% endfor -%}
 {% else %}
 

snowflake/cli/_plugins/connection/commands.py

@@ -16,20 +16,38 @@ from __future__ import annotations
 
 import logging
 import os.path
+from pathlib import Path
+from typing import Optional
 
 import typer
-from click import ClickException, Context, Parameter, UsageError  # type: ignore
+from click import (  # type: ignore
+    ClickException,
+    Context,
+    Parameter,
+    UsageError,
+)
 from click.core import ParameterSource  # type: ignore
-from click.types import StringParamType
 from snowflake import connector
 from snowflake.cli._plugins.connection.util import (
-    strip_and_check_if_exists,
     strip_if_value_present,
 )
 from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.flags import (
     PLAIN_PASSWORD_MSG,
+    AccountOption,
+    AuthenticatorOption,
+    DatabaseOption,
+    HostOption,
+    NoInteractiveOption,
+    PasswordOption,
+    PortOption,
+    PrivateKeyPathOption,
+    RoleOption,
+    SchemaOption,
+    TokenFilePathOption,
+    UserOption,
+    WarehouseOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.config import (
@@ -64,11 +82,6 @@ class EmptyInput:
         return "optional"
 
 
-class OptionalPrompt(StringParamType):
-    def convert(self, value, param, ctx):
-        return None if isinstance(value, EmptyInput) else value
-
-
 def _mask_password(connection_params: dict):
     if "password" in connection_params:
         connection_params["password"] = "****"
@@ -101,7 +114,7 @@ def list_connections(**options) -> CommandResult:
 
 
 def require_integer(field_name: str):
-    def callback(value: str):
+    def callback(ctx: Context, param: Parameter, value: str):
         if value is None:
             return None
         if value.strip().isdigit():
@@ -124,130 +137,91 @@ def add(
         None,
         "--connection-name",
         "-n",
-        prompt="Name for this connection",
         help="Name of the new connection.",
         show_default=False,
-        callback=strip_if_value_present,
     ),
     account: str = typer.Option(
         None,
-        "--account",
         "-a",
-        "--accountname",
-        prompt="Snowflake account name",
+        *AccountOption.param_decls,
         help="Account name to use when authenticating with Snowflake.",
         show_default=False,
-        callback=strip_if_value_present,
     ),
     user: str = typer.Option(
         None,
-        "--user",
         "-u",
-        "--username",
-        prompt="Snowflake username",
+        *UserOption.param_decls,
         show_default=False,
         help="Username to connect to Snowflake.",
-        callback=strip_if_value_present,
     ),
-    password: str = typer.Option(
-        EmptyInput(),
-        "--password",
+    password: Optional[str] = typer.Option(
+        None,
         "-p",
-        click_type=OptionalPrompt(),
+        *PasswordOption.param_decls,
         callback=_password_callback,
-        prompt="Snowflake password",
         help="Snowflake password.",
         hide_input=True,
     ),
-    role: str = typer.Option(
-        EmptyInput(),
-        "--role",
+    role: Optional[str] = typer.Option(
+        None,
         "-r",
-        click_type=OptionalPrompt(),
-        prompt="Role for the connection",
+        *RoleOption.param_decls,
         help="Role to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    warehouse: str = typer.Option(
-        EmptyInput(),
-        "--warehouse",
+    warehouse: Optional[str] = typer.Option(
+        None,
         "-w",
-        click_type=OptionalPrompt(),
-        prompt="Warehouse for the connection",
+        *WarehouseOption.param_decls,
         help="Warehouse to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    database: str = typer.Option(
-        EmptyInput(),
-        "--database",
+    database: Optional[str] = typer.Option(
+        None,
         "-d",
-        click_type=OptionalPrompt(),
-        prompt="Database for the connection",
+        *DatabaseOption.param_decls,
         help="Database to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    schema: str = typer.Option(
-        EmptyInput(),
-        "--schema",
+    schema: Optional[str] = typer.Option(
+        None,
         "-s",
-        click_type=OptionalPrompt(),
-        prompt="Schema for the connection",
+        *SchemaOption.param_decls,
         help="Schema to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    host: str = typer.Option(
-        EmptyInput(),
-        "--host",
+    host: Optional[str] = typer.Option(
+        None,
         "-h",
-        click_type=OptionalPrompt(),
-        prompt="Connection host",
+        *HostOption.param_decls,
         help="Host name the connection attempts to connect to Snowflake.",
-        callback=strip_if_value_present,
     ),
-    port: int = typer.Option(
-        EmptyInput(),
-        "--port",
+    port: Optional[int] = typer.Option(
+        None,
         "-P",
-        click_type=OptionalPrompt(),
-        prompt="Connection port",
+        *PortOption.param_decls,
         help="Port to communicate with on the host.",
-        callback=require_integer(field_name="port"),
     ),
-    region: str = typer.Option(
-        EmptyInput(),
+    region: Optional[str] = typer.Option(
+        None,
         "--region",
         "-R",
-        click_type=OptionalPrompt(),
-        prompt="Snowflake region",
         help="Region name if not the default Snowflake deployment.",
-        callback=strip_if_value_present,
     ),
-    authenticator: str = typer.Option(
-        EmptyInput(),
-        "--authenticator",
+    authenticator: Optional[str] = typer.Option(
+        None,
         "-A",
-        click_type=OptionalPrompt(),
-        prompt="Authentication method",
+        *AuthenticatorOption.param_decls,
         help="Chosen authenticator, if other than password-based",
     ),
-    private_key_file: str = typer.Option(
-        EmptyInput(),
+    private_key_file: Optional[str] = typer.Option(
+        None,
         "--private-key",
-        "--private-key-path",
         "-k",
-        click_type=OptionalPrompt(),
-        prompt="Path to private key file",
+        *PrivateKeyPathOption.param_decls,
         help="Path to file containing private key",
-        callback=strip_and_check_if_exists,
     ),
-    token_file_path: str = typer.Option(
-        EmptyInput(),
-        "--token-file-path",
+    token_file_path: Optional[str] = typer.Option(
+        None,
         "-t",
-        click_type=OptionalPrompt(),
-        prompt="Path to token file",
+        *TokenFilePathOption.param_decls,
         help="Path to file with an OAuth token that should be used when connecting to Snowflake",
-        callback=strip_and_check_if_exists,
     ),
     set_as_default: bool = typer.Option(
         False,
@@ -255,29 +229,62 @@ def add(
         is_flag=True,
         help="If provided the connection will be configured as default connection.",
     ),
+    no_interactive: bool = NoInteractiveOption,
     **options,
 ) -> CommandResult:
     """Adds a connection to configuration file."""
+    connection_options = {
+        "connection_name": connection_name,
+        "account": account,
+        "user": user,
+        "password": password,
+        "role": role,
+        "warehouse": warehouse,
+        "database": database,
+        "schema": schema,
+        "host": host,
+        "port": port,
+        "region": region,
+        "authenticator": authenticator,
+        "private_key_file": private_key_file,
+        "token_file_path": token_file_path,
+    }
+
+    if not no_interactive:
+        for option in connection_options:
+            if connection_options[option] is None:
+                connection_options[option] = typer.prompt(
+                    f"Enter {option.replace('_', ' ')}",
+                    default="",
+                    value_proc=lambda x: None if not x else x,
+                    hide_input=option == "password",
+                    show_default=False,
+                )
+            if isinstance(connection_options[option], str):
+                connection_options[option] = strip_if_value_present(
+                    connection_options[option]
+                )
+
+    if (value := connection_options["port"]) is not None:
+        connection_options["port"] = int(value)
+
+    if (path := connection_options["private_key_file"]) is not None:
+        if not Path(str(path)).exists():
+            raise UsageError(f"Path {path} does not exist.")
+
+    if (path := connection_options["token_file_path"]) is not None:
+        if not Path(str(path)).exists():
+            raise UsageError(f"Path {path} does not exist.")
+
+    connection_name = str(connection_options["connection_name"])
+    del connection_options["connection_name"]
+
     if connection_exists(connection_name):
-        raise ClickException(f"Connection {connection_name} already exists")
+        raise UsageError(f"Connection {connection_name} already exists")
 
     connections_file = add_connection_to_proper_file(
         connection_name,
-        ConnectionConfig(
-            account=account,
-            user=user,
-            password=password,
-            host=host,
-            region=region,
-            port=port,
-            database=database,
-            schema=schema,
-            warehouse=warehouse,
-            role=role,
-            authenticator=authenticator,
-            private_key_file=private_key_file,
-            token_file_path=token_file_path,
-        ),
+        ConnectionConfig(**connection_options),
     )
     if set_as_default:
         set_config_value(
@@ -358,7 +365,7 @@ def set_default(
 def generate_jwt(
     **options,
 ) -> CommandResult:
-    """Generate and display a JWT token."""
+    """Generate a JWT token, which will be printed out and displayed.."""
     connection_details = get_cli_context().connection_context.update_from_config()
 
     msq_template = (
@@ -370,22 +377,30 @@ def generate_jwt(
         raise UsageError(msq_template.format("Account"))
     if not connection_details.private_key_file:
         raise UsageError(msq_template.format("Private key file"))
+
     passphrase = os.getenv("PRIVATE_KEY_PASSPHRASE", None)
-    if not passphrase:
-        passphrase = typer.prompt(
-            "Enter private key file password (Press enter if none)",
-            hide_input=True,
-            type=str,
-            default="",
-        )
 
-    try:
-        token = connector.auth.get_token_from_private_key(
+    def _decrypt(passphrase: str | None):
+        return connector.auth.get_token_from_private_key(
             user=connection_details.user,
             account=connection_details.account,
             privatekey_path=connection_details.private_key_file,
             key_password=passphrase,
         )
+
+    try:
+        if passphrase is None:
+            try:
+                token = _decrypt(passphrase=None)
+                return MessageResult(token)
+            except TypeError:
+                passphrase = typer.prompt(
+                    "Enter private key file password (press enter for empty)",
+                    hide_input=True,
+                    type=str,
+                    default="",
+                )
+        token = _decrypt(passphrase=passphrase)
         return MessageResult(token)
-    except ValueError as err:
+    except (ValueError, TypeError) as err:
         raise ClickException(str(err))

snowflake/cli/_plugins/connection/util.py

@@ -17,7 +17,10 @@ from __future__ import annotations
 import json
 import logging
 import os
-from typing import Optional
+from enum import Enum
+from functools import lru_cache
+from textwrap import dedent
+from typing import Any, Dict, Optional
 
 from click.exceptions import ClickException
 from snowflake.connector import SnowflakeConnection
@@ -25,12 +28,6 @@ from snowflake.connector.cursor import DictCursor
 
 log = logging.getLogger(__name__)
 
-REGIONLESS_QUERY = """
-    select value['value'] as REGIONLESS from table(flatten(
-        input => parse_json(SYSTEM$BOOTSTRAP_DATA_REQUEST()),
-        path => 'clientParamsInfo'
-    )) where value['name'] = 'UI_SNOWSIGHT_ENABLE_REGIONLESS_REDIRECT';
-"""
 
 ALLOWLIST_QUERY = "SELECT SYSTEM$ALLOWLIST()"
 SNOWFLAKE_DEPLOYMENT = "SNOWFLAKE_DEPLOYMENT"
@@ -54,6 +51,50 @@ class MissingConnectionRegionError(ClickException):
         )
 
 
+class UIParameter(Enum):
+    NA_ENABLE_REGIONLESS_REDIRECT = "UI_SNOWSIGHT_ENABLE_REGIONLESS_REDIRECT"
+    NA_EVENT_SHARING_V2 = "ENABLE_EVENT_SHARING_V2_IN_THE_SAME_ACCOUNT"
+    NA_ENFORCE_MANDATORY_FILTERS = (
+        "ENFORCE_MANDATORY_FILTERS_FOR_SAME_ACCOUNT_INSTALLATION"
+    )
+
+
+def get_ui_parameter(
+    conn: SnowflakeConnection, parameter: UIParameter, default: Any
+) -> str:
+    """
+    Returns the value of a single UI parameter.
+    If the parameter is not found, the default value is returned.
+    """
+
+    ui_parameters = get_ui_parameters(conn)
+    return ui_parameters.get(parameter, default)
+
+
+@lru_cache()
+def get_ui_parameters(conn: SnowflakeConnection) -> Dict[UIParameter, Any]:
+    """
+    Returns the UI parameters from the SYSTEM$BOOTSTRAP_DATA_REQUEST function
+    """
+
+    parameters_to_fetch = sorted([param.value for param in UIParameter])
+
+    query = dedent(
+        f"""
+        select value['value']::string as PARAM_VALUE, value['name']::string as PARAM_NAME from table(flatten(
+            input => parse_json(SYSTEM$BOOTSTRAP_DATA_REQUEST()),
+            path => 'clientParamsInfo'
+        )) where value['name'] in ('{"', '".join(parameters_to_fetch)}');
+        """
+    )
+
+    *_, cursor = conn.execute_string(query, cursor_class=DictCursor)
+
+    return {
+        UIParameter(row["PARAM_NAME"]): row["PARAM_VALUE"] for row in cursor.fetchall()
+    }
+
+
 def is_regionless_redirect(conn: SnowflakeConnection) -> bool:
     """
     Determines if the deployment this connection refers to uses
@@ -62,8 +103,12 @@ def is_regionless_redirect(conn: SnowflakeConnection) -> bool:
     assume it's regionless, as this is true for most production deployments.
     """
     try:
-        *_, cursor = conn.execute_string(REGIONLESS_QUERY, cursor_class=DictCursor)
-        return cursor.fetchone()["REGIONLESS"].lower() == "true"
+        return (
+            get_ui_parameter(
+                conn, UIParameter.NA_ENABLE_REGIONLESS_REDIRECT, "true"
+            ).lower()
+            == "true"
+        )
     except:
         log.warning(
             "Cannot determine regionless redirect; assuming True.", exc_info=True

snowflake/cli/_plugins/cortex/manager.py

@@ -180,7 +180,7 @@ class CortexManager(SqlExecutionMixin):
 
     def _query_cortex_result_str(self, query: str) -> str:
         try:
-            cursor = self._execute_query(query, cursor_class=DictCursor)
+            cursor = self.execute_query(query, cursor_class=DictCursor)
             if cursor.rowcount is None:
                 raise SnowflakeSQLExecutionError(query)
             return str(cursor.fetchone()["CORTEX_RESULT"])

snowflake/cli/_plugins/git/manager.py

@@ -84,13 +84,13 @@ class GitManager(StageManager):
         return StagePath.from_git_str(stage_path)
 
     def show_branches(self, repo_name: str, like: str) -> SnowflakeCursor:
-        return self._execute_query(f"show git branches like '{like}' in {repo_name}")
+        return self.execute_query(f"show git branches like '{like}' in {repo_name}")
 
     def show_tags(self, repo_name: str, like: str) -> SnowflakeCursor:
-        return self._execute_query(f"show git tags like '{like}' in {repo_name}")
+        return self.execute_query(f"show git tags like '{like}' in {repo_name}")
 
     def fetch(self, fqn: FQN) -> SnowflakeCursor:
-        return self._execute_query(f"alter git repository {fqn} fetch")
+        return self.execute_query(f"alter git repository {fqn} fetch")
 
     def create(
         self, repo_name: FQN, api_integration: str, url: str, secret: str
@@ -104,7 +104,7 @@ class GitManager(StageManager):
         )
         if secret is not None:
             query += f"git_credentials = {secret}\n"
-        return self._execute_query(query)
+        return self.execute_query(query)
 
     @staticmethod
     def get_stage_from_path(path: str):

snowflake/cli/_plugins/nativeapp/artifacts.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import itertools
 import os
+from collections import namedtuple
 from pathlib import Path
 from textwrap import dedent
 from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union
@@ -164,7 +165,7 @@ class _ArtifactPathMap:
         if src_is_dir:
             # mark all subdirectories of this source as directories so that we can
             # detect accidental clobbering
-            for (root, _, files) in os.walk(absolute_src, followlinks=True):
+            for root, _, files in os.walk(absolute_src, followlinks=True):
                 canonical_subdir = Path(root).relative_to(absolute_src)
                 canonical_dest_subdir = dest / canonical_subdir
                 self._update_dest_is_dir(canonical_dest_subdir, is_dir=True)
@@ -383,7 +384,7 @@ class BundleMap:
         if absolute_src.is_dir() and expand_directories:
             # both src and dest are directories, and expanding directories was requested. Traverse src, and map each
             # file to the dest directory
-            for (root, subdirs, files) in os.walk(absolute_src, followlinks=True):
+            for root, subdirs, files in os.walk(absolute_src, followlinks=True):
                 relative_root = Path(root).relative_to(absolute_src)
                 for name in itertools.chain(subdirs, files):
                     src_file_for_output = src_for_output / relative_root / name
@@ -674,16 +675,27 @@ def build_bundle(
     if resolved_root.exists():
         delete(resolved_root)
 
-    bundle_map = BundleMap(project_root=project_root, deploy_root=deploy_root)
-    for artifact in artifacts:
-        bundle_map.add(artifact)
-
+    bundle_map = bundle_artifacts(project_root, deploy_root, artifacts)
     if bundle_map.is_empty():
         raise ArtifactError(
             "No artifacts mapping found in project definition, nothing to do."
         )
 
-    for (absolute_src, absolute_dest) in bundle_map.all_mappings(
+    return bundle_map
+
+
+def bundle_artifacts(
+    project_root: Path, deploy_root: Path, artifacts: list[PathMapping]
+):
+    """
+    Internal implementation of build_bundle that assumes
+    that validation is being done by the caller.
+    """
+    bundle_map = BundleMap(project_root=project_root, deploy_root=deploy_root)
+    for artifact in artifacts:
+        bundle_map.add(artifact)
+
+    for absolute_src, absolute_dest in bundle_map.all_mappings(
         absolute=True, expand_directories=False
     ):
         symlink_or_copy(absolute_src, absolute_dest, deploy_root=deploy_root)
@@ -716,7 +728,7 @@ def find_and_read_manifest_file(deploy_root: Path) -> Dict[str, Any]:
         "r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
     ) as file:
         manifest_content = safe_load(file.read())
-    return manifest_content
+    return manifest_content or {}
 
 
 def find_setup_script_file(deploy_root: Path) -> Path:
@@ -743,19 +755,24 @@ def find_setup_script_file(deploy_root: Path) -> Path:
         )
 
 
+VersionInfo = namedtuple("VersionInfo", ["version_name", "patch_number", "label"])
+
+
 def find_version_info_in_manifest_file(
     deploy_root: Path,
-) -> Tuple[Optional[str], Optional[int]]:
+) -> VersionInfo:
     """
     Find version and patch, if available, in the manifest.yml file.
     """
     name_field = "name"
     patch_field = "patch"
+    label_field = "label"
 
     manifest_content = find_and_read_manifest_file(deploy_root=deploy_root)
 
     version_name: Optional[str] = None
     patch_number: Optional[int] = None
+    label: Optional[str] = None
 
     version_info = manifest_content.get("version", None)
     if version_info:
@@ -763,5 +780,42 @@ def find_version_info_in_manifest_file(
             version_name = to_identifier(str(version_info[name_field]))
         if patch_field in version_info:
             patch_number = int(version_info[patch_field])
+        if label_field in version_info:
+            label = str(version_info[label_field])
+
+    return VersionInfo(version_name, patch_number, label)
+
+
+def find_events_definitions_in_manifest_file(
+    deploy_root: Path,
+) -> List[Dict[str, str]]:
+    """
+    Find events definitions, if available, in the manifest.yml file.
+    Events definitions can be found under this section in the manifest.yml file:
+
+    configuration:
+        telemetry_event_definitions:
+            - type: ERRORS_AND_WARNINGS
+              sharing: MANDATORY
+            - type: DEBUG_LOGS
+              sharing: OPTIONAL
+    """
+    manifest_content = find_and_read_manifest_file(deploy_root=deploy_root)
+
+    configuration_section = manifest_content.get("configuration", None)
+    events_definitions = []
+    if configuration_section and isinstance(configuration_section, dict):
+        telemetry_section = configuration_section.get("telemetry_event_definitions", [])
+        if isinstance(telemetry_section, list):
+            for event in telemetry_section:
+                if isinstance(event, dict):
+                    event_type = event.get("type", "")
+                    events_definitions.append(
+                        {
+                            "name": f"SNOWFLAKE${event_type}",
+                            "type": event_type,
+                            "sharing": event.get("sharing", ""),
+                        }
+                    )
 
-    return version_name, patch_number
+    return events_definitions

snowflake/cli/_plugins/nativeapp/codegen/templates/templates_processor.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 import jinja2
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
@@ -49,7 +49,9 @@ class TemplatesProcessor(ArtifactProcessor):
     Processor class to perform template expansion on all relevant artifacts (specified in the project definition file).
     """
 
-    def expand_templates_in_file(self, src: Path, dest: Path) -> None:
+    def expand_templates_in_file(
+        self, src: Path, dest: Path, template_context: dict[str, Any] | None = None
+    ) -> None:
         """
         Expand templates in the file.
         """
@@ -74,7 +76,7 @@ class TemplatesProcessor(ArtifactProcessor):
                         else get_client_side_jinja_env()
                     )
                     expanded_template = jinja_env.from_string(file.contents).render(
-                        get_cli_context().template_context
+                        template_context or get_cli_context().template_context
                     )
 
                 # For now, we are printing the source file path in the error message