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

snowflake/cli/__about__.py

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

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/commands_registration/builtin_plugins.py

@@ -15,6 +15,7 @@
 from snowflake.cli._plugins.connection import plugin_spec as connection_plugin_spec
 from snowflake.cli._plugins.cortex import plugin_spec as cortex_plugin_spec
 from snowflake.cli._plugins.git import plugin_spec as git_plugin_spec
+from snowflake.cli._plugins.helpers import plugin_spec as migrate_plugin_spec
 from snowflake.cli._plugins.init import plugin_spec as init_plugin_spec
 from snowflake.cli._plugins.nativeapp import plugin_spec as nativeapp_plugin_spec
 from snowflake.cli._plugins.notebook import plugin_spec as notebook_plugin_spec
@@ -31,6 +32,7 @@ from snowflake.cli._plugins.workspace import plugin_spec as workspace_plugin_spe
 def get_builtin_plugin_name_to_plugin_spec():
     plugin_specs = {
         "connection": connection_plugin_spec,
+        "helpers": migrate_plugin_spec,
         "spcs": spcs_plugin_spec,
         "nativeapp": nativeapp_plugin_spec,
         "object": object_plugin_spec,

snowflake/cli/_app/secret.py

@@ -0,0 +1,9 @@
+class SecretType:
+    def __init__(self, value):
+        self.value = value
+
+    def __repr__(self):
+        return "SecretType(***)"
+
+    def __str___(self):
+        return "***"

snowflake/cli/_app/snow_connector.py

@@ -24,12 +24,11 @@ from click.exceptions import ClickException
 from snowflake.cli._app.constants import (
     PARAM_APPLICATION_NAME,
 )
+from snowflake.cli._app.secret import SecretType
 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 +45,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 +84,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 +100,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,13 +195,34 @@ 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])
-        connection_parameters["private_key"] = private_key
+        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.value
+        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 = _load_pem_from_parameters(
+            connection_parameters[private_key_var_name]
+        )
+        private_key = _load_pem_to_der(private_key_pem)
+        connection_parameters["private_key"] = private_key.value
         del connection_parameters[private_key_var_name]
     else:
         raise ClickException(
@@ -191,41 +238,49 @@ 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) -> SecretType:
     with SecurePath(private_key_file).open(
         "rb", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
     ) as f:
-        private_key_pem = f.read()
+        private_key_pem = SecretType(f.read())
+    return private_key_pem
+
+
+def _load_pem_from_parameters(private_key_raw: str) -> SecretType:
+    return SecretType(private_key_raw.encode("utf-8"))
 
-    private_key_passphrase = os.getenv("PRIVATE_KEY_PASSPHRASE", None)
+
+def _load_pem_to_der(private_key_pem: SecretType) -> SecretType:
+    """
+    Given a private key file path (in PEM format), decode key data into DER
+    format
+    """
+    private_key_passphrase = SecretType(os.getenv("PRIVATE_KEY_PASSPHRASE", None))
     if (
-        private_key_pem.startswith(ENCRYPTED_PKCS8_PK_HEADER)
-        and private_key_passphrase is None
+        private_key_pem.value.startswith(ENCRYPTED_PKCS8_PK_HEADER)
+        and private_key_passphrase.value is None
     ):
         raise ClickException(
             "Encrypted private key, you must provide the"
             "passphrase in the environment variable PRIVATE_KEY_PASSPHRASE"
         )
 
-    if not private_key_pem.startswith(
+    if not private_key_pem.value.startswith(
         ENCRYPTED_PKCS8_PK_HEADER
-    ) and not private_key_pem.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
+    ) and not private_key_pem.value.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
         raise ClickException(
             "Private key provided is not in PKCS#8 format. Please use correct format."
         )
 
-    if private_key_pem.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
-        private_key_passphrase = None
+    if private_key_pem.value.startswith(UNENCRYPTED_PKCS8_PK_HEADER):
+        private_key_passphrase = SecretType(None)
 
     return prepare_private_key(private_key_pem, private_key_passphrase)
 
 
-def prepare_private_key(private_key_pem, private_key_passphrase=None):
+def prepare_private_key(
+    private_key_pem: SecretType, private_key_passphrase: SecretType = SecretType(None)
+):
     from cryptography.hazmat.backends import default_backend
     from cryptography.hazmat.primitives.serialization import (
         Encoding,
@@ -234,17 +289,21 @@ def prepare_private_key(private_key_pem, private_key_passphrase=None):
         load_pem_private_key,
     )
 
-    private_key = load_pem_private_key(
-        private_key_pem,
-        (
-            str.encode(private_key_passphrase)
-            if private_key_passphrase is not None
-            else private_key_passphrase
-        ),
-        default_backend(),
+    private_key = SecretType(
+        load_pem_private_key(
+            private_key_pem.value,
+            (
+                str.encode(private_key_passphrase.value)
+                if private_key_passphrase.value is not None
+                else private_key_passphrase.value
+            ),
+            default_backend(),
+        )
     )
-    return private_key.private_bytes(
-        encoding=Encoding.DER,
-        format=PrivateFormat.PKCS8,
-        encryption_algorithm=NoEncryption(),
+    return SecretType(
+        private_key.value.private_bytes(
+            encoding=Encoding.DER,
+            format=PrivateFormat.PKCS8,
+            encryption_algorithm=NoEncryption(),
+        )
     )

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

@@ -14,10 +14,11 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from textwrap import dedent
 from typing import List
 
+from click import UsageError
 from snowflake.cli._plugins.stage.manager import (
     USER_STAGE_PREFIX,
     StageManager,
@@ -27,16 +28,22 @@ from snowflake.cli._plugins.stage.manager import (
 from snowflake.cli.api.identifiers import FQN
 from snowflake.connector.cursor import SnowflakeCursor
 
+# Replace magic numbers with constants
+OMIT_FIRST = slice(1, None)
+OMIT_STAGE = slice(3, None)
+OMIT_STAGE_IN_NEW_LIST_FILES = slice(2, None)
+ONLY_STAGE = slice(3)
+
 
 class GitStagePathParts(StagePathParts):
     def __init__(self, stage_path: str):
         self.stage = GitManager.get_stage_from_path(stage_path)
-        stage_path_parts = Path(stage_path).parts
+        stage_path_parts = GitManager.split_git_path(stage_path)
         git_repo_name = stage_path_parts[0].split(".")[-1]
         if git_repo_name.startswith("@"):
-            git_repo_name = git_repo_name[1:]
+            git_repo_name = git_repo_name[OMIT_FIRST]
         self.stage_name = "/".join([git_repo_name, *stage_path_parts[1:3], ""])
-        self.directory = "/".join(stage_path_parts[3:])
+        self.directory = "/".join(stage_path_parts[OMIT_STAGE])
         self.is_directory = True if stage_path.endswith("/") else False
 
     @property
@@ -45,7 +52,12 @@ class GitStagePathParts(StagePathParts):
 
     @classmethod
     def get_directory(cls, stage_path: str) -> str:
-        return "/".join(Path(stage_path).parts[3:])
+        git_path_parts = GitManager.split_git_path(stage_path)
+        # New file list does not have a stage name at the beginning
+        if stage_path.startswith("/"):
+            return "/".join(git_path_parts[OMIT_STAGE_IN_NEW_LIST_FILES])
+        else:
+            return "/".join(git_path_parts[OMIT_STAGE])
 
     @property
     def full_path(self) -> str:
@@ -53,7 +65,7 @@ class GitStagePathParts(StagePathParts):
 
     def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
-        file_path_without_prefix = Path(file_path).parts[1:]
+        file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
     def add_stage_prefix(self, file_path: str) -> str:
@@ -95,7 +107,8 @@ class GitManager(StageManager):
         Returns stage name from potential path on stage. For example
         repo/branches/main/foo/bar -> repo/branches/main/
         """
-        return f"{'/'.join(Path(path).parts[0:3])}/"
+        path_parts = GitManager.split_git_path(path)
+        return f"{'/'.join(path_parts[ONLY_STAGE])}/"
 
     @staticmethod
     def _stage_path_part_factory(stage_path: str) -> StagePathParts:
@@ -103,3 +116,36 @@ class GitManager(StageManager):
         if stage_path.startswith(USER_STAGE_PREFIX):
             return UserStagePathParts(stage_path)
         return GitStagePathParts(stage_path)
+
+    @staticmethod
+    def split_git_path(path: str):
+        # Check if path contains quotes and split it accordingly
+        if '/"' in path and '"/' in path:
+            if path.count('"') > 2:
+                raise UsageError(
+                    f'Invalid string {path}, too much " in path, expected 2.'
+                )
+
+            path_parts = path.split('"')
+            before_quoted_part = GitManager._split_path_without_empty_parts(
+                path_parts[0]
+            )
+
+            if path_parts[2] == "/":
+                after_quoted_part = []
+            else:
+                after_quoted_part = GitManager._split_path_without_empty_parts(
+                    path_parts[2]
+                )
+
+            return [
+                *before_quoted_part,
+                f'"{path_parts[1]}"',
+                *after_quoted_part,
+            ]
+        else:
+            return GitManager._split_path_without_empty_parts(path)
+
+    @staticmethod
+    def _split_path_without_empty_parts(path: str):
+        return [e for e in PurePosixPath(path).parts if e != "/"]