snowflake-cli-labs 3.0.0rc0__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.0rc0"
+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,36 +99,33 @@ def connect_to_snowflake(
     )
 
     if 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
@@ -164,18 +190,44 @@ def _raise_errors_related_to_session_token(
 
 
 def update_connection_details_with_private_key(connection_parameters: Dict):
-    if "private_key_path" in connection_parameters:
-        if connection_parameters.get("authenticator") == "SNOWFLAKE_JWT":
-            private_key = _load_pem_to_der(connection_parameters["private_key_path"])
-            connection_parameters["private_key"] = private_key
-            del connection_parameters["private_key_path"]
-        else:
-            raise ClickException(
-                "Private Key authentication requires authenticator set to SNOWFLAKE_JWT"
-            )
+    if "private_key_file" in connection_parameters:
+        _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_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:
+        raise ClickException(
+            "Private Key authentication requires authenticator set to SNOWFLAKE_JWT"
+        )
+
+
 def _update_connection_application_name(connection_parameters: Dict):
     """Update version and name of app handling connection."""
     connection_application_params = {
@@ -184,17 +236,19 @@ def _update_connection_application_name(connection_parameters: Dict):
     connection_parameters.update(connection_application_params)
 
 
-def _load_pem_to_der(private_key_path: str) -> bytes:
-    """
-    Given a private key file path (in PEM format), decode key data into DER
-    format
-    """
-
-    with SecurePath(private_key_path).open(
+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/connection/commands.py

@@ -224,9 +224,10 @@ def add(
         prompt="Authentication method",
         help="Chosen authenticator, if other than password-based",
     ),
-    private_key_path: str = typer.Option(
+    private_key_file: str = typer.Option(
         EmptyInput(),
         "--private-key",
+        "--private-key-path",
         "-k",
         click_type=OptionalPrompt(),
         prompt="Path to private key file",
@@ -268,7 +269,7 @@ def add(
             warehouse=warehouse,
             role=role,
             authenticator=authenticator,
-            private_key_path=private_key_path,
+            private_key_file=private_key_file,
             token_file_path=token_file_path,
         ),
     )

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/git/manager.py

@@ -41,17 +41,25 @@ class GitStagePathParts(StagePathParts):
 
     @property
     def path(self) -> str:
-        return (
-            f"{self.stage_name}{self.directory}"
-            if self.stage_name.endswith("/")
-            else f"{self.stage_name}/{self.directory}"
-        )
+        return f"{self.stage_name.rstrip('/')}/{self.directory}"
 
-    def add_stage_prefix(self, file_path: str) -> str:
+    @classmethod
+    def get_directory(cls, stage_path: str) -> str:
+        return "/".join(Path(stage_path).parts[3:])
+
+    @property
+    def full_path(self) -> str:
+        return f"{self.stage.rstrip('/')}/{self.directory}"
+
+    def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
         file_path_without_prefix = Path(file_path).parts[1:]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
+    def add_stage_prefix(self, file_path: str) -> str:
+        stage = self.stage.rstrip("/")
+        return f"{stage}/{file_path.lstrip('/')}"
+
     def get_directory_from_file_path(self, file_path: str) -> List[str]:
         stage_path_length = len(Path(self.directory).parts)
         return list(Path(file_path).parts[3 + stage_path_length : -1])

snowflake/cli/_plugins/nativeapp/codegen/compiler.py

@@ -14,8 +14,11 @@
 
 from __future__ import annotations
 
+import copy
+import re
 from typing import Dict, Optional
 
+from click import ClickException
 from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
 from snowflake.cli._plugins.nativeapp.codegen.artifact_processor import (
     ArtifactProcessor,
@@ -27,6 +30,9 @@ from snowflake.cli._plugins.nativeapp.codegen.setup.native_app_setup_processor i
 from snowflake.cli._plugins.nativeapp.codegen.snowpark.python_processor import (
     SnowparkAnnotationProcessor,
 )
+from snowflake.cli._plugins.nativeapp.codegen.templates.templates_processor import (
+    TemplatesProcessor,
+)
 from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.project.schemas.native_app.path_mapping import (
@@ -34,11 +40,13 @@ from snowflake.cli.api.project.schemas.native_app.path_mapping import (
 )
 
 SNOWPARK_PROCESSOR = "snowpark"
-NA_SETUP_PROCESSOR = "native-app-setup"
+NA_SETUP_PROCESSOR = "native app setup"
+TEMPLATES_PROCESSOR = "templates"
 
 _REGISTERED_PROCESSORS_BY_NAME = {
     SNOWPARK_PROCESSOR: SnowparkAnnotationProcessor,
     NA_SETUP_PROCESSOR: NativeAppSetupProcessor,
+    TEMPLATES_PROCESSOR: TemplatesProcessor,
 }
 
 
@@ -110,7 +118,15 @@ class NativeAppCompiler:
             # No registered processor with the specified name
             return None
 
-        current_processor = processor_factory(self._bundle_ctx)
+        processor_ctx = copy.copy(self._bundle_ctx)
+        processor_subdirectory = re.sub(r"[^a-zA-Z0-9_$]", "_", processor_name)
+        processor_ctx.bundle_root = (
+            self._bundle_ctx.bundle_root / processor_subdirectory
+        )
+        processor_ctx.generated_root = (
+            self._bundle_ctx.generated_root / processor_subdirectory
+        )
+        current_processor = processor_factory(processor_ctx)
         self.cached_processors[processor_name] = current_processor
 
         return current_processor