snowflake-cli 3.10.1__py3-none-any.whl → 3.11.0__py3-none-any.whl

snowflake/cli/_plugins/auth/oidc/plugin_spec.py

@@ -0,0 +1,30 @@
+# 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 snowflake.cli._plugins.auth import app
+from snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=app.create_instance(),
+    )

snowflake/cli/_plugins/connection/commands.py

@@ -53,6 +53,7 @@ from snowflake.cli.api.commands.flags import (
     TokenFilePathOption,
     UserOption,
     WarehouseOption,
+    WorkloadIdentityProviderOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.config import (
@@ -62,7 +63,9 @@ from snowflake.cli.api.config import (
     get_all_connections,
     get_connection_dict,
     get_default_connection_name,
+    remove_connection_from_proper_file,
     set_config_value,
+    unset_config_value,
 )
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
@@ -220,6 +223,12 @@ def add(
         *AuthenticatorOption.param_decls,
         help="Chosen authenticator, if other than password-based",
     ),
+    workload_identity_provider: Optional[str] = typer.Option(
+        None,
+        "-W",
+        *WorkloadIdentityProviderOption.param_decls,
+        help="Workload identity provider type",
+    ),
     private_key_file: Optional[str] = typer.Option(
         None,
         "--private-key",
@@ -256,6 +265,7 @@ def add(
         "port": port,
         "region": region,
         "authenticator": authenticator,
+        "workload_identity_provider": workload_identity_provider,
         "private_key_file": private_key_file,
         "token_file_path": token_file_path,
     }
@@ -317,6 +327,30 @@ def add(
     )
 
 
+@app.command(requires_connection=False)
+def remove(
+    connection_name: str = typer.Argument(
+        help="Name of the connection to remove.",
+        show_default=False,
+    ),
+    **options,
+):
+    """Removes a connection from configuration file."""
+    if not connection_exists(connection_name):
+        raise UsageError(f"Connection {connection_name} does not exist.")
+
+    is_default = get_default_connection_name() == connection_name
+    if is_default:
+        unset_config_value(path=["default_connection_name"])
+
+    connections_file = remove_connection_from_proper_file(connection_name)
+
+    return MessageResult(
+        f"Removed connection {connection_name} from {connections_file}."
+        f"{' It was the default connection, so default connection is now unset.' if is_default else ''}"
+    )
+
+
 @app.command(requires_connection=True)
 def test(
     **options,
@@ -355,9 +389,9 @@ def test(
         "Host": conn.host,
         "Account": conn.account,
         "User": conn.user,
-        "Role": f'{conn.role or "not set"}',
-        "Database": f'{conn.database or "not set"}',
-        "Warehouse": f'{conn.warehouse or "not set"}',
+        "Role": f"{conn.role or 'not set'}",
+        "Database": f"{conn.database or 'not set'}",
+        "Warehouse": f"{conn.warehouse or 'not set'}",
     }
 
     if conn_ctx.enable_diag:

snowflake/cli/_plugins/dbt/manager.py

@@ -26,7 +26,6 @@ from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, ObjectType
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.util import unquote_identifier
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
@@ -67,8 +66,7 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating temporary stage"):
             stage_manager = StageManager()
-            unquoted_name = unquote_identifier(fqn.name)
-            stage_fqn = FQN.from_string(f"DBT_{unquoted_name}_STAGE").using_context()
+            stage_fqn = FQN.from_string(f"dbt_{fqn.name}_stage").using_context()
             stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
             stage_manager.create(stage_fqn, temporary=True)
 

snowflake/cli/_plugins/dcm/commands.py

@@ -11,7 +11,6 @@
 # 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 List, Optional
 
 import typer
@@ -22,13 +21,13 @@ from snowflake.cli._plugins.dcm.manager import DCMProjectManager
 from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli._plugins.object.manager import ObjectManager
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
     IfExistsOption,
     IfNotExistsOption,
     OverrideableOption,
-    PruneOption,
     entity_argument,
     identifier_argument,
     like_option,
@@ -46,6 +45,7 @@ from snowflake.cli.api.output.types import (
     QueryJsonValueResult,
     QueryResult,
 )
+from snowflake.cli.api.project.project_paths import ProjectPaths
 
 app = SnowTyperFactory(
     name="dcm",
@@ -54,12 +54,6 @@ app = SnowTyperFactory(
 )
 
 dcm_identifier = identifier_argument(sf_object="DCM Project", example="MY_PROJECT")
-version_flag = typer.Option(
-    None,
-    "--version",
-    help="Version of the DCM Project to use. If not specified default version is used. For names containing '$', use single quotes to prevent shell expansion (e.g., 'VERSION$1').",
-    show_default=False,
-)
 variables_flag = variables_option(
     'Variables for the execution context; for example: `-D "<key>=<value>"`.'
 )
@@ -72,6 +66,41 @@ configuration_flag = typer.Option(
 from_option = OverrideableOption(
     None,
     "--from",
+    mutually_exclusive=["prune"],
+    show_default=False,
+)
+
+prune_option = OverrideableOption(
+    False,
+    "--prune",
+    help="Remove unused artifacts from the stage during sync. Mutually exclusive with --from.",
+    mutually_exclusive=["from_stage"],
+    show_default=False,
+)
+
+alias_option = typer.Option(
+    None,
+    "--alias",
+    help="Alias for the deployment.",
+    show_default=False,
+)
+output_path_option = OverrideableOption(
+    None,
+    "--output-path",
+    show_default=False,
+)
+
+terse_option = typer.Option(
+    False,
+    "--terse",
+    help="Returns only a subset of output columns.",
+    show_default=False,
+)
+
+limit_option = typer.Option(
+    None,
+    "--limit",
+    help="Limits the maximum number of rows returned.",
     show_default=False,
 )
 
@@ -85,32 +114,33 @@ add_object_command_aliases(
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
     ommit_commands=["create"],
+    terse_option=terse_option,
+    limit_option=limit_option,
 )
 
 
 @app.command(requires_connection=True)
 def deploy(
     identifier: FQN = dcm_identifier,
-    version: Optional[str] = version_flag,
     from_stage: Optional[str] = from_option(
-        help="Apply changes defined in given stage instead of using a specific project version."
+        help="Deploy DCM Project deployment from a given stage."
     ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    alias: Optional[str] = alias_option,
+    prune: bool = prune_option(),
     **options,
 ):
     """
     Applies changes defined in DCM Project to Snowflake.
     """
-    if version and from_stage:
-        raise CliError("--version and --from are mutually exclusive.")
-
     result = DCMProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
-        version=version,
-        from_stage=from_stage,
+        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
         variables=variables,
+        alias=alias,
+        output_path=None,
     )
     return QueryJsonValueResult(result)
 
@@ -118,27 +148,27 @@ def deploy(
 @app.command(requires_connection=True)
 def plan(
     identifier: FQN = dcm_identifier,
-    version: Optional[str] = version_flag,
     from_stage: Optional[str] = from_option(
-        help="Plan DCM Project deployment from given stage instead of using a specific version."
+        help="Plan DCM Project deployment from a given stage."
     ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    prune: bool = prune_option(),
+    output_path: Optional[str] = output_path_option(
+        help="Stage path where the deployment plan output will be stored."
+    ),
     **options,
 ):
     """
     Plans a DCM Project deployment (validates without executing).
     """
-    if version and from_stage:
-        raise CliError("--version and --from are mutually exclusive.")
-
     result = DCMProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
-        version=version,
-        from_stage=from_stage,
+        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
         dry_run=True,
         variables=variables,
+        output_path=output_path,
     )
     return QueryJsonValueResult(result)
 
@@ -147,11 +177,6 @@ def plan(
 @with_project_definition()
 def create(
     entity_id: str = entity_argument("dcm"),
-    no_version: bool = typer.Option(
-        False,
-        "--no-version",
-        help="Do not initialize DCM Project with a new version, only create the snowflake object.",
-    ),
     if_not_exists: bool = IfNotExistsOption(
         help="Do nothing if the project already exists."
     ),
@@ -159,7 +184,6 @@ def create(
 ):
     """
     Creates a DCM Project in Snowflake.
-    By default, the DCM Project is initialized with a new version created from local files.
     """
     cli_context = get_cli_context()
     project: DCMProjectEntityModel = get_entity_for_operation(
@@ -175,76 +199,23 @@ def create(
             return MessageResult(message)
         raise CliError(message)
 
-    if not no_version and om.object_exists(
-        object_type="stage", fqn=FQN.from_stage(project.stage)
-    ):
+    if om.object_exists(object_type="stage", fqn=FQN.from_stage(project.stage)):
         raise CliError(f"Stage '{project.stage}' already exists.")
 
     dpm = DCMProjectManager()
     with cli_console.phase(f"Creating DCM Project '{project.fqn}'"):
-        dpm.create(project=project, initialize_version_from_local_files=not no_version)
+        dpm.create(project=project)
 
-    if no_version:
-        return MessageResult(f"DCM Project '{project.fqn}' successfully created.")
-    return MessageResult(
-        f"DCM Project '{project.fqn}' successfully created and initial version is added."
-    )
+    return MessageResult(f"DCM Project '{project.fqn}' successfully created.")
 
 
 @app.command(requires_connection=True)
-@with_project_definition()
-def add_version(
-    entity_id: str = entity_argument("dcm"),
-    _from: Optional[str] = from_option(
-        help="Create a new version using given stage instead of uploading local files."
-    ),
-    _alias: Optional[str] = typer.Option(
-        None, "--alias", help="Alias for the version.", show_default=False
-    ),
-    comment: Optional[str] = typer.Option(
-        None, "--comment", help="Version comment.", show_default=False
-    ),
-    prune: bool = PruneOption(default=True),
-    **options,
-):
-    """Uploads local files to Snowflake and cerates a new DCM Project version."""
-    if _from is not None and prune:
-        cli_console.warning(
-            "When `--from` option is used, `--prune` option will be ignored and files from stage will be used as they are."
-        )
-        prune = False
-    cli_context = get_cli_context()
-    project: DCMProjectEntityModel = get_entity_for_operation(
-        cli_context=cli_context,
-        entity_id=entity_id,
-        project_definition=cli_context.project_definition,
-        entity_type="dcm",
-    )
-    om = ObjectManager()
-    if not om.object_exists(object_type="dcm", fqn=project.fqn):
-        raise CliError(
-            f"DCM Project '{project.fqn}' does not exist. Use `dcm create` command first."
-        )
-    DCMProjectManager().add_version(
-        project=project,
-        prune=prune,
-        from_stage=_from,
-        alias=_alias,
-        comment=comment,
-    )
-    alias_str = "" if _alias is None else f"'{_alias}' "
-    return MessageResult(
-        f"New version {alias_str}added to DCM Project '{project.fqn}'."
-    )
-
-
-@app.command(requires_connection=True)
-def list_versions(
+def list_deployments(
     identifier: FQN = dcm_identifier,
     **options,
 ):
     """
-    Lists versions of given DCM Project.
+    Lists deployments of given DCM Project.
     """
     pm = DCMProjectManager()
     results = pm.list_versions(project_name=identifier)
@@ -252,7 +223,7 @@ def list_versions(
 
 
 @app.command(requires_connection=True)
-def drop_version(
+def drop_deployment(
     identifier: FQN = dcm_identifier,
     version_name: str = typer.Argument(
         help="Name or alias of the version to drop. For names containing '$', use single quotes to prevent shell expansion (e.g., 'VERSION$1').",
@@ -272,7 +243,7 @@ def drop_version(
         )
 
     dpm = DCMProjectManager()
-    dpm.drop_version(
+    dpm.drop_deployment(
         project_name=identifier,
         version_name=version_name,
         if_exists=if_exists,
@@ -280,3 +251,23 @@ def drop_version(
     return MessageResult(
         f"Version '{version_name}' dropped from DCM Project '{identifier}'."
     )
+
+
+def _sync_local_files(prune: bool = False) -> str:
+    cli_context = get_cli_context()
+    project_entity = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=None,
+        project_definition=cli_context.project_definition,
+        entity_type="dcm",
+    )
+
+    with cli_console.phase("Syncing local files to stage"):
+        sync_artifacts_with_stage(
+            project_paths=ProjectPaths(project_root=cli_context.project_root),
+            stage_root=project_entity.stage,
+            artifacts=project_entity.artifacts,
+            prune=prune,
+        )
+
+    return project_entity.stage

snowflake/cli/_plugins/dcm/manager.py

@@ -11,37 +11,36 @@
 # 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 textwrap import dedent
-from typing import List, Optional
+
+from typing import List
 
 from snowflake.cli._plugins.dcm.dcm_project_entity_model import DCMProjectEntityModel
 from snowflake.cli._plugins.stage.manager import StageManager
-from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
-from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.utils import parse_key_value_variables
-from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.project_paths import ProjectPaths
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
-from snowflake.connector.cursor import SnowflakeCursor
 
 
 class DCMProjectManager(SqlExecutionMixin):
     def execute(
         self,
         project_name: FQN,
+        from_stage: str,
         configuration: str | None = None,
-        version: str | None = None,
-        from_stage: str | None = None,
         variables: List[str] | None = None,
         dry_run: bool = False,
+        alias: str | None = None,
+        output_path: str | None = None,
     ):
+
         query = f"EXECUTE DCM PROJECT {project_name.sql_identifier}"
         if dry_run:
             query += " PLAN"
         else:
             query += " DEPLOY"
+            if alias:
+                query += f" AS {alias}"
         if configuration or variables:
             query += f" USING"
         if configuration:
@@ -50,23 +49,16 @@ class DCMProjectManager(SqlExecutionMixin):
             query += StageManager.parse_execute_variables(
                 parse_key_value_variables(variables)
             ).removeprefix(" using")
-        if version:
-            query += f" WITH VERSION {version}"
-        elif from_stage:
-            stage_path = StagePath.from_stage_str(from_stage)
-            query += f" FROM {stage_path.absolute_path()}"
+        stage_path = StagePath.from_stage_str(from_stage)
+        query += f" FROM {stage_path.absolute_path()}"
+        if output_path:
+            output_stage_path = StagePath.from_stage_str(output_path)
+            query += f" OUTPUT_PATH {output_stage_path.absolute_path()}"
         return self.execute_query(query=query)
 
-    def _create_object(self, project_name: FQN) -> SnowflakeCursor:
-        query = dedent(f"CREATE DCM PROJECT {project_name.sql_identifier}")
-        return self.execute_query(query)
-
-    def create(
-        self, project: DCMProjectEntityModel, initialize_version_from_local_files: bool
-    ) -> None:
-        self._create_object(project.fqn)
-        if initialize_version_from_local_files:
-            self.add_version(project=project)
+    def create(self, project: DCMProjectEntityModel) -> None:
+        query = f"CREATE DCM PROJECT {project.fqn.sql_identifier}"
+        self.execute_query(query)
 
     def _create_version(
         self,
@@ -84,43 +76,11 @@ class DCMProjectManager(SqlExecutionMixin):
             query += f" COMMENT = '{comment}'"
         return self.execute_query(query=query)
 
-    def add_version(
-        self,
-        project: DCMProjectEntityModel,
-        prune: bool = False,
-        from_stage: Optional[str] = None,
-        alias: Optional[str] = None,
-        comment: Optional[str] = None,
-    ):
-        """
-        Adds a version to DCM Project. If [from_stage] is not defined,
-        uploads local files to the stage defined in DCM Project definition.
-        """
-
-        if not from_stage:
-            cli_context = get_cli_context()
-            from_stage = project.stage
-            with cli_console.phase("Uploading artifacts"):
-                sync_artifacts_with_stage(
-                    project_paths=ProjectPaths(project_root=cli_context.project_root),
-                    stage_root=from_stage,
-                    artifacts=project.artifacts,
-                    prune=prune,
-                )
-
-        with cli_console.phase(f"Creating DCM Project version from stage {from_stage}"):
-            return self._create_version(
-                project_name=project.fqn,
-                from_stage=from_stage,  # type:ignore
-                alias=alias,
-                comment=comment,
-            )
-
     def list_versions(self, project_name: FQN):
         query = f"SHOW VERSIONS IN DCM PROJECT {project_name.identifier}"
         return self.execute_query(query=query)
 
-    def drop_version(
+    def drop_deployment(
         self,
         project_name: FQN,
         version_name: str,

snowflake/cli/_plugins/notebook/notebook_entity.py

@@ -60,6 +60,8 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
             query += f"\nCOMPUTE_POOL = '{self.model.compute_pool}'"
         if self.model.runtime_name:
             query += f"\nRUNTIME_NAME = '{self.model.runtime_name}'"
+        if self.model.runtime_environment_version and not self.model.compute_pool:
+            query += f"\nRUNTIME_ENVIRONMENT_VERSION = '{self.model.runtime_environment_version}'"
 
         query += (
             ";\n// Cannot use IDENTIFIER(...)"

snowflake/cli/_plugins/notebook/notebook_entity_model.py

@@ -20,6 +20,9 @@ class NotebookEntityModel(EntityModelBaseWithArtifacts):
     )
     notebook_file: Path = Field(title="Notebook file")
     query_warehouse: str = Field(title="Snowflake warehouse to execute the notebook")
+    runtime_environment_version: Optional[str] = Field(
+        title="Runtime environment version", default=None
+    )
     compute_pool: Optional[str] = Field(
         title="Compute pool to run the notebook in", default=None
     )
@@ -37,6 +40,10 @@ class NotebookEntityModel(EntityModelBaseWithArtifacts):
     def validate_container_setup(self):
         if self.compute_pool and not self.runtime_name:
             raise ValueError("compute_pool is specified without runtime_name")
-        if self.runtime_name and not self.compute_pool and not self:
+        if self.runtime_name and not self.compute_pool:
             raise ValueError("runtime_name is specified without compute_pool")
+        if self.compute_pool and self.runtime_environment_version:
+            raise ValueError(
+                "runtime_environment_version is only applicable for notebooks using warehouse, not compute pool"
+            )
         return self

snowflake/cli/_plugins/object/command_aliases.py

@@ -22,8 +22,10 @@ from snowflake.cli._plugins.object.commands import (
     ScopeOption,
     describe,
     drop,
+    limit_option_,
     list_,
     scope_option,  # noqa: F401
+    terse_option_,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
@@ -37,6 +39,8 @@ def add_object_command_aliases(
     like_option: Optional[typer.Option],
     scope_option: Optional[typer.Option],
     ommit_commands: Optional[List[str]] = None,
+    terse_option: Optional[typer.Option] = None,
+    limit_option: Optional[typer.Option] = None,
 ):
     if ommit_commands is None:
         ommit_commands = list()
@@ -47,11 +51,18 @@ def add_object_command_aliases(
         if not scope_option:
 
             @app.command("list", requires_connection=True)
-            def list_cmd(like: str = like_option, **options):  # type: ignore
+            def list_cmd(
+                like: str = like_option,  # type: ignore
+                terse: bool = terse_option if terse_option else terse_option_(),  # type: ignore
+                limit: Optional[int] = limit_option if limit_option else limit_option_(),  # type: ignore
+                **options,
+            ):
                 return list_(
                     object_type=object_type.value.cli_name,
                     like=like,
                     scope=ScopeOption.default,
+                    terse=terse,
+                    limit=limit,
                     **options,
                 )
 
@@ -61,12 +72,16 @@ def add_object_command_aliases(
             def list_cmd(
                 like: str = like_option,  # type: ignore
                 scope: Tuple[str, str] = scope_option,  # type: ignore
+                terse: bool = terse_option if terse_option else terse_option_(),  # type: ignore
+                limit: Optional[int] = limit_option if limit_option else limit_option_(),  # type: ignore
                 **options,
             ):
                 return list_(
                     object_type=object_type.value.cli_name,
                     like=like,
                     scope=scope,
+                    terse=terse,
+                    limit=limit,
                     **options,
                 )
 

snowflake/cli/_plugins/object/commands.py

@@ -94,6 +94,24 @@ def scope_option(help_example: str):
     )
 
 
+def terse_option_():
+    return typer.Option(
+        None,
+        "--terse",
+        help=f"Returns only a subset of available columns.",
+        hidden=True,
+    )
+
+
+def limit_option_():
+    return typer.Option(
+        None,
+        "--limit",
+        help=f"Limits the maximum number of rows returned.",
+        hidden=True,
+    )
+
+
 ScopeOption = scope_option(
     help_example="`list table --in database my_db`. Some object types have specialized scopes (e.g. list service --in compute-pool my_pool)"
 )
@@ -110,11 +128,19 @@ def list_(
     object_type: str = ObjectArgument,
     like: str = LikeOption,
     scope: Tuple[str, str] = ScopeOption,
+    terse: Optional[bool] = terse_option_(),
+    limit: Optional[int] = limit_option_(),
     **options,
 ):
     _scope_validate(object_type, scope)
     return QueryResult(
-        ObjectManager().show(object_type=object_type, like=like, scope=scope)
+        ObjectManager().show(
+            object_type=object_type,
+            like=like,
+            scope=scope,
+            terse=terse,
+            limit=limit,
+        )
     )