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

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "3.0.0rc1"
+VERSION = "3.0.0rc2"

snowflake/cli/_app/cli_app.py

@@ -38,6 +38,10 @@ from snowflake.cli._app.dev.pycharm_remote_debug import (
 )
 from snowflake.cli._app.main_typer import SnowCliMainTyper
 from snowflake.cli._app.printing import MessageResult, print_result
+from snowflake.cli._app.version_check import (
+    get_new_version_msg,
+    show_new_version_banner_callback,
+)
 from snowflake.cli.api import Api, api_provider
 from snowflake.cli.api.config import config_init
 from snowflake.cli.api.output.formats import OutputFormat
@@ -145,8 +149,13 @@ def _info_callback(value: bool):
 
 def app_factory() -> SnowCliMainTyper:
     app = SnowCliMainTyper()
+    new_version_msg = get_new_version_msg()
 
-    @app.callback(invoke_without_command=True)
+    @app.callback(
+        invoke_without_command=True,
+        epilog=new_version_msg,
+        result_callback=show_new_version_banner_callback(new_version_msg),
+    )
     def default(
         ctx: typer.Context,
         version: bool = typer.Option(

snowflake/cli/_app/snow_connector.py

@@ -25,11 +25,9 @@ from snowflake.cli._app.constants import (
     PARAM_APPLICATION_NAME,
 )
 from snowflake.cli._app.telemetry import command_info
-from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.config import (
     get_connection_dict,
-    get_default_connection_dict,
-    get_default_connection_name,
+    get_env_value,
 )
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.exceptions import (
@@ -46,6 +44,33 @@ log = logging.getLogger(__name__)
 ENCRYPTED_PKCS8_PK_HEADER = b"-----BEGIN ENCRYPTED PRIVATE KEY-----"
 UNENCRYPTED_PKCS8_PK_HEADER = b"-----BEGIN PRIVATE KEY-----"
 
+# connection keys that can be set using SNOWFLAKE_* env vars
+SUPPORTED_ENV_OVERRIDES = [
+    "account",
+    "user",
+    "password",
+    "authenticator",
+    "private_key_file",
+    "private_key_path",
+    "database",
+    "schema",
+    "role",
+    "warehouse",
+    "session_token",
+    "master_token",
+    "token_file_path",
+]
+
+# mapping of found key -> key to set
+CONNECTION_KEY_ALIASES = {"private_key_path": "private_key_file"}
+
+
+def _resolve_alias(key_or_alias: str):
+    """
+    Given the key of an override / env var, what key should it be set as in the connection parameters?
+    """
+    return CONNECTION_KEY_ALIASES.get(key_or_alias, key_or_alias)
+
 
 def connect_to_snowflake(
     temporary_connection: bool = False,
@@ -58,6 +83,10 @@ def connect_to_snowflake(
 ) -> SnowflakeConnection:
     if temporary_connection and connection_name:
         raise ClickException("Can't use connection name and temporary connection.")
+    elif not temporary_connection and not connection_name:
+        raise ClickException(
+            "One of connection name or temporary connection is required."
+        )
 
     using_session_token = (
         "session_token" in overrides and overrides["session_token"] is not None
@@ -70,37 +99,33 @@ def connect_to_snowflake(
     )
 
     if connection_name:
-        connection_parameters = get_connection_dict(connection_name)
-        connection_parameters = get_connection_dict(connection_name)
+        connection_parameters = {
+            _resolve_alias(k): v
+            for k, v in get_connection_dict(connection_name).items()
+        }
     elif temporary_connection:
         connection_parameters = {}  # we will apply overrides in next step
-    else:
-        connection_parameters = get_default_connection_dict()
-        get_cli_context().connection_context.set_connection_name(
-            get_default_connection_name()
-        )
 
     # Apply overrides to connection details
+    # (1) Command line override case
     for key, value in overrides.items():
-        # Command line override case
-        if value:
-            connection_parameters[key] = value
-            continue
+        if value is not None:
+            connection_parameters[_resolve_alias(key)] = value
 
-        # Generic environment variable case, apply only if value not passed via flag or connection variable
-        generic_env_value = os.environ.get(f"SNOWFLAKE_{key}".upper())
-        if key not in connection_parameters and generic_env_value:
-            connection_parameters[key] = generic_env_value
-            continue
+    # (2) Generic environment variable case
+    # ... apply only if value not passed via flag or connection variable
+    for key in SUPPORTED_ENV_OVERRIDES:
+        generic_env_value = get_env_value(key=key)
+        connection_key = _resolve_alias(key)
+        if connection_key not in connection_parameters and generic_env_value:
+            connection_parameters[connection_key] = generic_env_value
 
     # Clean up connection params
     connection_parameters = {
         k: v for k, v in connection_parameters.items() if v is not None
     }
 
-    connection_parameters = update_connection_details_with_private_key(
-        connection_parameters
-    )
+    update_connection_details_with_private_key(connection_parameters)
 
     if mfa_passcode:
         connection_parameters["passcode"] = mfa_passcode
@@ -169,12 +194,32 @@ def update_connection_details_with_private_key(connection_parameters: Dict):
         _load_private_key(connection_parameters, "private_key_file")
     elif "private_key_path" in connection_parameters:
         _load_private_key(connection_parameters, "private_key_path")
+    elif "private_key_raw" in connection_parameters:
+        _load_private_key_from_parameters(connection_parameters, "private_key_raw")
     return connection_parameters
 
 
 def _load_private_key(connection_parameters: Dict, private_key_var_name: str) -> None:
     if connection_parameters.get("authenticator") == "SNOWFLAKE_JWT":
-        private_key = _load_pem_to_der(connection_parameters[private_key_var_name])
+        private_key_pem = _load_pem_from_file(
+            connection_parameters[private_key_var_name]
+        )
+        private_key = _load_pem_to_der(private_key_pem)
+        connection_parameters["private_key"] = private_key
+        del connection_parameters[private_key_var_name]
+    else:
+        raise ClickException(
+            "Private Key authentication requires authenticator set to SNOWFLAKE_JWT"
+        )
+
+
+def _load_private_key_from_parameters(
+    connection_parameters: Dict, private_key_var_name: str
+) -> None:
+    if connection_parameters.get("authenticator") == "SNOWFLAKE_JWT":
+        private_key_pem = connection_parameters[private_key_var_name]
+        private_key_pem = private_key_pem.encode("utf-8")
+        private_key = _load_pem_to_der(private_key_pem)
         connection_parameters["private_key"] = private_key
         del connection_parameters[private_key_var_name]
     else:
@@ -191,17 +236,19 @@ def _update_connection_application_name(connection_parameters: Dict):
     connection_parameters.update(connection_application_params)
 
 
-def _load_pem_to_der(private_key_file: str) -> bytes:
-    """
-    Given a private key file path (in PEM format), decode key data into DER
-    format
-    """
-
+def _load_pem_from_file(private_key_file: str) -> bytes:
     with SecurePath(private_key_file).open(
         "rb", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
     ) as f:
         private_key_pem = f.read()
+    return private_key_pem
 
+
+def _load_pem_to_der(private_key_pem: bytes) -> bytes:
+    """
+    Given a private key file path (in PEM format), decode key data into DER
+    format
+    """
     private_key_passphrase = os.getenv("PRIVATE_KEY_PASSPHRASE", None)
     if (
         private_key_pem.startswith(ENCRYPTED_PKCS8_PK_HEADER)

snowflake/cli/_app/telemetry.py

@@ -22,7 +22,10 @@ from typing import Any, Dict, Union
 import click
 from snowflake.cli.__about__ import VERSION
 from snowflake.cli._app.constants import PARAM_APPLICATION_NAME
-from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.cli_global_context import (
+    _CliGlobalContextAccess,
+    get_cli_context,
+)
 from snowflake.cli.api.commands.execution_metadata import ExecutionMetadata
 from snowflake.cli.api.config import get_feature_flags_section
 from snowflake.cli.api.output.formats import OutputFormat
@@ -106,8 +109,9 @@ def python_version() -> str:
 
 
 class CLITelemetryClient:
-    def __init__(self, ctx):
-        self._ctx = ctx
+    @property
+    def _ctx(self) -> _CliGlobalContextAccess:
+        return get_cli_context()
 
     @staticmethod
     def generate_telemetry_data_dict(
@@ -143,7 +147,7 @@ class CLITelemetryClient:
         self._telemetry.send_batch()
 
 
-_telemetry = CLITelemetryClient(ctx=get_cli_context())
+_telemetry = CLITelemetryClient()
 
 
 @ignore_exceptions()

snowflake/cli/_app/version_check.py

@@ -0,0 +1,74 @@
+import json
+import time
+
+import requests
+from packaging.version import Version
+from snowflake.cli.__about__ import VERSION
+from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.secure_path import SecurePath
+from snowflake.connector.config_manager import CONFIG_MANAGER
+
+
+def get_new_version_msg() -> str | None:
+    last = _VersionCache().get_last_version()
+    current = Version(VERSION)
+    if last and last > current:
+        return f"\nNew version of Snowflake CLI available. Newest: {last}, current: {VERSION}\n"
+    return None
+
+
+def show_new_version_banner_callback(msg):
+    def _callback(*args, **kwargs):
+        if msg:
+            cli_console.message(msg)
+
+    return _callback
+
+
+class _VersionCache:
+    _last_time = "last_time_check"
+    _version = "version"
+    _version_cache_file = SecurePath(
+        CONFIG_MANAGER.file_path.parent / ".cli_version.cache"
+    )
+
+    def __init__(self):
+        self._cache_file = _VersionCache._version_cache_file
+
+    def _save_latest_version(self, version: str):
+        data = {
+            _VersionCache._last_time: time.time(),
+            _VersionCache._version: str(version),
+        }
+        self._cache_file.write_text(json.dumps(data))
+
+    @staticmethod
+    def _get_version_from_pypi() -> str | None:
+        headers = {"Content-Type": "application/vnd.pypi.simple.v1+json"}
+        response = requests.get(
+            "https://pypi.org/pypi/snowflake-cli-labs/json", headers=headers, timeout=3
+        )
+        response.raise_for_status()
+        return response.json()["info"]["version"]
+
+    def _update_latest_version(self) -> Version | None:
+        version = self._get_version_from_pypi()
+        if version is None:
+            return None
+        self._save_latest_version(version)
+        return Version(version)
+
+    def _read_latest_version(self) -> Version | None:
+        if self._cache_file.exists():
+            data = json.loads(self._cache_file.read_text())
+            now = time.time()
+            if data[_VersionCache._last_time] > now - 60 * 60:
+                return Version(data[_VersionCache._version])
+
+        return self._update_latest_version()
+
+    def get_last_version(self) -> Version | None:
+        try:
+            return self._read_latest_version()
+        except:  # anything, this it not crucial feature
+            return None

snowflake/cli/_plugins/git/commands.py

@@ -18,7 +18,7 @@ import itertools
 import logging
 from os import path
 from pathlib import Path
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import typer
 from click import ClickException
@@ -41,6 +41,7 @@ from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.output.types import CollectionResult, CommandResult, QueryResult
 from snowflake.cli.api.utils.path_utils import is_stage_path
+from snowflake.connector import DictCursor
 
 app = SnowTyperFactory(
     name="git",
@@ -98,6 +99,24 @@ def _validate_origin_url(url: str) -> None:
         raise ClickException("Url address should start with 'https'")
 
 
+def _unique_new_object_name(
+    om: ObjectManager, object_type: ObjectType, proposed_fqn: FQN
+) -> str:
+    existing_objects: List[Dict] = om.show(
+        object_type=object_type.value.cli_name,
+        like=f"{proposed_fqn.name}%",
+        cursor_class=DictCursor,
+    ).fetchall()
+    existing_names = set(o["name"].upper() for o in existing_objects)
+
+    result = proposed_fqn.name
+    i = 1
+    while result.upper() in existing_names:
+        result = proposed_fqn.name + str(i)
+        i += 1
+    return result
+
+
 @app.command("setup", requires_connection=True)
 def setup(
     repository_name: FQN = RepoNameArgument,
@@ -128,13 +147,29 @@ def setup(
     should_create_secret = False
     secret_name = None
     if secret_needed:
-        secret_name = f"{repository_name}_secret"
-        secret_name = typer.prompt(
-            "Secret identifier (will be created if not exists)", default=secret_name
+        default_secret_name = (
+            FQN.from_string(f"{repository_name.name}_secret")
+            .set_schema(repository_name.schema)
+            .set_database(repository_name.database)
+        )
+        default_secret_name.set_name(
+            _unique_new_object_name(
+                om, object_type=ObjectType.SECRET, proposed_fqn=default_secret_name
+            ),
         )
-        secret_fqn = FQN.from_string(secret_name)
+        secret_name = FQN.from_string(
+            typer.prompt(
+                "Secret identifier (will be created if not exists)",
+                default=default_secret_name.name,
+            )
+        )
+        if not secret_name.database:
+            secret_name.set_database(repository_name.database)
+        if not secret_name.schema:
+            secret_name.set_schema(repository_name.schema)
+
         if om.object_exists(
-            object_type=ObjectType.SECRET.value.cli_name, fqn=secret_fqn
+            object_type=ObjectType.SECRET.value.cli_name, fqn=secret_name
         ):
             cli_console.step(f"Using existing secret '{secret_name}'")
         else:
@@ -143,24 +178,30 @@ def setup(
             secret_username = typer.prompt("username")
             secret_password = typer.prompt("password/token", hide_input=True)
 
-    api_integration = f"{repository_name}_api_integration"
-    api_integration = typer.prompt(
-        "API integration identifier (will be created if not exists)",
-        default=api_integration,
+    # API integration is an account-level object
+    api_integration = FQN.from_string(f"{repository_name.name}_api_integration")
+    api_integration.set_name(
+        typer.prompt(
+            "API integration identifier (will be created if not exists)",
+            default=_unique_new_object_name(
+                om,
+                object_type=ObjectType.INTEGRATION,
+                proposed_fqn=api_integration,
+            ),
+        )
     )
-    api_integration_fqn = FQN.from_string(api_integration)
 
     if should_create_secret:
         manager.create_password_secret(
-            name=secret_fqn, username=secret_username, password=secret_password
+            name=secret_name, username=secret_username, password=secret_password
         )
         cli_console.step(f"Secret '{secret_name}' successfully created.")
 
     if not om.object_exists(
-        object_type=ObjectType.INTEGRATION.value.cli_name, fqn=api_integration_fqn
+        object_type=ObjectType.INTEGRATION.value.cli_name, fqn=api_integration
     ):
         manager.create_api_integration(
-            name=api_integration_fqn,
+            name=api_integration,
             api_provider="git_https_api",
             allowed_prefix=url,
             secret=secret_name,

snowflake/cli/_plugins/nativeapp/codegen/snowpark/python_processor.py

@@ -323,11 +323,8 @@ class SnowparkAnnotationProcessor(ArtifactProcessor):
                 predicate=is_python_file_artifact,
             )
         ):
-            cc.step(
-                "Processing Snowpark annotations from {}".format(
-                    dest_file.relative_to(bundle_map.deploy_root())
-                )
-            )
+            src_file_name = src_file.relative_to(self._bundle_ctx.project_root)
+            cc.step(f"Processing Snowpark annotations from {src_file_name}")
             collected_extension_function_json = _execute_in_sandbox(
                 py_file=str(dest_file.resolve()),
                 deploy_root=self._bundle_ctx.deploy_root,

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

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import Optional
 
 import jinja2
@@ -30,27 +31,72 @@ from snowflake.cli.api.project.schemas.native_app.path_mapping import (
 )
 from snowflake.cli.api.rendering.project_definition_templates import (
     get_client_side_jinja_env,
+    has_client_side_templates,
 )
 from snowflake.cli.api.rendering.sql_templates import (
     choose_sql_jinja_env_based_on_template_syntax,
+    has_sql_templates,
 )
 
 
+def _is_sql_file(file: Path) -> bool:
+    return file.name.lower().endswith(".sql")
+
+
 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:
+        """
+        Expand templates in the file.
+        """
+        if src.is_dir():
+            return
+
+        with self.edit_file(dest) as file:
+            if not has_client_side_templates(file.contents) and not (
+                _is_sql_file(dest) and has_sql_templates(file.contents)
+            ):
+                return
+
+            src_file_name = src.relative_to(self._bundle_ctx.project_root)
+            cc.step(f"Expanding templates in {src_file_name}")
+            with cc.indented():
+                try:
+                    jinja_env = (
+                        choose_sql_jinja_env_based_on_template_syntax(
+                            file.contents, reference_name=src_file_name
+                        )
+                        if _is_sql_file(dest)
+                        else get_client_side_jinja_env()
+                    )
+                    expanded_template = jinja_env.from_string(file.contents).render(
+                        get_cli_context().template_context
+                    )
+
+                # For now, we are printing the source file path in the error message
+                # instead of the destination file path to make it easier for the user
+                # to identify the file that has the error, and edit the correct file.
+                except jinja2.TemplateSyntaxError as e:
+                    raise InvalidTemplateInFileError(src_file_name, e, e.lineno) from e
+
+                except jinja2.UndefinedError as e:
+                    raise InvalidTemplateInFileError(src_file_name, e) from e
+
+                if expanded_template != file.contents:
+                    file.edited_contents = expanded_template
+
     def process(
         self,
         artifact_to_process: PathMapping,
         processor_mapping: Optional[ProcessorMapping],
         **kwargs,
-    ):
+    ) -> None:
         """
         Process the artifact by executing the template expansion logic on it.
         """
-        cc.step(f"Processing artifact {artifact_to_process} with templates processor")
 
         bundle_map = BundleMap(
             project_root=self._bundle_ctx.project_root,
@@ -62,32 +108,4 @@ class TemplatesProcessor(ArtifactProcessor):
             absolute=True,
             expand_directories=True,
         ):
-            if src.is_dir():
-                continue
-            with self.edit_file(dest) as f:
-                file_name = src.relative_to(self._bundle_ctx.project_root)
-
-                jinja_env = (
-                    choose_sql_jinja_env_based_on_template_syntax(
-                        f.contents, reference_name=file_name
-                    )
-                    if dest.name.lower().endswith(".sql")
-                    else get_client_side_jinja_env()
-                )
-
-                try:
-                    expanded_template = jinja_env.from_string(f.contents).render(
-                        get_cli_context().template_context
-                    )
-
-                # For now, we are printing the source file path in the error message
-                # instead of the destination file path to make it easier for the user
-                # to identify the file that has the error, and edit the correct file.
-                except jinja2.TemplateSyntaxError as e:
-                    raise InvalidTemplateInFileError(file_name, e, e.lineno) from e
-
-                except jinja2.UndefinedError as e:
-                    raise InvalidTemplateInFileError(file_name, e) from e
-
-                if expanded_template != f.contents:
-                    f.edited_contents = expanded_template
+            self.expand_templates_in_file(src, dest)