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

snowflake/cli/api/commands/flags.py

@@ -95,7 +95,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,
@@ -383,6 +383,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",
@@ -531,8 +537,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 +557,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/utils.py

@@ -1,7 +1,9 @@
-from typing import List, Optional
+from typing import Dict, List, Optional
 
-from click import ClickException
+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 +18,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/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

snowflake/cli/api/entities/utils.py

@@ -1,13 +1,10 @@
 import os
+from enum import Enum
 from pathlib import Path
 from typing import Any, List, NoReturn, Optional
 
 import jinja2
 from click import ClickException
-from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
-    resolve_without_follow,
-)
 from snowflake.cli._plugins.nativeapp.exceptions import (
     InvalidTemplateInFileError,
     MissingScriptError,
@@ -22,10 +19,11 @@ from snowflake.cli._plugins.stage.diff import (
     sync_local_diff_with_stage,
     to_stage_path,
 )
+from snowflake.cli._plugins.stage.manager import DefaultStagePathParts
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.cli_global_context import get_cli_context, span
 from snowflake.cli.api.console.abc import AbstractConsole
-from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.errno import (
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     NO_WAREHOUSE_SELECTED_IN_SESSION,
@@ -41,6 +39,8 @@ from snowflake.cli.api.rendering.sql_templates import (
     choose_sql_jinja_env_based_on_template_syntax,
 )
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
+from snowflake.cli.api.sql_execution import SqlExecutor
+from snowflake.cli.api.utils.path_utils import resolve_without_follow
 from snowflake.connector import ProgrammingError
 
 
@@ -80,12 +80,11 @@ def sync_deploy_root_with_stage(
     console: AbstractConsole,
     deploy_root: Path,
     package_name: str,
-    stage_schema: str,
     bundle_map: BundleMap,
     role: str,
     prune: bool,
     recursive: bool,
-    stage_fqn: str,
+    stage_path: DefaultStagePathParts,
     local_paths_to_sync: List[Path] | None = None,
     print_diff: bool = True,
 ) -> DiffResult:
@@ -98,32 +97,37 @@ def sync_deploy_root_with_stage(
         role (str): The name of the role to use for queries and commands.
         prune (bool): Whether to prune artifacts from the stage that don't exist locally.
         recursive (bool): Whether to traverse directories recursively.
-        stage_fqn (str): The name of the stage to diff against and upload to.
+        stage_path (DefaultStagePathParts): stage path object.
+
         local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
-         local paths. Note that providing an empty list here is equivalent to None.
+        local paths. Note that providing an empty list here is equivalent to None.
         print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
 
     Returns:
         A `DiffResult` instance describing the changes that were performed.
     """
-
     sql_facade = get_snowflake_facade()
+    schema = stage_path.schema
+    stage_fqn = stage_path.stage
     # Does a stage already exist within the application package, or we need to create one?
     # Using "if not exists" should take care of either case.
     console.step(
         f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
     )
     if not sql_facade.stage_exists(stage_fqn):
-        sql_facade.create_schema(stage_schema, database=package_name)
+        sql_facade.create_schema(schema, database=package_name)
         sql_facade.create_stage(stage_fqn)
 
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
         console.step(
-            "Performing a diff between the Snowflake stage and your local deploy_root ('%s') directory."
-            % deploy_root.resolve()
+            f"Performing a diff between the Snowflake stage: {stage_path.path} and your local deploy_root: {deploy_root.resolve()}."
         )
-    diff: DiffResult = compute_stage_diff(deploy_root, stage_fqn)
+
+    diff: DiffResult = compute_stage_diff(
+        local_root=deploy_root,
+        stage_path=stage_path,
+    )
 
     if local_paths_to_sync:
         # Deploying specific files/directories
@@ -184,7 +188,7 @@ def sync_deploy_root_with_stage(
             role=role,
             deploy_root_path=deploy_root,
             diff_result=diff,
-            stage_fqn=stage_fqn,
+            stage_full_path=stage_path.full_path,
         )
     return diff
 
@@ -336,3 +340,40 @@ def print_messages(console: AbstractConsole, cursor_results: list[tuple[str]]):
     for message in messages:
         console.warning(message)
     console.message("")
+
+
+def get_sql_executor() -> SqlExecutor:
+    """Returns an SQL Executor that uses the connection from the current CLI context"""
+    return SqlExecutor()
+
+
+class EntityActions(str, Enum):
+    BUNDLE = "action_bundle"
+    DEPLOY = "action_deploy"
+    DROP = "action_drop"
+    VALIDATE = "action_validate"
+    EVENTS = "action_events"
+    DIFF = "action_diff"
+
+    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_DIRECTIVE_ADD_ACCOUNTS = "action_release_directive_add_accounts"
+    RELEASE_DIRECTIVE_REMOVE_ACCOUNTS = "action_release_directive_remove_accounts"
+
+    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"
+    RELEASE_CHANNEL_SET_ACCOUNTS = "action_release_channel_set_accounts"
+
+    PUBLISH = "action_publish"
+
+    @property
+    def get_action_name(self):
+        return self.value.replace("action_", "")

snowflake/cli/api/errno.py

@@ -54,6 +54,7 @@ APPLICATION_PACKAGE_MANIFEST_CONTAINER_IMAGE_URL_BAD_VALUE = 93148
 CANNOT_GRANT_NON_MANIFEST_PRIVILEGE = 93118
 APPLICATION_OWNS_EXTERNAL_OBJECTS = 93128
 APPLICATION_PACKAGE_PATCH_ALREADY_EXISTS = 93168
+CANNOT_ADD_PATCH_WITH_NON_INCREASING_PATCH_NUMBER = 93167
 APPLICATION_PACKAGE_CANNOT_SET_EXTERNAL_DISTRIBUTION_WITH_SPCS = 93197
 NATIVE_APPLICATION_MANIFEST_UNRECOGNIZED_FIELD = 93301
 NATIVE_APPLICATION_MANIFEST_UNEXPECTED_VALUE_FOR_PROPERTY = 93302
@@ -64,8 +65,10 @@ CANNOT_DISABLE_MANDATORY_TELEMETRY = 93329
 VERSION_NOT_ADDED_TO_RELEASE_CHANNEL = 512008
 CANNOT_DISABLE_RELEASE_CHANNELS = 512001
 RELEASE_DIRECTIVES_VERSION_PATCH_NOT_FOUND = 93036
+RELEASE_DIRECTIVE_UNAPPROVED_VERSION_OR_PATCH = 93074
 RELEASE_DIRECTIVE_DOES_NOT_EXIST = 93090
 VERSION_DOES_NOT_EXIST = 93031
+CANNOT_CREATE_VERSION_WITH_NON_ZERO_PATCH = 93170
 VERSION_NOT_IN_RELEASE_CHANNEL = 512010
 ACCOUNT_DOES_NOT_EXIST = 1999
 ACCOUNT_HAS_TOO_MANY_QUALIFIERS = 906

snowflake/cli/api/feature_flags.py

@@ -66,5 +66,4 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID = BooleanFlag(
         "ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID", False
     )
-    ENABLE_SPCS_SERVICE_EVENTS = BooleanFlag("ENABLE_SPCS_SERVICE_EVENTS", False)
-    ENABLE_SPCS_SERVICE_METRICS = BooleanFlag("ENABLE_SPCS_SERVICE_METRICS", False)
+    ENABLE_SNOWPARK_GLOB_SUPPORT = BooleanFlag("ENABLE_SNOWPARK_GLOB_SUPPORT", False)

snowflake/cli/api/project/definition_conversion.py

@@ -222,10 +222,11 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit) -> Dict[str, Any]:
         environment_file,
         pages_dir,
     ]
-    artifacts = [a for a in artifacts if a is not None]
+    artifacts = [str(a) for a in artifacts if a is not None]
 
     if streamlit.additional_source_files:
-        artifacts.extend(streamlit.additional_source_files)
+        for additional_file in streamlit.additional_source_files:
+            artifacts.append(str(additional_file))
 
     identifier = {"name": streamlit.name}
     if streamlit.schema_name:

snowflake/cli/api/project/project_paths.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from snowflake.cli.api.secure_path import SecurePath
+
+
+@dataclass
+class ProjectPaths:
+    """
+    This class allows you to manage files paths related to given project.
+    Class provides bundle root path and allows to remove it.
+    """
+
+    project_root: Path
+
+    @property
+    def bundle_root(self) -> Path:
+        return bundle_root(self.project_root)
+
+    def remove_up_bundle_root(self) -> None:
+        if self.bundle_root.exists():
+            SecurePath(self.bundle_root).rmdir(recursive=True)
+
+
+def bundle_root(root: Path, app_type: str | None = None) -> Path:
+    if app_type:
+        return root / "output" / "bundle" / app_type
+    return root / "output" / "bundle"