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

snowflake/cli/_plugins/dcm/commands.py

@@ -11,33 +11,26 @@
 # 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
-from snowflake.cli._plugins.dcm.dcm_project_entity_model import (
-    DCMProjectEntityModel,
-)
 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.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,
     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.constants import (
+    ObjectType,
+)
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
@@ -46,6 +39,7 @@ from snowflake.cli.api.output.types import (
     QueryJsonValueResult,
     QueryResult,
 )
+from snowflake.cli.api.utils.path_utils import is_stage_path
 
 app = SnowTyperFactory(
     name="dcm",
@@ -54,12 +48,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>"`.'
 )
@@ -69,9 +57,36 @@ configuration_flag = typer.Option(
     help="Configuration of the DCM Project to use. If not specified default configuration is used.",
     show_default=False,
 )
-from_option = OverrideableOption(
+from_option = typer.Option(
     None,
     "--from",
+    help="Source location: stage path (starting with '@') or local directory path. Omit to use current directory.",
+    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,73 +100,73 @@ 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."
-    ),
+    from_location: Optional[str] = from_option,
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    alias: Optional[str] = alias_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,
-        variables=variables,
-    )
+    manager = DCMProjectManager()
+    effective_stage = _get_effective_stage(identifier, from_location)
+
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Deploying dcm project {identifier}", total=None)
+        result = manager.execute(
+            project_identifier=identifier,
+            configuration=configuration,
+            from_stage=effective_stage,
+            variables=variables,
+            alias=alias,
+            output_path=None,
+        )
     return QueryJsonValueResult(result)
 
 
 @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."
-    ),
+    from_location: Optional[str] = from_option,
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    output_path: Optional[str] = output_path_option(
+        help="Path where the deployment plan output will be stored. Can be a stage path (starting with '@') or a local directory path."
+    ),
     **options,
 ):
     """
     Plans a DCM Project deployment (validates without executing).
     """
-    if version and from_stage:
-        raise CliError("--version and --from are mutually exclusive.")
+    manager = DCMProjectManager()
+    effective_stage = _get_effective_stage(identifier, from_location)
+
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Planning dcm project {identifier}", total=None)
+        result = manager.execute(
+            project_identifier=identifier,
+            configuration=configuration,
+            from_stage=effective_stage,
+            dry_run=True,
+            variables=variables,
+            output_path=output_path,
+        )
 
-    result = DCMProjectManager().execute(
-        project_name=identifier,
-        configuration=configuration,
-        version=version,
-        from_stage=from_stage,
-        dry_run=True,
-        variables=variables,
-    )
     return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
-@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.",
-    ),
+    identifier: FQN = dcm_identifier,
     if_not_exists: bool = IfNotExistsOption(
         help="Do nothing if the project already exists."
     ),
@@ -159,124 +174,75 @@ 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(
-        cli_context=cli_context,
-        entity_id=entity_id,
-        project_definition=cli_context.project_definition,
-        entity_type="dcm",
-    )
     om = ObjectManager()
-    if om.object_exists(object_type="dcm", fqn=project.fqn):
-        message = f"DCM Project '{project.fqn}' already exists."
+    if om.object_exists(object_type="dcm", fqn=identifier):
+        message = f"DCM Project '{identifier}' already exists."
         if if_not_exists:
             return MessageResult(message)
         raise CliError(message)
 
-    if not no_version and 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)
+    with cli_console.phase(f"Creating DCM Project '{identifier}'"):
+        dpm.create(project_identifier=identifier)
 
-    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 '{identifier}' 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)
+    results = pm.list_deployments(project_identifier=identifier)
     return QueryResult(results)
 
 
 @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').",
+    deployment_name: str = typer.Argument(
+        help="Name or alias of the deployment to drop. For names containing '$', use single quotes to prevent shell expansion (e.g., 'DEPLOYMENT$1').",
         show_default=False,
     ),
-    if_exists: bool = IfExistsOption(help="Do nothing if the version does not exist."),
+    if_exists: bool = IfExistsOption(
+        help="Do nothing if the deployment does not exist."
+    ),
     **options,
 ):
     """
-    Drops a version from the DCM Project.
+    Drops a deployment from the DCM Project.
     """
     # Detect potential shell expansion issues
-    if version_name and version_name.upper() == "VERSION":
+    if deployment_name and deployment_name.upper() == "DEPLOYMENT":
         cli_console.warning(
-            f"Version name '{version_name}' might be truncated due to shell expansion. "
-            f"If you meant to use a version like 'VERSION$1', try using single quotes: 'VERSION$1'."
+            f"Deployment name '{deployment_name}' might be truncated due to shell expansion. "
+            f"If you meant to use a deployment like 'DEPLOYMENT$1', try using single quotes: 'DEPLOYMENT$1'."
         )
 
     dpm = DCMProjectManager()
-    dpm.drop_version(
-        project_name=identifier,
-        version_name=version_name,
+    dpm.drop_deployment(
+        project_identifier=identifier,
+        deployment_name=deployment_name,
         if_exists=if_exists,
     )
     return MessageResult(
-        f"Version '{version_name}' dropped from DCM Project '{identifier}'."
+        f"Deployment '{deployment_name}' dropped from DCM Project '{identifier}'."
     )
+
+
+def _get_effective_stage(identifier: FQN, from_location: Optional[str]):
+    manager = DCMProjectManager()
+    if not from_location:
+        from_stage = manager.sync_local_files(project_identifier=identifier)
+    elif is_stage_path(from_location):
+        from_stage = from_location
+    else:
+        from_stage = manager.sync_local_files(
+            project_identifier=identifier, source_directory=from_location
+        )
+    return from_stage

snowflake/cli/_plugins/dcm/manager.py

@@ -11,126 +11,173 @@
 # 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 contextlib import contextmanager, nullcontext
+from pathlib import Path
+from typing import Generator, List
 
-from snowflake.cli._plugins.dcm.dcm_project_entity_model import DCMProjectEntityModel
+import yaml
 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.constants import (
+    DEFAULT_SIZE_LIMIT_MB,
+    ObjectType,
+    PatternMatchingType,
+)
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
+from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
-from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.cli.api.utils.path_utils import is_stage_path
+
+MANIFEST_FILE_NAME = "manifest.yml"
+DCM_PROJECT_TYPE = "dcm_project"
 
 
 class DCMProjectManager(SqlExecutionMixin):
+    @contextmanager
+    def _collect_output(
+        self, project_identifier: FQN, output_path: str
+    ) -> Generator[str, None, None]:
+        """
+        Context manager for handling output path - creates temporary stage for local paths,
+        downloads files after execution, and ensures proper cleanup.
+
+        Args:
+            project_identifier: The DCM project identifier
+            output_path: Either a stage path (@stage/path) or local directory path
+
+        Yields:
+            str: The effective output path to use in the DCM command
+        """
+        temp_stage_for_local_output = None
+        stage_manager = StageManager()
+
+        if should_download_files := not is_stage_path(output_path):
+            temp_stage_fqn = FQN.from_resource(
+                ObjectType.DCM_PROJECT, project_identifier, "OUTPUT_TMP_STAGE"
+            )
+            stage_manager.create(temp_stage_fqn, temporary=True)
+            effective_output_path = StagePath.from_stage_str(temp_stage_fqn.identifier)
+            temp_stage_for_local_output = (temp_stage_fqn.identifier, Path(output_path))
+        else:
+            effective_output_path = StagePath.from_stage_str(output_path)
+
+        yield effective_output_path.absolute_path()
+
+        if should_download_files:
+            assert temp_stage_for_local_output is not None
+            stage_path, local_path = temp_stage_for_local_output
+            stage_manager.get_recursive(stage_path=stage_path, dest_path=local_path)
+            cli_console.step(f"Plan output saved to: {local_path.resolve()}")
+        else:
+            cli_console.step(f"Plan output saved to: {output_path}")
+
     def execute(
         self,
-        project_name: FQN,
+        project_identifier: 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 configuration or variables:
-            query += f" USING"
-        if configuration:
-            query += f" CONFIGURATION {configuration}"
-        if variables:
-            query += StageManager.parse_execute_variables(
-                parse_key_value_variables(variables)
-            ).removeprefix(" using")
-        if version:
-            query += f" WITH VERSION {version}"
-        elif from_stage:
+        with self._collect_output(project_identifier, output_path) if (
+            output_path and dry_run
+        ) else nullcontext() as output_stage:
+            query = f"EXECUTE DCM PROJECT {project_identifier.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:
+                query += f" CONFIGURATION {configuration}"
+            if variables:
+                query += StageManager.parse_execute_variables(
+                    parse_key_value_variables(variables)
+                ).removeprefix(" using")
             stage_path = StagePath.from_stage_str(from_stage)
             query += f" FROM {stage_path.absolute_path()}"
-        return self.execute_query(query=query)
+            if output_stage is not None:
+                query += f" OUTPUT_PATH {output_stage}"
+            result = 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)
+        return result
 
-    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_identifier: FQN) -> None:
+        query = f"CREATE DCM PROJECT {project_identifier.sql_identifier}"
+        self.execute_query(query)
 
-    def _create_version(
-        self,
-        project_name: FQN,
-        from_stage: str,
-        alias: str | None = None,
-        comment: str | None = None,
-    ):
-        stage_path = StagePath.from_stage_str(from_stage)
-        query = f"ALTER DCM PROJECT {project_name.identifier} ADD VERSION"
-        if alias:
-            query += f" IF NOT EXISTS {alias}"
-        query += f" FROM {stage_path.absolute_path(at_prefix=True)}"
-        if comment:
-            query += f" COMMENT = '{comment}'"
+    def list_deployments(self, project_identifier: FQN):
+        query = f"SHOW DEPLOYMENTS IN DCM PROJECT {project_identifier.identifier}"
         return self.execute_query(query=query)
 
-    def add_version(
+    def drop_deployment(
         self,
-        project: DCMProjectEntityModel,
-        prune: bool = False,
-        from_stage: Optional[str] = None,
-        alias: Optional[str] = None,
-        comment: Optional[str] = None,
+        project_identifier: FQN,
+        deployment_name: str,
+        if_exists: bool = False,
     ):
         """
-        Adds a version to DCM Project. If [from_stage] is not defined,
-        uploads local files to the stage defined in DCM Project definition.
+        Drops a deployment from the DCM Project.
         """
+        query = f"ALTER DCM PROJECT {project_identifier.identifier} DROP DEPLOYMENT"
+        if if_exists:
+            query += " IF EXISTS"
+        query += f' "{deployment_name}"'
+        return self.execute_query(query=query)
 
-        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,
-                )
+    @staticmethod
+    def sync_local_files(
+        project_identifier: FQN, source_directory: str | None = None
+    ) -> str:
+        source_path = (
+            SecurePath(source_directory).resolve()
+            if source_directory
+            else SecurePath.cwd()
+        )
 
-        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,
+        dcm_manifest_file = source_path / MANIFEST_FILE_NAME
+        if not dcm_manifest_file.exists():
+            raise CliError(
+                f"{MANIFEST_FILE_NAME} was not found in directory {source_path.path}"
             )
 
-    def list_versions(self, project_name: FQN):
-        query = f"SHOW VERSIONS IN DCM PROJECT {project_name.identifier}"
-        return self.execute_query(query=query)
+        with dcm_manifest_file.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
+            dcm_manifest = yaml.safe_load(fd)
+            object_type = dcm_manifest.get("type") if dcm_manifest else None
+            if object_type is None:
+                raise CliError(
+                    f"Manifest file type is undefined. Expected {DCM_PROJECT_TYPE}"
+                )
+            if object_type.lower() != DCM_PROJECT_TYPE:
+                raise CliError(
+                    f"Manifest file is defined for type {object_type}. Expected {DCM_PROJECT_TYPE}"
+                )
 
-    def drop_version(
-        self,
-        project_name: FQN,
-        version_name: str,
-        if_exists: bool = False,
-    ):
-        """
-        Drops a version from the DCM Project.
-        """
-        query = f"ALTER DCM PROJECT {project_name.identifier} DROP VERSION"
-        if if_exists:
-            query += " IF EXISTS"
-        query += f" {version_name}"
-        return self.execute_query(query=query)
+            definitions = list(dcm_manifest.get("include_definitions", list()))
+            if MANIFEST_FILE_NAME not in definitions:
+                definitions.append(MANIFEST_FILE_NAME)
+
+        with cli_console.phase(f"Uploading definition files"):
+            stage_fqn = FQN.from_resource(
+                ObjectType.DCM_PROJECT, project_identifier, "TMP_STAGE"
+            )
+            sync_artifacts_with_stage(
+                project_paths=ProjectPaths(project_root=source_path.path),
+                stage_root=stage_fqn.identifier,
+                use_temporary_stage=True,
+                artifacts=[PathMapping(src=definition) for definition in definitions],
+                pattern_type=PatternMatchingType.REGEX,
+            )
+
+        return stage_fqn.identifier

snowflake/cli/_plugins/logs/commands.py

@@ -48,6 +48,11 @@ def get_logs(
         "--log-level",
         help="The log level to filter by. If not provided, INFO will be used",
     ),
+    partial_match: bool = typer.Option(
+        False,
+        "--partial",
+        help="Enable partial, case-insensitive matching for object names",
+    ),
     **options,
 ):
     """
@@ -75,6 +80,7 @@ def get_logs(
             refresh_time=refresh_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
         logs = itertools.chain(
             (MessageResult(log.log_message) for logs in logs_stream for log in logs)
@@ -87,6 +93,7 @@ def get_logs(
             to_time=to_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
         logs = (MessageResult(log.log_message) for log in logs_iterable)  # type: ignore