snowflake-cli 3.3.0__py3-none-any.whl → 3.5.0__py3-none-any.whl

snowflake/cli/api/artifacts/utils.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
+from snowflake.cli.api.artifacts.common import NotInDeployRootError
+from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.project.schemas.entities.common import Artifacts
+from snowflake.cli.api.secure_path import SecurePath
+from snowflake.cli.api.utils.path_utils import delete, resolve_without_follow
+
+
+def symlink_or_copy(src: Path, dst: Path, deploy_root: Path) -> None:
+    """
+    Symlinks files from src to dst. If the src contains parent directories, then copies the empty directory shell to the deploy root.
+    The directory hierarchy above dst is created if any of those directories do not exist.
+    """
+    ssrc = SecurePath(src)
+    sdst = SecurePath(dst)
+    sdst.parent.mkdir(parents=True, exist_ok=True)
+
+    # Verify that the mapping isn't accidentally trying to create a file in the project source through symlinks.
+    # We need to ensure we're resolving symlinks for this check to be effective.
+    # We are unlikely to hit this if calling the function through bundle map, keeping it here for other future use cases outside bundle.
+    resolved_dst = dst.resolve()
+    resolved_deploy_root = deploy_root.resolve()
+    dst_is_deploy_root = resolved_deploy_root == resolved_dst
+    if (not dst_is_deploy_root) and (resolved_deploy_root not in resolved_dst.parents):
+        raise NotInDeployRootError(dest_path=dst, deploy_root=deploy_root, src_path=src)
+
+    absolute_src = resolve_without_follow(src)
+    if absolute_src.is_file():
+        delete(dst)
+        try:
+            os.symlink(absolute_src, dst)
+        except OSError:
+            ssrc.copy(dst)
+    else:
+        # 1. Create a new directory in the deploy root
+        sdst.mkdir(exist_ok=True)
+        # 2. For all children of src, create their counterparts in dst now that it exists
+        for root, _, files in sorted(os.walk(absolute_src, followlinks=True)):
+            relative_root = Path(root).relative_to(absolute_src)
+            absolute_root_in_deploy = Path(dst, relative_root)
+            SecurePath(absolute_root_in_deploy).mkdir(parents=True, exist_ok=True)
+            for file in sorted(files):
+                absolute_file_in_project = Path(absolute_src, relative_root, file)
+                absolute_file_in_deploy = Path(absolute_root_in_deploy, file)
+                symlink_or_copy(
+                    src=absolute_file_in_project,
+                    dst=absolute_file_in_deploy,
+                    deploy_root=deploy_root,
+                )
+
+
+def bundle_artifacts(project_paths: ProjectPaths, artifacts: Artifacts) -> BundleMap:
+    """
+    Creates a bundle directory (project_paths.bundle_root) with all artifacts (using symlink_or_copy function above).
+    Previous contents of the directory are deleted.
+
+    Returns a BundleMap containing the mapping between artifacts and their location in bundle directory.
+    """
+    bundle_map = BundleMap(
+        project_root=project_paths.project_root,
+        deploy_root=project_paths.bundle_root,
+    )
+    for artifact in artifacts:
+        bundle_map.add(artifact)
+
+    project_paths.remove_up_bundle_root()
+    for absolute_src, absolute_dest in bundle_map.all_mappings(
+        absolute=True, expand_directories=True
+    ):
+        # We treat the bundle root as deploy root
+        symlink_or_copy(
+            absolute_src,
+            absolute_dest,
+            deploy_root=project_paths.bundle_root,
+        )
+
+    return bundle_map

snowflake/cli/api/cli_global_context.py

@@ -19,7 +19,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass, field, replace
 from functools import wraps
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator
+from typing import TYPE_CHECKING, Iterator, Optional
 
 from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
 from snowflake.cli.api.exceptions import MissingConfiguration
@@ -196,6 +196,19 @@ class _CliGlobalContextAccess:
         """Computes whether cli_console output should be muted."""
         return self._manager.output_format == OutputFormat.JSON
 
+    @property
+    def snow_api_root(
+        self,
+    ) -> Optional[
+        object
+    ]:  # Should be Optional[Root], but we need local import for performance reasons
+        from snowflake.core import Root
+
+        if self.connection:
+            return Root(self.connection)
+        else:
+            return None
+
 
 _CLI_CONTEXT_MANAGER: ContextVar[_CliGlobalContextManager | None] = ContextVar(
     "cli_context", default=None

snowflake/cli/api/commands/flags.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import tempfile
 from pathlib import Path
 from typing import Any, Callable, Optional
 
@@ -95,7 +94,7 @@ TemporaryConnectionOption = typer.Option(
     False,
     "--temporary-connection",
     "-x",
-    help="Uses connection defined with command line parameters, instead of one defined in config",
+    help="Uses a connection defined with command line parameters, instead of one defined in config",
     callback=_connection_callback("temporary_connection"),
     is_flag=True,
     rich_help_panel=_CONNECTION_SECTION,
@@ -277,7 +276,7 @@ MfaPasscodeOption = typer.Option(
 EnableDiagOption = typer.Option(
     False,
     "--enable-diag",
-    help="Run Python connector diagnostic test",
+    help="Whether to generate a connection diagnostic report.",
     callback=_connection_callback("enable_diag"),
     show_default=False,
     is_flag=True,
@@ -286,20 +285,29 @@ EnableDiagOption = typer.Option(
 
 # Set default via callback to avoid including tempdir path in generated docs (snow --docs).
 # Use constant instead of None, as None is removed from telemetry data.
-_DIAG_LOG_DEFAULT_VALUE = "<temporary_directory>"
+_DIAG_LOG_DEFAULT_VALUE = "<system_temporary_directory>"
 
 
 def _diag_log_path_callback(path: str):
     if path == _DIAG_LOG_DEFAULT_VALUE:
+        import tempfile
+
         path = tempfile.gettempdir()
-    get_cli_context_manager().connection_context.diag_log_path = Path(path)
-    return path
+
+    absolute_path = Path(path).absolute()
+    if not absolute_path.exists():
+        # if the path does not exist the report is not generated
+        from snowflake.cli.api.secure_path import SecurePath
+
+        SecurePath(absolute_path).mkdir(parents=True)
+
+    return _connection_callback("diag_log_path")(absolute_path)
 
 
 DiagLogPathOption: Path = typer.Option(
     _DIAG_LOG_DEFAULT_VALUE,
     "--diag-log-path",
-    help="Diagnostic report path",
+    help="Path for the generated report. Defaults to system temporary directory.",
     callback=_diag_log_path_callback,
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -307,11 +315,17 @@ DiagLogPathOption: Path = typer.Option(
     writable=True,
 )
 
+
+def _diag_log_allowlist_path_callback(path: str):
+    absolute_path = Path(path).absolute() if path else None
+    return _connection_callback("diag_allowlist_path")(absolute_path)
+
+
 DiagAllowlistPathOption: Path = typer.Option(
     None,
     "--diag-allowlist-path",
-    help="Diagnostic report path to optional allowlist",
-    callback=_connection_callback("diag_allowlist_path"),
+    help="Path to a JSON file containing allowlist parameters.",
+    callback=_diag_log_allowlist_path_callback,
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -383,6 +397,12 @@ ReplaceOption = OverrideableOption(
     mutually_exclusive=CREATE_MODE_OPTION_NAMES,
 )
 
+ForceReplaceOption = OverrideableOption(
+    False,
+    "--force-replace",
+    help="Replace this object, even if the state didn't change",
+)
+
 OnErrorOption = typer.Option(
     OnErrorType.BREAK.value,
     "--on-error",
@@ -486,9 +506,10 @@ def identifier_argument(
     example: str,
     click_type: click.ParamType = IdentifierType(),
     callback: Callable | None = None,
+    is_optional: bool = False,
 ) -> typer.Argument:
     return typer.Argument(
-        ...,
+        None if is_optional else ...,
         help=f"Identifier of the {sf_object}; for example: {example}",
         show_default=False,
         click_type=click_type,
@@ -531,8 +552,8 @@ def project_definition_option(is_optional: bool):
         None,
         "-p",
         "--project",
-        help=f"Path where Snowflake project resides. "
-        f"Defaults to current working directory.",
+        help=f"Path where the Snowflake project is stored. "
+        f"Defaults to the current working directory.",
         callback=project_path_callback,
         show_default=False,
     )
@@ -551,7 +572,7 @@ def project_env_overrides_option():
     return typer.Option(
         [],
         "--env",
-        help="String in format of key=value. Overrides variables from env section used for templates.",
+        help="String in the format key=value. Overrides variables from the env section used for templates.",
         callback=project_env_overrides_callback,
         show_default=False,
     )

snowflake/cli/api/commands/snow_typer.py

@@ -19,6 +19,7 @@ import logging
 from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
+import click
 import typer
 from click import ClickException
 from snowflake.cli.api.commands.decorators import (
@@ -35,10 +36,20 @@ from snowflake.cli.api.output.types import CommandResult
 from snowflake.cli.api.sanitizers import sanitize_for_terminal
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector import DatabaseError
+from typer.core import TyperGroup
 
 log = logging.getLogger(__name__)
 
 
+class SortedTyperGroup(TyperGroup):
+    def list_commands(self, ctx: click.Context) -> List[str]:
+        """
+        From Typer 0.13.0 help items are in order of definition, this function override that approach.
+        Returns a list of subcommand names in the alphabetic order.
+        """
+        return sorted(self.commands)
+
+
 class SnowTyper(typer.Typer):
     def __init__(self, /, **kwargs):
         self._sanitize_kwargs(kwargs)
@@ -49,6 +60,7 @@ class SnowTyper(typer.Typer):
             no_args_is_help=True,
             add_completion=True,
             rich_markup_mode="markdown",
+            cls=SortedTyperGroup,
         )
 
     @staticmethod

snowflake/cli/api/commands/utils.py

@@ -1,7 +1,11 @@
-from typing import List, Optional
+from __future__ import annotations
 
-from click import ClickException
+from typing import Dict, List, Optional
+
+from click import ClickException, UsageError
 from snowflake.cli.api.commands.common import Variable
+from snowflake.cli.api.exceptions import NoProjectDefinitionError
+from snowflake.cli.api.project.schemas.entities.common import EntityModelBase
 
 
 def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
@@ -16,3 +20,27 @@ def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
         key, value = p.split("=", 1)
         result.append(Variable(key.strip(), value.strip()))
     return result
+
+
+def get_entity_for_operation(
+    cli_context,
+    entity_id: str | None,
+    project_definition,
+    entity_type: str,
+):
+    entities: Dict[str, EntityModelBase] = project_definition.get_entities_by_type(
+        entity_type=entity_type
+    )
+    if not entities:
+        raise NoProjectDefinitionError(
+            project_type=entity_type, project_root=cli_context.project_root
+        )
+    if entity_id and entity_id not in entities:
+        raise UsageError(f"No '{entity_id}' entity in project definition file.")
+    if len(entities.keys()) == 1:
+        entity_id = list(entities.keys())[0]
+    if entity_id is None:
+        raise UsageError(
+            f"Multiple entities of type {entity_type} found. Please provide entity id for the operation."
+        )
+    return entities[entity_id]

snowflake/cli/api/config.py

@@ -20,7 +20,7 @@ import warnings
 from contextlib import contextmanager
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 import tomlkit
 from click import ClickException
@@ -58,6 +58,7 @@ PLUGINS_SECTION = "plugins"
 
 LOGS_SECTION_PATH = [CLI_SECTION, LOGS_SECTION]
 PLUGINS_SECTION_PATH = [CLI_SECTION, PLUGINS_SECTION]
+PLUGIN_ENABLED_KEY = "enabled"
 FEATURE_FLAGS_SECTION_PATH = [CLI_SECTION, "features"]
 
 CONFIG_MANAGER.add_option(
@@ -140,8 +141,7 @@ def add_connection_to_proper_file(name: str, connection_config: ConnectionConfig
         return CONNECTIONS_FILE
     else:
         set_config_value(
-            section=CONNECTIONS_SECTION,
-            key=name,
+            path=[CONNECTIONS_SECTION, name],
             value=connection_config.to_dict_of_all_non_empty_values(),
         )
         return CONFIG_MANAGER.file_path
@@ -200,14 +200,19 @@ def _initialise_logs_section():
             conf_file_cache[CLI_SECTION][LOGS_SECTION] = _DEFAULT_LOGS_CONFIG
 
 
-def set_config_value(section: str | None, key: str, value: Any):
+def set_config_value(path: List[str], value: Any) -> None:
+    """Sets value in config.
+    For example to set value "val" to key "key" in section [a.b.c], call
+    set_config_value(["a", "b", "c", "key"], "val").
+    If you want to override a whole section, value should be a dictionary.
+    """
     with _config_file() as conf_file_cache:
-        if section:
-            if conf_file_cache.get(section) is None:
-                conf_file_cache[section] = {}
-            conf_file_cache[section][key] = value
-        else:
-            conf_file_cache[key] = value
+        current_config_dict = conf_file_cache
+        for key in path[:-1]:
+            if key not in current_config_dict:
+                current_config_dict[key] = {}
+            current_config_dict = current_config_dict[key]
+        current_config_dict[path[-1]] = value
 
 
 def get_logs_config() -> dict:

snowflake/cli/api/constants.py

@@ -45,6 +45,7 @@ class ObjectType(Enum):
     )
     # JOB = ObjectNames("job", "job", "jobs")
     NETWORK_RULE = ObjectNames("network-rule", "network rule", "network rules")
+    NOTEBOOK = ObjectNames("notebook", "notebook", "notebooks")
     PROCEDURE = ObjectNames("procedure", "procedure", "procedures")
     ROLE = ObjectNames("role", "role", "roles")
     SCHEMA = ObjectNames("schema", "schema", "schemas")

snowflake/cli/api/entities/common.py

@@ -1,40 +1,16 @@
 import functools
-from enum import Enum
 from pathlib import Path
 from typing import Generic, Type, TypeVar, get_args
 
 from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
-from snowflake.cli.api.cli_global_context import span
+from snowflake.cli.api.cli_global_context import get_cli_context, span
+from snowflake.cli.api.entities.resolver import DependencyResolver
+from snowflake.cli.api.entities.utils import EntityActions, get_sql_executor
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutor
 from snowflake.connector import SnowflakeConnection
 from snowflake.connector.cursor import SnowflakeCursor
 
-
-class EntityActions(str, Enum):
-    BUNDLE = "action_bundle"
-    DEPLOY = "action_deploy"
-    DROP = "action_drop"
-    VALIDATE = "action_validate"
-    EVENTS = "action_events"
-
-    VERSION_LIST = "action_version_list"
-    VERSION_CREATE = "action_version_create"
-    VERSION_DROP = "action_version_drop"
-
-    RELEASE_DIRECTIVE_UNSET = "action_release_directive_unset"
-    RELEASE_DIRECTIVE_SET = "action_release_directive_set"
-    RELEASE_DIRECTIVE_LIST = "action_release_directive_list"
-
-    RELEASE_CHANNEL_LIST = "action_release_channel_list"
-    RELEASE_CHANNEL_ADD_ACCOUNTS = "action_release_channel_add_accounts"
-    RELEASE_CHANNEL_REMOVE_ACCOUNTS = "action_release_channel_remove_accounts"
-    RELEASE_CHANNEL_ADD_VERSION = "action_release_channel_add_version"
-    RELEASE_CHANNEL_REMOVE_VERSION = "action_release_channel_remove_version"
-
-    PUBLISH = "action_publish"
-
-
 T = TypeVar("T")
 
 
@@ -71,6 +47,7 @@ class EntityBase(Generic[T]):
     def __init__(self, entity_model: T, workspace_ctx: WorkspaceContext):
         self._entity_model = entity_model
         self._workspace_ctx = workspace_ctx
+        self.dependency_resolver = DependencyResolver(entity_model)
 
     @property
     def entity_id(self) -> str:
@@ -96,7 +73,10 @@ class EntityBase(Generic[T]):
     ):
         """
         Performs the requested action.
+        This is a preferred way to perform actions on entities, over calling actions directly,
+        as it will also call the dependencies in the correct order.
         """
+        self.dependency_resolver.perform_for_dep(action, action_ctx, *args, **kwargs)
         return getattr(self, action)(action_ctx, *args, **kwargs)
 
     @property
@@ -124,10 +104,17 @@ class EntityBase(Generic[T]):
     def _conn(self) -> SnowflakeConnection:
         return self._sql_executor._conn  # noqa
 
+    @property
+    def snow_api_root(self):
+        return get_cli_context().snow_api_root
+
     @property
     def model(self):
         return self._entity_model
 
+    def dependent_entities(self, action_ctx: ActionContext):
+        return self.dependency_resolver.depends_on(action_ctx)
+
     def get_usage_grant_sql(self, app_role: str) -> str:
         return f"GRANT USAGE ON {self.model.type.upper()} {self.identifier} TO ROLE {app_role};"
 
@@ -136,8 +123,3 @@ class EntityBase(Generic[T]):
 
     def get_drop_sql(self) -> str:
         return f"DROP {self.model.type.upper()} {self.identifier};"
-
-
-def get_sql_executor() -> SqlExecutor:
-    """Returns an SQL Executor that uses the connection from the current CLI context"""
-    return SqlExecutor()

snowflake/cli/api/entities/resolver.py

@@ -0,0 +1,160 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Tuple
+
+from snowflake.cli._plugins.workspace.context import ActionContext
+from snowflake.cli.api.entities.utils import EntityActions
+from snowflake.cli.api.exceptions import CycleDetectedError
+from snowflake.cli.api.project.schemas.entities.common import EntityModelBase
+from snowflake.cli.api.utils.graph import Graph, Node
+
+
+@dataclass
+class Dependency:
+    entity_id: str
+    call_arguments: Dict[str, Any]
+
+    def __eq__(self, other):
+        return self.entity_id == other.entity_id
+
+    def __hash__(self):
+        return hash(self.entity_id)
+
+
+class DependencyResolver:
+    """
+    Base class for resolving dependencies logic.
+    Any logic for resolving dependencies, calling their actions or validating them should be implemented here.
+    If an entity uses it's specific logic, it should implement its own resolver, inheriting from this one
+    """
+
+    def __init__(self, model: EntityModelBase):
+        self.entity_model = model
+        self.dependencies: List[Dependency] = []
+
+    def depends_on(self, action_ctx: ActionContext) -> List[Dependency]:
+        """
+        Returns a list of entities that this entity depends on.
+        The list is sorted in order they should be called- last one depends on all the previous.
+        """
+        if not self.dependencies:
+            graph = self._create_dependency_graph(action_ctx)
+            self.dependencies = self._check_and_sort_dependencies(graph)
+
+        return self.dependencies
+
+    def perform_for_dep(
+        self, action: EntityActions, action_ctx: ActionContext, *args, **kwargs
+    ):
+        """
+        Method used to perform selected
+        """
+        for dependency in self.depends_on(action_ctx):
+            entity = action_ctx.get_entity(dependency.entity_id)
+            if entity.supports(action):
+                arguments = dependency.call_arguments.get(action.get_action_name, {})
+                getattr(entity, action)(action_ctx, **arguments)
+
+    def _create_dependency_graph(self, action_ctx: ActionContext) -> Graph[Dependency]:
+        """
+        Creates a graph for dependencies. We need the graph, instead of a simple list, because we need to check if
+        calling dependencies actions in selected order is possible.
+        """
+        graph = Graph()
+        depends_on = self.entity_model.meta.depends_on if self.entity_model.meta else []  # type: ignore
+        self_dependency = Dependency(entity_id=self.entity_model.entity_id, call_arguments={})  # type: ignore
+        resolved_nodes = set()
+
+        graph.add(Node(key=self_dependency.entity_id, data=self_dependency))
+
+        def _resolve_dependencies(parent_id: str, dependency_id: str) -> None:
+
+            (
+                child_dependencies,
+                call_arguments,
+            ) = self._get_child_dependencies_and_call_arguments(
+                dependency_id=dependency_id, action_ctx=action_ctx
+            )
+
+            if not graph.contains_node(dependency_id):
+                dependency_node = Node(
+                    key=dependency_id,
+                    data=Dependency(
+                        entity_id=dependency_id, call_arguments=call_arguments
+                    ),
+                )
+                graph.add(dependency_node)
+
+            graph.add_directed_edge(parent_id, dependency_id)
+
+            resolved_nodes.add(dependency_node.key)
+
+            for child_dependency in child_dependencies:
+                if child_dependency not in resolved_nodes:
+                    _resolve_dependencies(dependency_node.key, child_dependency)
+                else:
+                    graph.add_directed_edge(dependency_node.key, child_dependency)
+
+        for dependency in depends_on:
+            _resolve_dependencies(self_dependency.entity_id, dependency)
+
+        return graph
+
+    @staticmethod
+    def _check_and_sort_dependencies(
+        graph: Graph[Dependency],
+    ) -> List[Dependency]:
+        """
+        This function is used to check and organize the dependency list.
+        The check has two stages:
+         * Cycle detection in dependency
+         * Clearing duplicate
+
+        In the first stage, if cycle is detected, it raises CycleDetectedError with node causing it specified.
+        The result list, shows entities this one depends on, in order they should be called.
+        Duplicates are removed in a way, that preserves earliest possible call.
+        Last item is removed from the result list, as it is this entity itself.
+        """
+        result = []
+
+        def _on_cycle(node: Node[Dependency]) -> None:
+            raise CycleDetectedError(
+                f"Cycle detected in entity dependencies: {node.key}"
+            )
+
+        def _on_visit(node: Node[Dependency]) -> None:
+            result.append(node.data)
+
+        graph.dfs(on_cycle_action=_on_cycle, visit_action=_on_visit)
+
+        return clear_duplicates_from_list(result)[:-1]
+
+    @staticmethod
+    def _get_child_dependencies_and_call_arguments(
+        dependency_id: str, action_ctx: ActionContext
+    ) -> Tuple[List[str], Dict[str, Any]]:
+        child_dependency = action_ctx.get_entity(dependency_id)
+
+        if not child_dependency:
+            raise ValueError(f"Entity with id {dependency_id} not found in project")
+
+        if child_dependency.model.meta:
+            return (
+                child_dependency.model.meta.depends_on,
+                child_dependency.model.meta.action_arguments,
+            )
+
+        else:
+            return [], {}
+
+    @staticmethod
+    def get_action_name(action: EntityActions) -> str:
+
+        return action.value.split("_")[1]
+
+
+def clear_duplicates_from_list(input_list: list[Any]) -> list[Any]:
+    """
+    Removes duplicates from the input list, preserving the first occurrence.
+    """
+    seen = set()
+    return [x for x in input_list if not (x in seen or seen.add(x))]  # type: ignore