snowflake-cli-labs 2.5.0rc3__py3-none-any.whl → 2.6.0__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "2.5.0rc3"
+VERSION = "2.6.0"

snowflake/cli/api/cli_global_context.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import re
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Callable, Optional
 
 from snowflake.cli.api.exceptions import InvalidSchemaError
 from snowflake.cli.api.output.formats import OutputFormat
@@ -226,6 +226,9 @@ class _CliGlobalContextManager:
         self._experimental = False
         self._project_definition = None
         self._project_root = None
+        self._project_path_arg = None
+        self._project_env_overrides_args = {}
+        self._typer_pre_execute_commands = []
         self._template_context = None
         self._silent: bool = False
 
@@ -261,10 +264,10 @@ class _CliGlobalContextManager:
         self._experimental = value
 
     @property
-    def project_definition(self) -> Optional[Dict]:
+    def project_definition(self) -> Optional[ProjectDefinition]:
         return self._project_definition
 
-    def set_project_definition(self, value: Dict):
+    def set_project_definition(self, value: ProjectDefinition):
         self._project_definition = value
 
     @property
@@ -274,6 +277,22 @@ class _CliGlobalContextManager:
     def set_project_root(self, project_root: Path):
         self._project_root = project_root
 
+    @property
+    def project_path_arg(self) -> Optional[str]:
+        return self._project_path_arg
+
+    def set_project_path_arg(self, project_path_arg: str):
+        self._project_path_arg = project_path_arg
+
+    @property
+    def project_env_overrides_args(self) -> dict[str, str]:
+        return self._project_env_overrides_args
+
+    def set_project_env_overrides_args(
+        self, project_env_overrides_args: dict[str, str]
+    ):
+        self._project_env_overrides_args = project_env_overrides_args
+
     @property
     def template_context(self) -> dict:
         return self._template_context
@@ -281,6 +300,15 @@ class _CliGlobalContextManager:
     def set_template_context(self, template_context: dict):
         self._template_context = template_context
 
+    @property
+    def typer_pre_execute_commands(self) -> list[Callable[[], None]]:
+        return self._typer_pre_execute_commands
+
+    def add_typer_pre_execute_commands(
+        self, typer_pre_execute_command: Callable[[], None]
+    ):
+        self._typer_pre_execute_commands.append(typer_pre_execute_command)
+
     @property
     def connection_context(self) -> _ConnectionContext:
         return self._connection_context

snowflake/cli/api/commands/decorators.py

@@ -43,7 +43,8 @@ from snowflake.cli.api.commands.flags import (
     VerboseOption,
     WarehouseOption,
     experimental_option,
-    project_type_option,
+    project_definition_option,
+    project_env_overrides_option,
 )
 from snowflake.cli.api.exceptions import CommandReturnTypeError
 from snowflake.cli.api.output.formats import OutputFormat
@@ -72,8 +73,11 @@ def global_options_with_connection(func: Callable):
     )
 
 
-def with_project_definition(project_name: str):
+def with_project_definition(
+    project_name: Optional[str] = None, is_optional: bool = False
+):
     def _decorator(func: Callable):
+
         return _options_decorator_factory(
             func,
             additional_options=[
@@ -81,8 +85,14 @@ def with_project_definition(project_name: str):
                     "project_definition",
                     inspect.Parameter.KEYWORD_ONLY,
                     annotation=Optional[str],
-                    default=project_type_option(project_name),
-                )
+                    default=project_definition_option(project_name, is_optional),
+                ),
+                inspect.Parameter(
+                    "env_overrides",
+                    inspect.Parameter.KEYWORD_ONLY,
+                    annotation=List[str],
+                    default=project_env_overrides_option(),
+                ),
             ],
         )
 
@@ -115,7 +125,7 @@ def with_experimental_behaviour(
     return decorator
 
 
-def _execute_before_command_using_global_options():
+def _execute_before_command_using_global_options(**options):
     from snowflake.cli.app.loggers import create_loggers
 
     create_loggers(cli_context.verbose, cli_context.enable_tracebacks)
@@ -136,10 +146,15 @@ def _options_decorator_factory(
     additional_options: List[inspect.Parameter],
     execute_before_command_using_new_options: Optional[Callable] = None,
 ):
+    """
+    execute_before_command_using_new_options executes before command telemetry has been emitted,
+    but after command line options have been populated.
+    """
+
     @wraps(func)
     def wrapper(**options):
         if execute_before_command_using_new_options:
-            execute_before_command_using_new_options()
+            execute_before_command_using_new_options(**options)
         return func(**options)
 
     wrapper.__signature__ = _extend_signature_with_additional_options(func, additional_options)  # type: ignore

snowflake/cli/api/commands/flags.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import os
 import tempfile
 from dataclasses import dataclass
 from enum import Enum
@@ -26,9 +25,11 @@ import click
 import typer
 from click import ClickException
 from snowflake.cli.api.cli_global_context import cli_context_manager
+from snowflake.cli.api.commands.typer_pre_execute import register_pre_execute_command
 from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.exceptions import MissingConfiguration
+from snowflake.cli.api.exceptions import MissingConfiguration, NoProjectDefinitionError
 from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.project.definition_manager import DefinitionManager
 from snowflake.cli.api.utils.rendering import CONTEXT_KEY
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
@@ -499,70 +500,74 @@ def execution_identifier_argument(sf_object: str, example: str) -> typer.Argumen
     )
 
 
-def project_type_option(project_name: str):
-    from snowflake.cli.api.exceptions import NoProjectDefinitionError
-    from snowflake.cli.api.project.definition_manager import DefinitionManager
+def register_project_definition(project_name: Optional[str], is_optional: bool) -> None:
+    project_path = cli_context_manager.project_path_arg
+    env_overrides_args = cli_context_manager.project_env_overrides_args
 
-    def _callback(project_path: Optional[str]):
-        dm = DefinitionManager(project_path)
-        project_definition = getattr(dm.project_definition, project_name, None)
-        project_root = dm.project_root
+    dm = DefinitionManager(project_path, {CONTEXT_KEY: {"env": env_overrides_args}})
+    project_definition = dm.project_definition
+    project_root = dm.project_root
+    template_context = dm.template_context
 
-        if not project_definition:
-            raise NoProjectDefinitionError(
-                project_type=project_name, project_file=project_path
-            )
+    if not dm.has_definition_file and not is_optional:
+        raise MissingConfiguration(
+            "Cannot find project definition (snowflake.yml). Please provide a path to the project or run this command in a valid project directory."
+        )
+
+    if project_name is not None and not getattr(project_definition, project_name, None):
+        raise NoProjectDefinitionError(
+            project_type=project_name, project_file=project_path
+        )
+
+    cli_context_manager.set_project_definition(project_definition)
+    cli_context_manager.set_project_root(project_root)
+    cli_context_manager.set_template_context(template_context)
 
-        cli_context_manager.set_project_definition(project_definition)
-        cli_context_manager.set_project_root(project_root)
-        cli_context_manager.set_template_context(dm.template_context)
-        return project_definition
 
-    if project_name == "native_app":
-        project_name_help = "Snowflake Native App"
-    elif project_name == "streamlit":
-        project_name_help = "Streamlit app"
+def _get_project_long_name(project_short_name: Optional[str]) -> str:
+    if project_short_name is None:
+        return "Snowflake"
+
+    if project_short_name == "native_app":
+        project_long_name = "Snowflake Native App"
+    elif project_short_name == "streamlit":
+        project_long_name = "Streamlit app"
     else:
-        project_name_help = project_name.replace("_", " ").capitalize()
+        project_long_name = project_short_name.replace("_", " ").capitalize()
+
+    return f"the {project_long_name}"
+
+
+def project_definition_option(project_name: Optional[str], is_optional: bool):
+    def project_definition_callback(project_path: str) -> None:
+        cli_context_manager.set_project_path_arg(project_path)
+        register_pre_execute_command(
+            lambda: register_project_definition(project_name, is_optional)
+        )
 
     return typer.Option(
         None,
         "-p",
         "--project",
-        help=f"Path where the {project_name_help} project resides. "
+        help=f"Path where {_get_project_long_name(project_name)} project resides. "
         f"Defaults to current working directory.",
-        callback=_callback,
+        callback=_callback(lambda: project_definition_callback),
         show_default=False,
     )
 
 
-def project_definition_option(optional: bool = False):
-    from snowflake.cli.api.project.definition_manager import DefinitionManager
-
-    def _callback(project_path: Optional[str]):
-        try:
-            dm = DefinitionManager(project_path)
-            project_definition = dm.project_definition
-            project_root = dm.project_root
-            template_context = dm.template_context
-        except MissingConfiguration:
-            if optional:
-                project_definition = None
-                project_root = None
-                template_context = {CONTEXT_KEY: {"env": os.environ}}
-            else:
-                raise
-        cli_context_manager.set_project_definition(project_definition)
-        cli_context_manager.set_project_root(project_root)
-        cli_context_manager.set_template_context(template_context)
-        return project_definition
+def project_env_overrides_option():
+    def project_env_overrides_callback(env_overrides_args_list: list[str]) -> None:
+        env_overrides_args_map = {
+            v.key: v.value for v in parse_key_value_variables(env_overrides_args_list)
+        }
+        cli_context_manager.set_project_env_overrides_args(env_overrides_args_map)
 
     return typer.Option(
-        None,
-        "-p",
-        "--project",
-        help=f"Path where Snowflake project resides. Defaults to current working directory.",
-        callback=_callback,
+        [],
+        "--env",
+        help="String in format of key=value. Overrides variables from env section used for templating.",
+        callback=_callback(lambda: project_env_overrides_callback),
         show_default=False,
     )
 
@@ -610,9 +615,13 @@ class Variable:
         self.value = value
 
 
-def parse_key_value_variables(variables: List[str]) -> List[Variable]:
+def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
     """Util for parsing key=value input. Useful for commands accepting multiple input options."""
-    result = []
+    result: List[Variable] = []
+
+    if variables is None:
+        return result
+
     for p in variables:
         if "=" not in p:
             raise ClickException(f"Invalid variable: '{p}'")

snowflake/cli/api/commands/snow_typer.py

@@ -25,14 +25,17 @@ from snowflake.cli.api.commands.decorators import (
     global_options_with_connection,
 )
 from snowflake.cli.api.commands.flags import DEFAULT_CONTEXT_SETTINGS
+from snowflake.cli.api.commands.typer_pre_execute import run_pre_execute_commands
 from snowflake.cli.api.exceptions import CommandReturnTypeError
 from snowflake.cli.api.output.types import CommandResult
+from snowflake.cli.api.sanitizers import sanitize_for_terminal
 
 log = logging.getLogger(__name__)
 
 
 class SnowTyper(typer.Typer):
     def __init__(self, /, **kwargs):
+        self._sanitize_kwargs(kwargs)
         super().__init__(
             **kwargs,
             context_settings=DEFAULT_CONTEXT_SETTINGS,
@@ -41,6 +44,21 @@ class SnowTyper(typer.Typer):
             add_completion=True,
         )
 
+    @staticmethod
+    def _sanitize_kwargs(kwargs: Dict):
+        # Sanitize all string options that are visible in terminal output
+        known_keywords = [
+            "help",
+            "short_help",
+            "options_metavar",
+            "rich_help_panel",
+            "epilog",
+        ]
+        for kw in known_keywords:
+            if kw in kwargs:
+                kwargs[kw] = sanitize_for_terminal(kwargs[kw])
+        return kwargs
+
     @wraps(typer.Typer.command)
     def command(
         self,
@@ -55,11 +73,16 @@ class SnowTyper(typer.Typer):
         logic before and after execution as well as process the result and act on possible
         errors.
         """
+        name = sanitize_for_terminal(name)
+        self._sanitize_kwargs(kwargs)
         if is_enabled is not None and not is_enabled():
             return lambda func: func
 
         def custom_command(command_callable):
             """Custom command wrapper similar to Typer.command."""
+            # Sanitize doc string which is used to create help in terminal
+            command_callable.__doc__ = sanitize_for_terminal(command_callable.__doc__)
+
             if requires_connection:
                 command_callable = global_options_with_connection(command_callable)
             elif requires_global_options:
@@ -94,6 +117,7 @@ class SnowTyper(typer.Typer):
         from snowflake.cli.app.telemetry import log_command_usage
 
         log.debug("Executing command pre execution callback")
+        run_pre_execute_commands()
         log_command_usage()
 
     @staticmethod

snowflake/cli/api/commands/typer_pre_execute.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Callable
+
+from snowflake.cli.api.cli_global_context import cli_context_manager
+
+
+def register_pre_execute_command(command: Callable[[], None]) -> None:
+    cli_context_manager.add_typer_pre_execute_commands(command)
+
+
+def run_pre_execute_commands() -> None:
+    for command in cli_context_manager.typer_pre_execute_commands:
+        command()

snowflake/cli/api/console/abc.py

@@ -66,6 +66,14 @@ class AbstractConsole(ABC):
     ) -> Iterator[Callable[[str], None]]:
         """A context manager for organising steps into logical group."""
 
+    @contextmanager
+    @abstractmethod
+    def indented(self):
+        """
+        A context manager for temporarily indenting messages and warnings. Phases and steps cannot be used in indented blocks,
+        but multiple indented blocks can be nested (use sparingly).
+        """
+
     @abstractmethod
     def step(self, message: str):
         """Displays a message to output."""

snowflake/cli/api/console/console.py

@@ -44,22 +44,27 @@ class CliConsole(AbstractConsole):
     """
 
     _indentation_level: int = INDENTATION_LEVEL
+    _extra_indent: int = 0
     _styles: dict = {
         "default": "",
         Output.PHASE: PHASE_STYLE,
         Output.STEP: STEP_STYLE,
-        Output.INFO: INFO_STYLE,
+        Output.INFO: None,
         Output.IMPORTANT: IMPORTANT_STYLE,
     }
 
     def _format_message(self, message: str, output: Output) -> Text:
         """Wraps message in rich Text object and applies formatting."""
         style = self._styles.get(output, "default")
-        text = Text(message, style=style)
+        if style is not None:
+            text = Text(message, style=style)
+        else:
+            text = Text.from_markup(message)
 
+        current_indent = self._extra_indent
         if self.in_phase and output in {Output.STEP, Output.INFO, Output.IMPORTANT}:
-            text.pad_left(self._indentation_level)
-
+            current_indent += 1
+        text.pad_left(current_indent * self._indentation_level)
         return text
 
     @contextmanager
@@ -67,6 +72,10 @@ class CliConsole(AbstractConsole):
         """A context manager for organising steps into logical group."""
         if self.in_phase:
             raise CliConsoleNestingProhibitedError("Only one phase allowed at a time.")
+        if self._extra_indent > 0:
+            raise CliConsoleNestingProhibitedError(
+                "Phase cannot be used in an indented block."
+            )
 
         self._print(self._format_message(enter_message, Output.PHASE))
         self._in_phase = True
@@ -78,11 +87,27 @@ class CliConsole(AbstractConsole):
             if exit_message:
                 self._print(self._format_message(exit_message, Output.PHASE))
 
+    @contextmanager
+    def indented(self):
+        """
+        A context manager for temporarily indenting messages and warnings. Phases and steps cannot be used in indented blocks,
+        but multiple indented blocks can be nested (use sparingly).
+        """
+        self._extra_indent += 1
+        try:
+            yield
+        finally:
+            self._extra_indent -= 1
+
     def step(self, message: str):
         """Displays a message to output.
 
         If called within a phase, the output will be indented.
         """
+        if self._extra_indent > 0:
+            raise CliConsoleNestingProhibitedError(
+                "Step cannot be used in an indented block."
+            )
         text = self._format_message(message, Output.STEP)
         self._print(text)
 

snowflake/cli/api/constants.py

@@ -20,6 +20,7 @@ from pathlib import Path
 
 TEMPLATES_PATH = Path(__file__).parent.parent / "templates"
 DEPLOYMENT_STAGE = "deployments"
+PYTHON_3_12 = (3, 12)
 
 
 @dataclass(frozen=True)
@@ -74,3 +75,5 @@ SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys())
 VALID_SCOPES = ["database", "schema", "compute-pool"]
 
 DEFAULT_SIZE_LIMIT_MB = 128
+
+SF_REST_API_URL_PREFIX = "/api/v2"

snowflake/cli/api/project/definition.py

@@ -14,14 +14,16 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 
-import yaml.loader
+import yaml
 from snowflake.cli.api.cli_global_context import cli_context
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
-from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
+from snowflake.cli.api.project.schemas.project_definition import (
+    ProjectDefinition,
+    ProjectProperties,
+)
 from snowflake.cli.api.project.util import (
     append_to_identifier,
     clean_identifier,
@@ -31,61 +33,41 @@ from snowflake.cli.api.project.util import (
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.utils.definition_rendering import render_definition_template
 from snowflake.cli.api.utils.dict_utils import deep_merge_dicts
-from snowflake.cli.api.utils.types import Definition
-from yaml import load
+from snowflake.cli.api.utils.types import Context, Definition
 
 DEFAULT_USERNAME = "unknown_user"
 
 
-@dataclass
-class ProjectProperties:
-    """
-    This class stores 2 objects representing the project definition:
-
-    The raw_project_definition object:
-    - Only contains data structures like dict, list, and scalars.
-    - The purpose of the raw_project_defintion object is to represent the same structure as the yaml project definition file.
-    - This can be used as a templating context when users reference variables in the project definition file.
-
-    The project_definition object:
-    - This is a transformed object type through Pydantic, which has been normalized.
-    - This object could have slightly different structure than what the users see in their yaml project definition files.
-    - This should be used for the business logic of snow CLI modules.
-    """
-
-    project_definition: ProjectDefinition
-    raw_project_definition: Definition
-
-
-def _get_merged_definitions(paths: List[Path]) -> Definition:
+def _get_merged_definitions(paths: List[Path]) -> Optional[Definition]:
     spaths: List[SecurePath] = [SecurePath(p) for p in paths]
     if len(spaths) == 0:
-        raise ValueError("Need at least one definition file.")
+        return None
 
     with spaths[0].open("r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as base_yml:
-        definition = load(base_yml.read(), Loader=yaml.loader.BaseLoader) or {}
+        definition = yaml.load(base_yml.read(), Loader=yaml.loader.BaseLoader) or {}
 
     for override_path in spaths[1:]:
         with override_path.open(
             "r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
         ) as override_yml:
-            overrides = load(override_yml.read(), Loader=yaml.loader.BaseLoader) or {}
+            overrides = (
+                yaml.load(override_yml.read(), Loader=yaml.loader.BaseLoader) or {}
+            )
             deep_merge_dicts(definition, overrides)
 
     return definition
 
 
-def load_project(paths: List[Path]) -> ProjectProperties:
+def load_project(
+    paths: List[Path], context_overrides: Optional[Context] = None
+) -> ProjectProperties:
     """
     Loads project definition, optionally overriding values. Definition values
     are merged in left-to-right order (increasing precedence).
     Templating is also applied after the merging process.
     """
     merged_definitions = _get_merged_definitions(paths)
-    rendered_definition = render_definition_template(merged_definitions)
-    return ProjectProperties(
-        ProjectDefinition(**rendered_definition), rendered_definition
-    )
+    return render_definition_template(merged_definitions, context_overrides or {})
 
 
 def generate_local_override_yml(

snowflake/cli/api/project/definition_manager.py

@@ -19,10 +19,8 @@ import os
 from pathlib import Path
 from typing import List, Optional
 
-from snowflake.cli.api.exceptions import MissingConfiguration
 from snowflake.cli.api.project.definition import ProjectProperties, load_project
 from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
-from snowflake.cli.api.utils.rendering import CONTEXT_KEY
 from snowflake.cli.api.utils.types import Context
 
 
@@ -42,32 +40,39 @@ class DefinitionManager:
     project_root: Path
     _project_config_paths: List[Path]
 
-    def __init__(self, project_arg: Optional[str] = None) -> None:
+    def __init__(
+        self,
+        project_arg: Optional[str] = None,
+        context_overrides: Optional[Context] = None,
+    ) -> None:
         project_root = Path(
             os.path.abspath(project_arg) if project_arg else os.getcwd()
         )
-        if not self._base_definition_file_if_available(project_root):
-            raise MissingConfiguration(
-                f"Cannot find project definition (snowflake.yml). Please provide a path to the project or run this command in a valid project directory."
-            )
 
         self.project_root = project_root
         self._project_config_paths = self._find_definition_files(self.project_root)
+        self._context_overrides = context_overrides
+
+    @functools.cached_property
+    def has_definition_file(self):
+        return len(self._project_config_paths) > 0
 
     @staticmethod
     def _find_definition_files(project_root: Path) -> List[Path]:
-        base_config_file_path = (
-            project_root / DefinitionManager.BASE_DEFINITION_FILENAME
+        base_config_file_path = DefinitionManager._base_definition_file_if_available(
+            project_root
         )
         user_config_file_path = DefinitionManager._user_definition_file_if_available(
             project_root
         )
-        if user_config_file_path:
-            return [
-                base_config_file_path,
-                user_config_file_path,
-            ]
-        return [base_config_file_path]
+
+        definition_files: List[Path] = []
+        if base_config_file_path:
+            definition_files.append(base_config_file_path)
+            if user_config_file_path:
+                definition_files.append(user_config_file_path)
+
+        return definition_files
 
     @staticmethod
     def find_project_root(search_path: Path) -> Optional[Path]:
@@ -118,7 +123,7 @@ class DefinitionManager:
 
     @functools.cached_property
     def _project_properties(self) -> ProjectProperties:
-        return load_project(self._project_config_paths)
+        return load_project(self._project_config_paths, self._context_overrides)
 
     @functools.cached_property
     def project_definition(self) -> ProjectDefinition:
@@ -126,6 +131,4 @@ class DefinitionManager:
 
     @functools.cached_property
     def template_context(self) -> Context:
-        definition = self._project_properties.raw_project_definition
-
-        return {CONTEXT_KEY: definition}
+        return self._project_properties.project_context