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

snowflake/cli/__about__.py

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

snowflake/cli/_app/cli_app.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import platform
 import sys
 from dataclasses import dataclass
@@ -141,6 +142,7 @@ def _info_callback(value: bool):
                 {"key": "python_version", "value": sys.version},
                 {"key": "system_info", "value": platform.platform()},
                 {"key": "feature_flags", "value": get_feature_flags_section()},
+                {"key": "SNOWFLAKE_HOME", "value": os.getenv("SNOWFLAKE_HOME")},
             ],
         )
         print_result(result, output_format=OutputFormat.JSON)
@@ -155,6 +157,7 @@ def app_factory() -> SnowCliMainTyper:
         invoke_without_command=True,
         epilog=new_version_msg,
         result_callback=show_new_version_banner_callback(new_version_msg),
+        help=f"Snowflake CLI tool for developers [v{__about__.VERSION}]",
     )
     def default(
         ctx: typer.Context,

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

@@ -5,5 +5,5 @@ Global options
 ===============================================================================
 {% for param in options if not param.hidden %}
 :samp:`{% for p in param.opts %}{{ p }}{{ ", " if not loop.last }}{% endfor %}{% if not param.is_flag %} {{ '{' }}{{ param.name }}{{ '}' }}{% endif %}`
-{% if param.help %}{{ "  " + param.help | replace("`", "``") }}{% if param.help[-1] != '.' %}.{% endif %}{% else %}  TBD{% endif %}
+{% if param.help %}{{ "  " + param.help}}{% if param.help[-1] != '.' %}.{% endif %}{% else %}  TBD{% endif %}
 {% endfor %}

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

@@ -26,7 +26,7 @@ Arguments
         {{ param.make_metavar().replace("[", "").replace("]", "").lower() }}
     {%- endif -%}
     {{ '}' }}`
-{% if param.help %}{{ "  " + param.help | replace("`", "``") | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
+{% if param.help %}{{ "  " + param.help | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
 {% endfor %}
 {% else %}
 
@@ -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("`", "``") | 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 %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
 {% endfor -%}
 {% else %}
 

snowflake/cli/_app/telemetry.py

@@ -14,12 +14,14 @@
 
 from __future__ import annotations
 
+import os
 import platform
 import sys
 from enum import Enum, unique
 from typing import Any, Dict, Union
 
 import click
+import typer
 from snowflake.cli.__about__ import VERSION
 from snowflake.cli._app.constants import PARAM_APPLICATION_NAME
 from snowflake.cli.api.cli_global_context import (
@@ -30,6 +32,7 @@ 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
 from snowflake.cli.api.utils.error_handling import ignore_exceptions
+from snowflake.connector import ProgrammingError
 from snowflake.connector.telemetry import (
     TelemetryData,
     TelemetryField,
@@ -59,6 +62,7 @@ class CLITelemetryField(Enum):
     COMMAND_RESULT_STATUS = "command_result_status"
     COMMAND_OUTPUT_TYPE = "command_output_type"
     COMMAND_EXECUTION_TIME = "command_execution_time"
+    COMMAND_CI_ENVIRONMENT = "command_ci_environment"
     # Configuration
     CONFIG_FEATURE_FLAGS = "config_feature_flags"
     # Metrics
@@ -67,6 +71,9 @@ class CLITelemetryField(Enum):
     EVENT = "event"
     ERROR_MSG = "error_msg"
     ERROR_TYPE = "error_type"
+    ERROR_CODE = "error_code"
+    ERROR_CAUSE = "error_cause"
+    SQL_STATE = "sql_state"
     IS_CLI_EXCEPTION = "is_cli_exception"
     # Project context
     PROJECT_DEFINITION_VERSION = "project_definition_version"
@@ -81,6 +88,43 @@ class TelemetryEvent(Enum):
 TelemetryDict = Dict[Union[CLITelemetryField, TelemetryField], Any]
 
 
+def _is_cli_exception(exception: Exception) -> bool:
+    return isinstance(
+        exception,
+        (
+            click.ClickException,
+            typer.Exit,
+            typer.Abort,
+            BrokenPipeError,
+            KeyboardInterrupt,
+        ),
+    )
+
+
+def _get_additional_exception_information(exception: Exception) -> TelemetryDict:
+    """
+    Attach the errno and sqlstate if the exception or the
+    cause of the exception is a ProgrammingError
+    """
+    additional_info = {}
+
+    if isinstance(exception, ProgrammingError):
+        additional_info[CLITelemetryField.ERROR_CODE] = exception.errno
+        additional_info[CLITelemetryField.SQL_STATE] = exception.sqlstate
+
+    if exception.__cause__:
+        cause = exception.__cause__
+        additional_info[CLITelemetryField.ERROR_CAUSE] = type(cause).__name__
+
+        if isinstance(cause, ProgrammingError):
+            if not additional_info.get(CLITelemetryField.ERROR_CODE):
+                additional_info[CLITelemetryField.ERROR_CODE] = cause.errno
+            if not additional_info.get(CLITelemetryField.SQL_STATE):
+                additional_info[CLITelemetryField.SQL_STATE] = cause.sqlstate
+
+    return additional_info
+
+
 def _get_command_metrics() -> TelemetryDict:
     cli_context = get_cli_context()
 
@@ -110,9 +154,14 @@ def _find_command_info() -> TelemetryDict:
 
 
 def _get_definition_version() -> str | None:
-    cli_context = get_cli_context()
-    if cli_context.project_definition:
-        return cli_context.project_definition.definition_version
+    try:
+        cli_context = get_cli_context()
+        if cli_context.project_definition:
+            return cli_context.project_definition.definition_version
+    except Exception:
+        # Don't let an invalid project definition file break telemetry
+        # (especially for commands that don't normally load it)
+        pass
     return None
 
 
@@ -122,6 +171,20 @@ def _get_installation_source() -> CLIInstallationSource:
     return CLIInstallationSource.PYPI
 
 
+def _get_ci_environment_type() -> str:
+    if "GITHUB_ACTIONS" in os.environ:
+        return "GITHUB_ACTIONS"
+    if "GITLAB_CI" in os.environ:
+        return "GITLAB_CI"
+    if "CIRCLECI" in os.environ:
+        return "CIRCLECI"
+    if "JENKINS_URL" in os.environ or "HUDSON_URL" in os.environ:
+        return "JENKINS"
+    if "TF_BUILD" in os.environ:
+        return "AZURE_DEVOPS"
+    return "UNKNOWN"
+
+
 def command_info() -> str:
     info = _find_command_info()
     command = ".".join(info[CLITelemetryField.COMMAND])
@@ -148,6 +211,7 @@ class CLITelemetryClient:
             CLITelemetryField.VERSION_CLI: VERSION,
             CLITelemetryField.VERSION_OS: platform.platform(),
             CLITelemetryField.VERSION_PYTHON: python_version(),
+            CLITelemetryField.COMMAND_CI_ENVIRONMENT: _get_ci_environment_type(),
             CLITelemetryField.CONFIG_FEATURE_FLAGS: {
                 k: str(v) for k, v in get_feature_flags_section().items()
             },
@@ -202,7 +266,7 @@ def log_command_result(execution: ExecutionMetadata):
 @ignore_exceptions()
 def log_command_execution_error(exception: Exception, execution: ExecutionMetadata):
     exception_type: str = type(exception).__name__
-    is_cli_exception: bool = issubclass(exception.__class__, click.ClickException)
+    is_cli_exception: bool = _is_cli_exception(exception)
     _telemetry.send(
         {
             TelemetryField.KEY_TYPE: TelemetryEvent.CMD_EXECUTION_ERROR.value,
@@ -210,6 +274,7 @@ def log_command_execution_error(exception: Exception, execution: ExecutionMetada
             CLITelemetryField.ERROR_TYPE: exception_type,
             CLITelemetryField.IS_CLI_EXCEPTION: is_cli_exception,
             CLITelemetryField.COMMAND_EXECUTION_TIME: execution.get_duration(),
+            **_get_additional_exception_information(exception),
             **_get_command_metrics(),
         }
     )

snowflake/cli/_plugins/connection/commands.py

@@ -18,9 +18,10 @@ import logging
 import os.path
 
 import typer
-from click import ClickException, Context, Parameter  # type: ignore
+from click import ClickException, Context, Parameter, UsageError  # type: ignore
 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,
@@ -342,7 +343,7 @@ def test(
 @app.command(requires_connection=False)
 def set_default(
     name: str = typer.Argument(
-        help="Name of the connection, as defined in your `config.toml`",
+        help="Name of the connection, as defined in your `config.toml` file",
         show_default=False,
     ),
     **options,
@@ -351,3 +352,40 @@ def set_default(
     get_connection_dict(connection_name=name)
     set_config_value(section=None, key="default_connection_name", value=name)
     return MessageResult(f"Default connection set to: {name}")
+
+
+@app.command(requires_connection=True)
+def generate_jwt(
+    **options,
+) -> CommandResult:
+    """Generate and display a JWT token."""
+    connection_details = get_cli_context().connection_context.update_from_config()
+
+    msq_template = (
+        "{} is not set in the connection context, but required for JWT generation."
+    )
+    if not connection_details.user:
+        raise UsageError(msq_template.format("User"))
+    if not connection_details.account:
+        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(
+            user=connection_details.user,
+            account=connection_details.account,
+            privatekey_path=connection_details.private_key_file,
+            key_password=passphrase,
+        )
+        return MessageResult(token)
+    except ValueError as err:
+        raise ClickException(str(err))

snowflake/cli/_plugins/git/commands.py

@@ -333,12 +333,15 @@ def execute(
     **options,
 ):
     """
-    Execute immediate all files from the repository path. Files can be filtered with glob like pattern,
+    Execute immediate all files from the repository path. Files can be filtered with a glob-like pattern,
     e.g. `@my_repo/branches/main/*.sql`, `@my_repo/branches/main/dev/*`. Only files with `.sql`
-    extension will be executed.
+    or `.py` extension will be executed.
     """
     results = GitManager().execute(
-        stage_path=repository_path, on_error=on_error, variables=variables
+        stage_path_str=repository_path,
+        on_error=on_error,
+        variables=variables,
+        requires_temporary_stage=True,
     )
     return CollectionResult(results)
 

snowflake/cli/_plugins/git/manager.py

@@ -26,6 +26,7 @@ from snowflake.cli._plugins.stage.manager import (
     UserStagePathParts,
 )
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.stage_path import StagePath
 from snowflake.connector.cursor import SnowflakeCursor
 
 # Replace magic numbers with constants
@@ -78,6 +79,10 @@ class GitStagePathParts(StagePathParts):
 
 
 class GitManager(StageManager):
+    @staticmethod
+    def build_path(stage_path: str) -> StagePathParts:
+        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}")
 

snowflake/cli/_plugins/nativeapp/artifacts.py

@@ -225,9 +225,7 @@ class _ArtifactPathMap:
 
         current_is_dir = self._dest_is_dir.get(dest, None)
         if current_is_dir is not None and current_is_dir != is_dir:
-            raise ArtifactError(
-                "Conflicting type for destination path: {canonical_dest}"
-            )
+            raise ArtifactError(f"Conflicting type for destination path: {dest}")
 
         parent = dest.parent
         if parent != dest:
@@ -240,9 +238,21 @@ class BundleMap:
     """
     Computes the mapping between project directory artifacts (aka source artifacts) to their deploy root location
     (aka destination artifact). This information is primarily used when bundling a native applications project.
+
+    :param project_root: The root directory of the project and base for all relative paths. Must be an absolute path.
+    :param deploy_root: The directory where artifacts should be copied to. Must be an absolute path.
     """
 
     def __init__(self, *, project_root: Path, deploy_root: Path):
+        # If a relative path ends up here, it's a bug in the app and can lead to other
+        # subtle bugs as paths would be resolved relative to the current working directory.
+        assert (
+            project_root.is_absolute()
+        ), f"Project root {project_root} must be an absolute path."
+        assert (
+            deploy_root.is_absolute()
+        ), f"Deploy root {deploy_root} must be an absolute path."
+
         self._project_root: Path = resolve_without_follow(project_root)
         self._deploy_root: Path = resolve_without_follow(deploy_root)
         self._artifact_map = _ArtifactPathMap(project_root=self._project_root)

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

@@ -36,7 +36,7 @@ class UnsupportedArtifactProcessorError(ClickException):
 
 
 def is_python_file_artifact(src: Path, _: Path):
-    """Determines whether the provided source path is an existing python file."""
+    """Determines whether the provided source path is an existing Python file."""
     return src.is_file() and src.suffix == ".py"
 
 

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

@@ -65,10 +65,17 @@ class NativeAppCompiler:
         self,
         bundle_ctx: BundleContext,
     ):
+        self._assert_absolute_paths(bundle_ctx)
         self._bundle_ctx = bundle_ctx
         # dictionary of all processors created and shared between different artifact objects.
         self.cached_processors: Dict[str, ArtifactProcessor] = {}
 
+    @staticmethod
+    def _assert_absolute_paths(bundle_ctx: BundleContext):
+        for name in ["Project", "Deploy", "Bundle", "Generated"]:
+            path = getattr(bundle_ctx, f"{name.lower()}_root")
+            assert path.is_absolute(), f"{name} root {path} must be an absolute path."
+
     def compile_artifacts(self):
         """
         Go through every artifact object in the project definition of a native app, and execute processors in order of specification for each of the artifact object.

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

@@ -29,10 +29,10 @@ EnvVars = Mapping[str, str]  # Only support str -> str for cross-platform compat
 
 
 class SandboxExecutionError(ClickException):
-    """An error occurred while executing a python script."""
+    """An error occurred while executing a Python script."""
 
     def __init__(self, error: str):
-        super().__init__(f"Failed to execute python script. {error}")
+        super().__init__(f"Failed to execute Python script. {error}")
 
 
 def _get_active_venv_dir() -> Optional[str]:
@@ -63,7 +63,7 @@ def _execute_python_interpreter(
     env_vars: Optional[EnvVars],
 ) -> subprocess.CompletedProcess:
     if not python_executable:
-        raise SandboxExecutionError("No python executable found")
+        raise SandboxExecutionError("No Python executable found")
 
     if isinstance(python_executable, str) or isinstance(python_executable, Path):
         args = [python_executable]
@@ -106,7 +106,7 @@ def _execute_in_venv(
             f"venv path must be an existing directory: {resolved_venv_path}"
         )
 
-    # find the python interpreter for this environment. There is no need to activate environment prior to invoking the
+    # find the Python interpreter for this environment. There is no need to activate environment prior to invoking the
     # interpreter, as venv maintains the invariant that invoking any of the scripts will set up the virtual environment
     # correctly. activation scripts are only used for convenience in interactive shells.
     if _is_ms_windows():
@@ -116,7 +116,7 @@ def _execute_in_venv(
 
     if not python_executable.is_file():
         raise SandboxExecutionError(
-            f"No venv python executable found: {resolved_venv_path}"
+            f"No venv Python executable found: {resolved_venv_path}"
         )
 
     return _execute_python_interpreter(
@@ -189,14 +189,14 @@ def execute_script_in_sandbox(
     **kwargs,
 ) -> subprocess.CompletedProcess:
     """
-    Executes a python script in a sandboxed environment, and returns its output. The script is executed in a different
+    Executes a Python script in a sandboxed environment, and returns its output. The script is executed in a different
     process. The execution environment is determined by the `env_type` argument. By default, the logic will attempt
     to auto-detect the correct environment by looking for an active venv or conda environment. If none can be found, it
-    will use the system's default python executable, as determined by the user's path. As a last resort, the current
-    python execution environment will be used (still in a subprocess).
+    will use the system's default Python executable, as determined by the user's path. As a last resort, the current
+    Python execution environment will be used (still in a subprocess).
 
     Parameters:
-        script_source (str): The python script to be executed, as a string.
+        script_source (str): The Python script to be executed, as a string.
         env_type: The type of execution environment to use (default: ExecutionEnvironmentType.AUTO_DETECT).
         cwd (Optional[Union[str, Path]]): An optional path to use as the current directory when executing the script.
         timeout (Optional[int]): An optional timeout in seconds when executing the script. Defaults to no timeout.
@@ -248,7 +248,7 @@ def execute_script_in_sandbox(
 class SandboxEnvBuilder(EnvBuilder):
     """
     A virtual environment builder that can be used to build an environment suitable for
-    executing user-provided python scripts in an isolated sandbox.
+    executing user-provided Python scripts in an isolated sandbox.
     """
 
     def __init__(self, path: Path, **kwargs) -> None:

snowflake/cli/_plugins/nativeapp/codegen/setup/native_app_setup_processor.py

@@ -167,14 +167,14 @@ class NativeAppSetupProcessor(ArtifactProcessor):
             )
         except Exception as e:
             raise ClickException(
-                f"Exception while executing python setup script logic: {e}"
+                f"Exception while executing Python setup script logic: {e}"
             )
 
         if result.returncode == 0:
             return json.loads(result.stdout)
         else:
             raise ClickException(
-                f"Failed to execute python setup script logic: {result.stderr}"
+                f"Failed to execute Python setup script logic: {result.stderr}"
             )
 
     def _edit_setup_sql(self, modifications: List[dict]) -> None:

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

@@ -194,7 +194,7 @@ def deannotate_module_source(
 
     module_lines = module_source.splitlines()
     for definition in definitions:
-        # Comment out all decorators. As per the python grammar, decorators must be terminated by a
+        # Comment out all decorators. As per the Python grammar, decorators must be terminated by a
         # new line, so the line ranges can't overlap.
         for decorator in definition.decorator_list:
             decorator_id = _get_decorator_id(decorator)

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

@@ -132,12 +132,12 @@ def _execute_in_sandbox(
         )
     except SandboxExecutionError as sdbx_err:
         cc.warning(
-            f"Could not fetch Snowpark objects from {py_file} due to {sdbx_err}, continuing execution for the rest of the python files."
+            f"Could not fetch Snowpark objects from {py_file} due to {sdbx_err}, continuing execution for the rest of the Python files."
         )
         return None
     except Exception as err:
         cc.warning(
-            f"Could not fetch Snowpark objects from {py_file} due to {err}, continuing execution for the rest of the python files."
+            f"Could not fetch Snowpark objects from {py_file} due to {err}, continuing execution for the rest of the Python files."
         )
         return None
 
@@ -145,22 +145,22 @@ def _execute_in_sandbox(
         cc.warning(
             f"Could not fetch Snowpark objects from {py_file} due to the following error:\n {completed_process.stderr}"
         )
-        cc.warning("Continuing execution for the rest of the python files.")
+        cc.warning("Continuing execution for the rest of the Python files.")
         return None
 
     try:
         return json.loads(completed_process.stdout)
     except Exception as exc:
         cc.warning(
-            f"Could not load JSON into python due to the following exception: {exc}"
+            f"Could not load JSON into Python due to the following exception: {exc}"
         )
-        cc.warning(f"Continuing execution for the rest of the python files.")
+        cc.warning(f"Continuing execution for the rest of the Python files.")
         return None
 
 
 class SnowparkAnnotationProcessor(ArtifactProcessor):
     """
-    Built-in Processor to discover Snowpark-annotated objects in a given set of python files,
+    Built-in Processor to discover Snowpark-annotated objects in a given set of Python files,
     and generate SQL code for creation of extension functions based on those discovered objects.
     """
 
@@ -174,7 +174,7 @@ class SnowparkAnnotationProcessor(ArtifactProcessor):
         **kwargs,
     ) -> None:
         """
-        Collects code annotations from Snowpark python files containing extension functions and augments the existing
+        Collects code annotations from Snowpark Python files containing extension functions and augments the existing
         setup script with generated SQL that registers these functions.
         """
 
@@ -360,7 +360,7 @@ class SnowparkAnnotationProcessor(ArtifactProcessor):
 
     def generate_new_sql_file_name(self, py_file: Path) -> Path:
         """
-        Generates a SQL filename for the generated root from the python file, and creates its parent directories.
+        Generates a SQL filename for the generated root from the Python file, and creates its parent directories.
         """
         relative_py_file = py_file.relative_to(self._bundle_ctx.deploy_root)
         sql_file = Path(