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

snowflake/cli/_plugins/project/commands.py

@@ -15,26 +15,31 @@
 from typing import List, Optional
 
 import typer
+from click import ClickException
+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._plugins.project.feature_flags import FeatureFlag
 from snowflake.cli._plugins.project.manager import ProjectManager
 from snowflake.cli._plugins.project.project_entity_model import (
     ProjectEntityModel,
 )
-from snowflake.cli._plugins.stage.manager import StageManager
-from snowflake.cli.api.artifacts.upload import put_files
 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 (
+    OverrideableOption,
+    PruneOption,
     entity_argument,
     identifier_argument,
+    like_option,
     variables_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.commands.utils import get_entity_for_operation
 from snowflake.cli.api.console.console import cli_console
+from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import MessageResult, SingleQueryResult
-from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.output.types import MessageResult, QueryResult, SingleQueryResult
 
 app = SnowTyperFactory(
     name="project",
@@ -44,17 +49,38 @@ app = SnowTyperFactory(
 
 project_identifier = identifier_argument(sf_object="project", example="MY_PROJECT")
 version_flag = typer.Option(
-    ..., "--version", help="Version of the project to use.", show_default=False
+    None,
+    "--version",
+    help="Version of the project to use. If not specified default version is used",
+    show_default=False,
 )
 variables_flag = variables_option(
     'Variables for the execution context; for example: `-D "<key>=<value>"`.'
 )
+from_option = OverrideableOption(
+    None,
+    "--from",
+    help="Create a new version using given stage instead of uploading local files.",
+    show_default=False,
+)
+
+
+add_object_command_aliases(
+    app=app,
+    object_type=ObjectType.PROJECT,
+    name_argument=project_identifier,
+    like_option=like_option(
+        help_example='`list --like "my%"` lists all projects that begin with “my”'
+    ),
+    scope_option=scope_option(help_example="`list --in database my_db`"),
+    ommit_commands=["drop", "create", "describe"],
+)
 
 
 @app.command(requires_connection=True)
 def execute(
     identifier: FQN = project_identifier,
-    version: str = version_flag,
+    version: Optional[str] = version_flag,
     variables: Optional[List[str]] = variables_flag,
     **options,
 ):
@@ -70,7 +96,7 @@ def execute(
 @app.command(requires_connection=True)
 def dry_run(
     identifier: FQN = project_identifier,
-    version: str = version_flag,
+    version: Optional[str] = version_flag,
     variables: Optional[List[str]] = variables_flag,
     **options,
 ):
@@ -85,12 +111,18 @@ def dry_run(
 
 @app.command(requires_connection=True)
 @with_project_definition()
-def create_version(
+def create(
     entity_id: str = entity_argument("project"),
+    no_version: bool = typer.Option(
+        False,
+        "--no-version",
+        help="Do not initialize project with a new version, only create the snowflake object.",
+    ),
     **options,
 ):
     """
-    Upload local files and create a new version of a project using those files. If the stage does not exist, it will be created.
+    Creates a project in Snowflake.
+    By default, the project is initialized with a new version created from local files.
     """
     cli_context = get_cli_context()
     project: ProjectEntityModel = get_entity_for_operation(
@@ -99,59 +131,68 @@ def create_version(
         project_definition=cli_context.project_definition,
         entity_type="project",
     )
+    om = ObjectManager()
+    if om.object_exists(object_type="project", fqn=project.fqn):
+        raise ClickException(f"Project '{project.fqn}' already exists.")
+    if not no_version and om.object_exists(
+        object_type="stage", fqn=FQN.from_stage(project.stage)
+    ):
+        raise ClickException(f"Stage '{project.stage}' already exists.")
 
-    # Sync state
-    with cli_console.phase("Syncing project state"):
-        stage_name = FQN.from_stage(project.stage)
-        sm = StageManager()
-
-        cli_console.step(f"Creating stage {stage_name}")
-        sm.create(fqn=stage_name)
-
-        put_files(
-            project_paths=ProjectPaths(project_root=cli_context.project_root),
-            stage_root=project.stage,
-            artifacts=project.artifacts,
-        )
-
-    # Create project and version
-    with cli_console.phase("Creating project and version"):
-        pm = ProjectManager()
-        cli_console.step(f"Creating project {project.fqn}")
-        pm.create(project_name=project.fqn)
+    pm = ProjectManager()
+    with cli_console.phase(f"Creating project '{project.fqn}'"):
+        pm.create(project=project, initialize_version_from_local_files=not no_version)
 
-        cli_console.step(f"Creating version from stage {stage_name}")
-        pm.create_version(project_name=project.fqn, stage_name=stage_name)
-    return MessageResult(f"Project {project.fqn} deployed.")
+    if no_version:
+        return MessageResult(f"Project '{project.fqn}' successfully created.")
+    return MessageResult(
+        f"Project '{project.fqn}' successfully created and initial version is added."
+    )
 
 
 @app.command(requires_connection=True)
 @with_project_definition()
 def add_version(
     entity_id: str = entity_argument("project"),
-    _from: str = typer.Option(
-        ...,
-        "--from",
-        help="Source stage to create the version from.",
-        show_default=False,
-    ),
-    alias: str
-    | None = typer.Option(
+    _from: Optional[str] = from_option(mutually_exclusive=["prune"]),
+    _alias: Optional[str] = typer.Option(
         None, "--alias", help="Alias for the version.", show_default=False
     ),
-    comment: str
-    | None = typer.Option(
+    comment: Optional[str] = typer.Option(
         None, "--comment", help="Version comment.", show_default=False
     ),
+    prune: bool = PruneOption(mutually_exclusive=["_from"]),
     **options,
 ):
-    """Adds a new version to a project using existing sources from provided stage path."""
-
-    pm = ProjectManager()
-    pm.add_version(
-        project_name=entity_id,
+    """Uploads local files to Snowflake and cerates a new project version."""
+    cli_context = get_cli_context()
+    project: ProjectEntityModel = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=entity_id,
+        project_definition=cli_context.project_definition,
+        entity_type="project",
+    )
+    ProjectManager().add_version(
+        project=project,
+        prune=prune,
         from_stage=_from,
-        alias=alias,
+        alias=_alias,
         comment=comment,
     )
-    return MessageResult("Version added.")
+    alias_str = "" if _alias is None else f"'{_alias}' "
+    return MessageResult(
+        f"New project version {alias_str}added to project '{project.fqn}'"
+    )
+
+
+@app.command(requires_connection=True)
+def list_versions(
+    identifier: FQN = project_identifier,
+    **options,
+):
+    """
+    Lists versions of given project.
+    """
+    pm = ProjectManager()
+    results = pm.list_versions(project_name=identifier)
+    return QueryResult(results)

snowflake/cli/_plugins/project/manager.py

@@ -12,13 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from textwrap import dedent
-from typing import List
+from typing import List, Optional
 
+from snowflake.cli._plugins.project.project_entity_model import ProjectEntityModel
 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 ProjectManager(SqlExecutionMixin):
@@ -40,37 +46,65 @@ class ProjectManager(SqlExecutionMixin):
             query += " DRY_RUN=TRUE"
         return self.execute_query(query=query)
 
-    def create(
-        self,
-        project_name: FQN,
-    ) -> str:
-        queries = dedent(f"CREATE PROJECT IF NOT EXISTS {project_name.sql_identifier}")
-        return self.execute_query(query=queries)
+    def _create_object(self, project_name: FQN) -> SnowflakeCursor:
+        query = dedent(f"CREATE PROJECT {project_name.sql_identifier}")
+        return self.execute_query(query)
 
-    def create_version(self, project_name: FQN, stage_name: FQN):
-        return self.add_version(
-            project_name=project_name,
-            from_stage=StagePath.from_stage_str(stage_name).absolute_path(
-                at_prefix=True
-            ),
-        )
+    def create(
+        self, project: ProjectEntityModel, initialize_version_from_local_files: bool
+    ) -> None:
+        self._create_object(project.fqn)
+        if initialize_version_from_local_files:
+            self.add_version(project=project)
 
-    def add_version(
+    def _create_version(
         self,
-        project_name: str | FQN,
+        project_name: FQN,
         from_stage: str,
         alias: str | None = None,
         comment: str | None = None,
     ):
-        project_name = (
-            project_name
-            if isinstance(project_name, FQN)
-            else FQN.from_string(project_name)
-        )
+        stage_path = StagePath.from_stage_str(from_stage)
         query = f"ALTER PROJECT {project_name.identifier} ADD VERSION"
         if alias:
-            query += f" IF NOT EXIST {alias}"
-        query += f" FROM {from_stage}"
+            query += f' IF NOT EXISTS "{alias}"'
+        query += f" FROM {stage_path.absolute_path(at_prefix=True)}"
         if comment:
             query += f" COMMENT = '{comment}'"
         return self.execute_query(query=query)
+
+    def add_version(
+        self,
+        project: ProjectEntityModel,
+        prune: bool = False,
+        from_stage: Optional[str] = None,
+        alias: Optional[str] = None,
+        comment: Optional[str] = None,
+    ):
+        """
+        Adds a version to project. If [from_stage] is not defined,
+        uploads local files to the stage defined in 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 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 PROJECT {project_name.identifier}"
+        return self.execute_query(query=query)

snowflake/cli/_plugins/project/project_entity_model.py

@@ -13,26 +13,45 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import Literal, Optional, TypeVar
+from typing import List, Literal, Optional, TypeVar
 
-from pydantic import Field
+from pydantic import Field, field_validator
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.entities.common import EntityBase, attach_spans_to_entity_actions
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.project.schemas.entities.common import (
+    Artifacts,
     EntityModelBaseWithArtifacts,
+    PathMapping,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
     DiscriminatorField,
 )
+from snowflake.cli.api.secure_path import SecurePath
 
 T = TypeVar("T")
 
 
+MANIFEST_FILE_NAME = "manifest.yml"
+
+
 class ProjectEntityModel(EntityModelBaseWithArtifacts):
     type: Literal["project"] = DiscriminatorField()  # noqa: A003
     stage: Optional[str] = Field(
         title="Stage in which the project artifacts will be stored", default=None
     )
-    main_file: Optional[str] = Field(title="Path to the main file of the project")
+
+    @field_validator("artifacts")
+    @classmethod
+    def transform_artifacts(cls, orig_artifacts: Artifacts) -> List[PathMapping]:
+        if not (
+            SecurePath(get_cli_context().project_root) / MANIFEST_FILE_NAME
+        ).exists():
+            raise CliError(
+                f"{MANIFEST_FILE_NAME} was not found in project root directory"
+            )
+        orig_artifacts.append(PathMapping(src=MANIFEST_FILE_NAME))
+        return super().transform_artifacts(orig_artifacts)
 
 
 @attach_spans_to_entity_actions(entity_name="project")

snowflake/cli/_plugins/snowpark/commands.py

@@ -71,6 +71,7 @@ from snowflake.cli.api.commands.decorators import (
 )
 from snowflake.cli.api.commands.flags import (
     ForceReplaceOption,
+    PruneOption,
     ReplaceOption,
     execution_identifier_argument,
     identifier_argument,
@@ -133,6 +134,9 @@ def deploy(
         "overwrites existing files, but does not remove any files already on the stage."
     ),
     force_replace: bool = ForceReplaceOption(),
+    prune: bool = PruneOption(
+        help="Remove contents of the stage before uploading artifacts."
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -174,7 +178,7 @@ def deploy(
             snowpark_entities=snowpark_entities,
         )
 
-        create_stages_and_upload_artifacts(stages_to_artifact_map)
+        create_stages_and_upload_artifacts(stages_to_artifact_map, prune=prune)
 
     # Create snowpark entities
     with cli_console.phase("Creating Snowpark entities"):
@@ -242,8 +246,17 @@ def build_artifacts_mappings(
     return entities_to_imports_map, stages_to_artifact_map
 
 
-def create_stages_and_upload_artifacts(stages_to_artifact_map: StageToArtifactMapping):
+def create_stages_and_upload_artifacts(
+    stages_to_artifact_map: StageToArtifactMapping, prune: bool
+):
     stage_manager = StageManager()
+    if prune:
+        # snowflake.cli._plugins.snowpark.snowpark_project_paths.Artifact class assumes that "stage"
+        # is a stage object, not path on stage - whole stage is managed by snowpark - it can be removed
+        for stage in stages_to_artifact_map.keys():
+            cli_console.step(f"Removing contents of stage {stage}")
+            stage_manager.remove(stage, path="")
+
     for stage, artifacts in stages_to_artifact_map.items():
         cli_console.step(f"Creating (if not exists) stage: {stage}")
         stage = FQN.from_stage(stage).using_context()

snowflake/cli/_plugins/spcs/compute_pool/commands.py

@@ -88,9 +88,17 @@ MaxNodesOption = OverrideableOption(
 _AUTO_RESUME_HELP = "The compute pool will automatically resume when a service or job is submitted to it."
 
 AutoResumeOption = OverrideableOption(
-    True,
-    "--auto-resume/--no-auto-resume",
+    False,
+    "--auto-resume",
     help=_AUTO_RESUME_HELP,
+    mutually_exclusive=["no_auto_resume"],
+)
+
+NoAutoResumeOption = OverrideableOption(
+    False,
+    "--no-auto-resume",
+    help=_AUTO_RESUME_HELP,
+    mutually_exclusive=["auto_resume"],
 )
 
 _AUTO_SUSPEND_SECS_HELP = "Number of seconds of inactivity after which you want Snowflake to automatically suspend the compute pool."
@@ -126,6 +134,7 @@ def create(
     min_nodes: int = MinNodesOption(),
     max_nodes: Optional[int] = MaxNodesOption(),
     auto_resume: bool = AutoResumeOption(),
+    no_auto_resume: bool = NoAutoResumeOption(),
     initially_suspended: bool = typer.Option(
         False,
         "--init-suspend/--no-init-suspend",
@@ -140,13 +149,14 @@ def create(
     """
     Creates a new compute pool.
     """
+    resume_option = True if auto_resume else False if no_auto_resume else True
     max_nodes = validate_and_set_instances(min_nodes, max_nodes, "nodes")
     cursor = ComputePoolManager().create(
         pool_name=name.identifier,
         min_nodes=min_nodes,
         max_nodes=max_nodes,
         instance_family=instance_family,
-        auto_resume=auto_resume,
+        auto_resume=resume_option,
         initially_suspended=initially_suspended,
         auto_suspend_secs=auto_suspend_secs,
         tags=tags,
@@ -223,7 +233,8 @@ def set_property(
     name: FQN = ComputePoolNameArgument,
     min_nodes: Optional[int] = MinNodesOption(default=None, show_default=False),
     max_nodes: Optional[int] = MaxNodesOption(show_default=False),
-    auto_resume: Optional[bool] = AutoResumeOption(default=None, show_default=False),
+    auto_resume: bool = AutoResumeOption(default=None, show_default=False),
+    no_auto_resume: bool = NoAutoResumeOption(default=None, show_default=False),
     auto_suspend_secs: Optional[int] = AutoSuspendSecsOption(
         default=None, show_default=False
     ),
@@ -235,11 +246,12 @@ def set_property(
     """
     Sets one or more properties for the compute pool.
     """
+    resume_option = True if auto_resume else False if no_auto_resume else None
     cursor = ComputePoolManager().set_property(
         pool_name=name.identifier,
         min_nodes=min_nodes,
         max_nodes=max_nodes,
-        auto_resume=auto_resume,
+        auto_resume=resume_option,
         auto_suspend_secs=auto_suspend_secs,
         comment=comment,
     )

snowflake/cli/_plugins/sql/manager.py

@@ -14,23 +14,29 @@
 
 from __future__ import annotations
 
+import logging
 import sys
-from io import StringIO
-from itertools import chain
+from functools import partial
 from pathlib import Path
 from typing import Dict, Iterable, List, Tuple
 
-from click import ClickException, UsageError
-from jinja2 import UndefinedError
 from snowflake.cli._plugins.sql.snowsql_templating import transpile_snowsql_templates
+from snowflake.cli._plugins.sql.source_reader import (
+    compile_statements,
+    files_reader,
+    query_reader,
+)
+from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.exceptions import CliArgumentError, CliSqlError
 from snowflake.cli.api.rendering.sql_templates import snowflake_sql_jinja_render
-from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
+from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin, VerboseCursor
 from snowflake.connector.cursor import SnowflakeCursor
-from snowflake.connector.util_text import split_statements
 
 IsSingleStatement = bool
 
+logger = logging.getLogger(__name__)
+
 
 class SqlManager(SqlExecutionMixin):
     def execute(
@@ -41,57 +47,42 @@ class SqlManager(SqlExecutionMixin):
         data: Dict | None = None,
         retain_comments: bool = False,
     ) -> Tuple[IsSingleStatement, Iterable[SnowflakeCursor]]:
-        inputs = [query, files, std_in]
-        # Check if any two inputs were provided simultaneously
-        if len([i for i in inputs if i]) > 1:
-            raise UsageError(
-                "Multiple input sources specified. Please specify only one."
-            )
+        """Reads, transforms and execute statements from input.
 
-        if std_in:
-            query = sys.stdin.read()
-        if query:
-            return self._execute_single_query(
-                query=query, data=data, retain_comments=retain_comments
-            )
+        Only one input can be consumed at a time.
+        When no compilation errors are detected, the sequence on queries
+        in executed and returned as tuple.
 
-        if files:
-            # Multiple files
-            results = []
-            single_statement = False
-            for file in files:
-                query_from_file = SecurePath(file).read_text(
-                    file_size_limit_mb=UNLIMITED
-                )
-                single_statement, result = self._execute_single_query(
-                    query=query_from_file, data=data, retain_comments=retain_comments
-                )
-                results.append(result)
+        Throws an exception ff multiple inputs are provided.
+        """
+        query = sys.stdin.read() if std_in else query
 
-            # Use single_statement if there's only one, otherwise this is multi statement result
-            single_statement = len(files) == 1 and single_statement
-            return single_statement, chain.from_iterable(results)
+        stmt_operators = (
+            transpile_snowsql_templates,
+            partial(snowflake_sql_jinja_render, data=data),
+        )
+        remove_comments = not retain_comments
 
-        # At that point, no stdin, query or files were provided
-        raise UsageError("Use either query, filename or input option.")
+        if query:
+            stmt_reader = query_reader(query, stmt_operators, remove_comments)
+        elif files:
+            secured_files = [SecurePath(f) for f in files]
+            stmt_reader = files_reader(secured_files, stmt_operators, remove_comments)
+        else:
+            raise CliArgumentError("Use either query, filename or input option.")
 
-    def _execute_single_query(
-        self, query: str, data: Dict | None = None, retain_comments: bool = False
-    ) -> Tuple[IsSingleStatement, Iterable[SnowflakeCursor]]:
-        try:
-            query = transpile_snowsql_templates(query)
-            query = snowflake_sql_jinja_render(content=query, data=data)
-        except UndefinedError as err:
-            raise ClickException(f"SQL template rendering error: {err}")
+        errors, stmt_count, compiled_statements = compile_statements(stmt_reader)
+        if not any((errors, stmt_count, compiled_statements)):
+            raise CliArgumentError("Use either query, filename or input option.")
 
-        statements = tuple(
-            statement
-            for statement, _ in split_statements(
-                StringIO(query), remove_comments=not retain_comments
-            )
-        )
-        single_statement = len(statements) == 1
+        if errors:
+            for error in errors:
+                logger.info("Statement compilation error: %s", error)
+                cli_console.warning(error)
+            raise CliSqlError("SQL rendering error")
 
-        return single_statement, self._execute_string(
-            "\n".join(statements), cursor_class=VerboseCursor
+        is_single_statement = not (stmt_count > 1)
+        return is_single_statement, self.execute_string(
+            "\n".join(compiled_statements),
+            cursor_class=VerboseCursor,
         )