snowflake-cli 3.4.1__py3-none-any.whl → 3.6.0__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,16 @@
 
 from __future__ import annotations
 
-VERSION = "3.4.1"
+from enum import Enum, unique
+
+VERSION = "3.6.0"
+
+
+@unique
+class CLIInstallationSource(Enum):
+    BINARY = "binary"
+    PYPI = "pypi"
+
+
+# This variable is changed in binary release script
+INSTALLATION_SOURCE = CLIInstallationSource.PYPI

snowflake/cli/_app/cli_app.py

@@ -25,9 +25,6 @@ import click
 import typer
 from click import Context as ClickContext
 from snowflake.cli import __about__
-from snowflake.cli._app.api_impl.plugin.plugin_config_provider_impl import (
-    PluginConfigProviderImpl,
-)
 from snowflake.cli._app.commands_registration.commands_registration_with_callbacks import (
     CommandsRegistrationWithCallbacks,
 )
@@ -42,7 +39,6 @@ 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, get_feature_flags_section
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import CollectionResult
@@ -63,12 +59,7 @@ def _do_not_execute_on_completion(callback):
 
 class CliAppFactory:
     def __init__(self):
-        api = Api(plugin_config_provider=PluginConfigProviderImpl())
-        self._api = api
-        self._commands_registration = CommandsRegistrationWithCallbacks(
-            api.plugin_config_provider
-        )
-        api_provider.register_api(api)
+        self._commands_registration = CommandsRegistrationWithCallbacks()
         self._app: Optional[SnowCliMainTyper] = None
         self._click_context: Optional[ClickContext] = None
 

snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.auth.keypair import plugin_spec as auth_plugin_spec
 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
@@ -20,6 +21,8 @@ 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
 from snowflake.cli._plugins.object import plugin_spec as object_plugin_spec
+from snowflake.cli._plugins.plugin import plugin_spec as plugin_plugin_spec
+from snowflake.cli._plugins.project import plugin_spec as project_plugin_spec
 from snowflake.cli._plugins.snowpark import plugin_spec as snowpark_plugin_spec
 from snowflake.cli._plugins.spcs import plugin_spec as spcs_plugin_spec
 from snowflake.cli._plugins.sql import plugin_spec as sql_plugin_spec
@@ -31,11 +34,13 @@ from snowflake.cli._plugins.workspace import plugin_spec as workspace_plugin_spe
 # plugin name to plugin spec
 def get_builtin_plugin_name_to_plugin_spec():
     plugin_specs = {
+        "auth": auth_plugin_spec,
         "connection": connection_plugin_spec,
         "helpers": migrate_plugin_spec,
         "spcs": spcs_plugin_spec,
-        "nativeapp": nativeapp_plugin_spec,
+        "app": nativeapp_plugin_spec,
         "object": object_plugin_spec,
+        "project": project_plugin_spec,
         "snowpark": snowpark_plugin_spec,
         "stage": stage_plugin_spec,
         "sql": sql_plugin_spec,
@@ -45,6 +50,7 @@ def get_builtin_plugin_name_to_plugin_spec():
         "cortex": cortex_plugin_spec,
         "init": init_plugin_spec,
         "workspace": workspace_plugin_spec,
+        "plugin": plugin_plugin_spec,
     }
 
     return plugin_specs

snowflake/cli/_app/commands_registration/command_plugins_loader.py

@@ -47,7 +47,9 @@ class CommandPluginsLoader:
         self._loaded_command_paths: Dict[CommandPath, LoadedCommandPlugin] = {}
 
     def register_builtin_plugins(self) -> None:
-        for plugin_name, plugin in get_builtin_plugin_name_to_plugin_spec().items():
+        for plugin_name, plugin in sorted(
+            get_builtin_plugin_name_to_plugin_spec().items()
+        ):
             try:
                 self._plugin_manager.register(plugin=plugin, name=plugin_name)
             except Exception as ex:

snowflake/cli/_app/commands_registration/commands_registration_with_callbacks.py

@@ -33,8 +33,8 @@ class CommandRegistrationConfig:
 
 
 class CommandsRegistrationWithCallbacks:
-    def __init__(self, plugin_config_provider: PluginConfigProvider):
-        self._plugin_config_provider = plugin_config_provider
+    def __init__(self):
+        self._plugin_config_manager = PluginConfigProvider()
         self._callbacks_after_registration: List[Callable[[], None]] = []
         self._commands_registration_config: CommandRegistrationConfig = (
             CommandRegistrationConfig(enable_external_command_plugins=True)
@@ -58,7 +58,7 @@ class CommandsRegistrationWithCallbacks:
 
     def _register_builtin_and_enabled_external_plugin_commands(self):
         enabled_external_plugins = (
-            self._plugin_config_provider.get_enabled_plugin_names()
+            self._plugin_config_manager.get_enabled_plugin_names()
         )
         loaded_command_plugins = load_builtin_and_external_command_plugins(
             enabled_external_plugins

snowflake/cli/_app/printing.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import json
 import sys
-from datetime import datetime
+from datetime import date, datetime
 from json import JSONEncoder
 from pathlib import Path
 from textwrap import indent
@@ -57,7 +57,7 @@ class CustomJSONEncoder(JSONEncoder):
             return o.result
         if isinstance(o, (CollectionResult, MultipleResults)):
             return list(o.result)
-        if isinstance(o, datetime):
+        if isinstance(o, (date, datetime)):
             return o.isoformat()
         if isinstance(o, Path):
             return str(o)

snowflake/cli/_app/snow_connector.py

@@ -21,12 +21,11 @@ from typing import Dict, Optional
 
 import snowflake.connector
 from click.exceptions import ClickException
-from snowflake.cli.__about__ import VERSION
+from snowflake.cli import __about__
 from snowflake.cli._app.constants import (
     INTERNAL_APPLICATION_NAME,
     PARAM_APPLICATION_NAME,
 )
-from snowflake.cli._app.secret import SecretType
 from snowflake.cli._app.telemetry import command_info
 from snowflake.cli.api.config import (
     get_connection_dict,
@@ -38,6 +37,7 @@ from snowflake.cli.api.exceptions import (
     SnowflakeConnectionError,
 )
 from snowflake.cli.api.feature_flags import FeatureFlag
+from snowflake.cli.api.secret import SecretType
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import SnowflakeConnection
 from snowflake.connector.errors import DatabaseError, ForbiddenError
@@ -56,6 +56,7 @@ SUPPORTED_ENV_OVERRIDES = [
     "authenticator",
     "private_key_file",
     "private_key_path",
+    "private_key_raw",
     "database",
     "schema",
     "role",
@@ -247,7 +248,7 @@ def _update_internal_application_info(connection_parameters: Dict):
     """Update internal application data if ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID is enabled."""
     if FeatureFlag.ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID.is_enabled():
         connection_parameters["internal_application_name"] = INTERNAL_APPLICATION_NAME
-        connection_parameters["internal_application_version"] = VERSION
+        connection_parameters["internal_application_version"] = __about__.VERSION
 
 
 def _load_pem_from_file(private_key_file: str) -> SecretType:
@@ -273,7 +274,7 @@ def _load_pem_to_der(private_key_pem: SecretType) -> SecretType:
         and private_key_passphrase.value is None
     ):
         raise ClickException(
-            "Encrypted private key, you must provide the"
+            "Encrypted private key, you must provide the "
             "passphrase in the environment variable PRIVATE_KEY_PASSPHRASE"
         )
 

snowflake/cli/_app/telemetry.py

@@ -22,7 +22,7 @@ from typing import Any, Dict, Union
 
 import click
 import typer
-from snowflake.cli.__about__ import VERSION
+from snowflake.cli import __about__
 from snowflake.cli._app.constants import PARAM_APPLICATION_NAME
 from snowflake.cli.api.cli_global_context import (
     _CliGlobalContextAccess,
@@ -40,12 +40,6 @@ from snowflake.connector.telemetry import (
 from snowflake.connector.time_util import get_time_millis
 
 
-@unique
-class CLIInstallationSource(Enum):
-    BINARY = "binary"
-    PYPI = "pypi"
-
-
 @unique
 class CLITelemetryField(Enum):
     # Basic information
@@ -172,12 +166,6 @@ def _get_definition_version() -> str | None:
     return None
 
 
-def _get_installation_source() -> CLIInstallationSource:
-    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
-        return CLIInstallationSource.BINARY
-    return CLIInstallationSource.PYPI
-
-
 def _get_ci_environment_type() -> str:
     if "GITHUB_ACTIONS" in os.environ:
         return "GITHUB_ACTIONS"
@@ -214,8 +202,8 @@ class CLITelemetryClient:
     ) -> Dict[str, Any]:
         data = {
             CLITelemetryField.SOURCE: PARAM_APPLICATION_NAME,
-            CLITelemetryField.INSTALLATION_SOURCE: _get_installation_source().value,
-            CLITelemetryField.VERSION_CLI: VERSION,
+            CLITelemetryField.INSTALLATION_SOURCE: __about__.INSTALLATION_SOURCE.value,
+            CLITelemetryField.VERSION_CLI: __about__.VERSION,
             CLITelemetryField.VERSION_OS: platform.platform(),
             CLITelemetryField.VERSION_PYTHON: python_version(),
             CLITelemetryField.COMMAND_CI_ENVIRONMENT: _get_ci_environment_type(),

snowflake/cli/_app/version_check.py

@@ -8,6 +8,8 @@ from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector.config_manager import CONFIG_MANAGER
 
+REPOSITORY_URL = "https://pypi.org/pypi/snowflake-cli/json"
+
 
 def get_new_version_msg() -> str | None:
     last = _VersionCache().get_last_version()
@@ -45,9 +47,7 @@ class _VersionCache:
     @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 = requests.get(REPOSITORY_URL, headers=headers, timeout=3)
         response.raise_for_status()
         return response.json()["info"]["version"]
 
@@ -60,7 +60,7 @@ class _VersionCache:
 
     def _read_latest_version(self) -> Version | None:
         if self._cache_file.exists():
-            data = json.loads(self._cache_file.read_text())
+            data = json.loads(self._cache_file.read_text(file_size_limit_mb=1))
             now = time.time()
             if data[_VersionCache._last_time] > now - 60 * 60:
                 return Version(data[_VersionCache._version])

snowflake/cli/_plugins/auth/__init__.py

@@ -0,0 +1,11 @@
+from snowflake.cli._plugins.auth.keypair.commands import app as keypair_app
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.feature_flags import FeatureFlag
+
+app = SnowTyperFactory(
+    name="auth",
+    help="Manages authentication methods.",
+    is_hidden=lambda: FeatureFlag.ENABLE_AUTH_KEYPAIR.is_disabled(),
+)
+
+app.add_typer(keypair_app)

snowflake/cli/_plugins/auth/keypair/commands.py

@@ -0,0 +1,151 @@
+from pathlib import Path
+
+import typer
+from snowflake.cli._plugins.auth.keypair.manager import AuthManager, PublicKeyProperty
+from snowflake.cli.api.commands.flags import SecretTypeParser
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.output.types import (
+    CollectionResult,
+    CommandResult,
+    MessageResult,
+    SingleQueryResult,
+)
+from snowflake.cli.api.secret import SecretType
+from snowflake.cli.api.secure_path import SecurePath
+
+app = SnowTyperFactory(
+    name="keypair",
+    help="Manages authentication.",
+)
+
+
+KEY_PAIR_DEFAULT_PATH = "~/.ssh"
+
+
+def _show_connection_name_prompt(ctx: typer.Context, value: str):
+    for param in ctx.command.params:
+        if param.name == "connection_name":
+            if value:
+                param.prompt = "Enter connection name"
+            break
+    return value
+
+
+_new_connection_option = typer.Option(
+    True,
+    help="Create a new connection.",
+    prompt="Create a new connection?",
+    callback=_show_connection_name_prompt,
+    show_default=False,
+    hidden=True,
+)
+
+
+_connection_name_option = typer.Option(
+    None,
+    help="The new connection name.",
+    prompt=False,
+    show_default=False,
+    hidden=True,
+)
+
+
+_key_length_option = typer.Option(
+    2048,
+    "--key-length",
+    help="The RSA key length.",
+    prompt="Enter key length",
+)
+
+
+_output_path_option = typer.Option(
+    KEY_PAIR_DEFAULT_PATH,
+    "--output-path",
+    help="The output path for private and public keys",
+    prompt="Enter output path",
+)
+
+
+_private_key_passphrase_option = typer.Option(
+    "",
+    "--private-key-passphrase",
+    help="The private key passphrase.",
+    click_type=SecretTypeParser(),
+    prompt="Enter private key passphrase",
+    hide_input=True,
+    show_default=False,
+)
+
+
+@app.command("setup", requires_connection=True)
+def setup(
+    new_connection: bool = _new_connection_option,
+    connection_name: str = _connection_name_option,
+    key_length: int = _key_length_option,
+    output_path: Path = _output_path_option,
+    private_key_passphrase: SecretType = _private_key_passphrase_option,
+    **options,
+):
+    """
+    Generates the key pair, sets the public key for the user in Snowflake, and creates or updates the connection.
+    """
+    AuthManager().setup(
+        connection_name=connection_name,
+        key_length=key_length,
+        output_path=SecurePath(output_path),
+        private_key_passphrase=private_key_passphrase,
+    )
+    return MessageResult(f"Setup completed.")
+
+
+@app.command("rotate", requires_connection=True)
+def rotate(
+    key_length: int = _key_length_option,
+    output_path: Path = _output_path_option,
+    private_key_passphrase: SecretType = _private_key_passphrase_option,
+    **options,
+):
+    """
+    Rotates the key for the connection. Generates the key pair, sets the public key for the user in Snowflake, and creates or updates the connection.
+    """
+    AuthManager().rotate(
+        key_length=key_length,
+        output_path=SecurePath(output_path),
+        private_key_passphrase=private_key_passphrase,
+    )
+    return MessageResult(f"Rotate completed.")
+
+
+@app.command("list", requires_connection=True)
+def list_keys(**options) -> CommandResult:
+    """
+    Lists the public keys set for the user.
+    """
+    return CollectionResult(AuthManager().list_keys())
+
+
+@app.command("remove", requires_connection=True)
+def remove(
+    public_key_property: PublicKeyProperty = typer.Option(
+        ...,
+        "--key-id",
+        help=f"Local path to the template directory or a URL to Git repository with templates.",
+        show_default=False,
+    ),
+    **options,
+):
+    """
+    Removes the public key for the user.
+    """
+    return SingleQueryResult(
+        AuthManager().remove_public_key(public_key_property=public_key_property)
+    )
+
+
+@app.command("status", requires_connection=True)
+def status(**options):
+    """
+    Verifies the key pair configuration and tests the connection.
+    """
+    AuthManager().status()
+    return MessageResult("Status check completed.")