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

snowflake/cli/_plugins/nativeapp/utils.py

@@ -96,3 +96,14 @@ def verify_no_directories(paths_to_sync: Iterable[Path]):
 def verify_exists(path: Path):
     if not path.exists():
         raise ClickException(f"The following path does not exist: {path}")
+
+
+def sanitize_dir_name(dir_name: str) -> str:
+    """
+    Returns a string that is safe to use as a directory name.
+    For simplicity, this function is over restricitive: it strips non alphanumeric characters,
+    unless listed in the allow list. Additional characters can be allowed in the future, but
+    we need to be careful to consider both Unix/Windows directory naming rules.
+    """
+    allowed_chars = [" ", "_"]
+    return "".join(char for char in dir_name if char in allowed_chars or char.isalnum())

snowflake/cli/_plugins/nativeapp/v2_conversions/compat.py

@@ -217,7 +217,11 @@ def force_project_definition_v2(
                     entities_to_keep.add(app_definition.entity_id)
                     kwargs["app_entity_id"] = app_definition.entity_id
                 for entity_id in list(original_pdf.entities):
-                    if entity_id not in entities_to_keep:
+                    entity_type = original_pdf.entities[entity_id].type.lower()
+                    if (
+                        entity_type in ["application", "application package"]
+                        and entity_id not in entities_to_keep
+                    ):
                         # This happens after templates are rendered,
                         # so we can safely remove the entity
                         del original_pdf.entities[entity_id]

snowflake/cli/_plugins/nativeapp/version/commands.py

@@ -18,6 +18,7 @@ import logging
 from typing import Optional
 
 import typer
+from snowflake.cli._plugins.nativeapp.artifacts import VersionInfo
 from snowflake.cli._plugins.nativeapp.common_flags import ForceOption, InteractiveOption
 from snowflake.cli._plugins.nativeapp.v2_conversions.compat import (
     force_project_definition_v2,
@@ -29,7 +30,14 @@ from snowflake.cli.api.commands.decorators import (
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.entities.common import EntityActions
-from snowflake.cli.api.output.types import CommandResult, MessageResult, QueryResult
+from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.output.types import (
+    CollectionResult,
+    CommandResult,
+    MessageResult,
+    ObjectResult,
+)
+from snowflake.cli.api.project.util import to_identifier
 
 app = SnowTyperFactory(
     name="version",
@@ -64,6 +72,12 @@ def create(
         help="When enabled, the Snowflake CLI skips checking if your project has any untracked or stages files in git. Default: unset.",
         is_flag=True,
     ),
+    from_stage: bool = typer.Option(
+        False,
+        "--from-stage",
+        help="When enabled, the Snowflake CLI creates a version from the current application package stage without syncing to the stage first.",
+        is_flag=True,
+    ),
     interactive: bool = InteractiveOption,
     force: Optional[bool] = ForceOption,
     **options,
@@ -78,7 +92,7 @@ def create(
         project_root=cli_context.project_root,
     )
     package_id = options["package_entity_id"]
-    ws.perform_action(
+    result: VersionInfo = ws.perform_action(
         package_id,
         EntityActions.VERSION_CREATE,
         version=version,
@@ -87,8 +101,21 @@ def create(
         force=force,
         interactive=interactive,
         skip_git_check=skip_git_check,
+        from_stage=from_stage,
     )
-    return MessageResult(f"Version create is now complete.")
+
+    message = "Version create is now complete."
+    if cli_context.output_format == OutputFormat.JSON:
+        return ObjectResult(
+            {
+                "message": message,
+                "version": to_identifier(result.version_name),
+                "patch": result.patch_number,
+                "label": result.label,
+            }
+        )
+    else:
+        return MessageResult(message)
 
 
 @app.command("list", requires_connection=True)
@@ -110,7 +137,7 @@ def version_list(
         package_id,
         EntityActions.VERSION_LIST,
     )
-    return QueryResult(cursor)
+    return CollectionResult(cursor)
 
 
 @app.command(requires_connection=True)

snowflake/cli/_plugins/notebook/manager.py

@@ -21,6 +21,7 @@ from snowflake.cli._plugins.notebook.types import NotebookStagePath
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.cli.api.stage_path import StagePath
 
 
 class NotebookManager(SqlExecutionMixin):
@@ -40,8 +41,9 @@ class NotebookManager(SqlExecutionMixin):
         """Parses notebook file path to pathlib.Path."""
         if not notebook_file.endswith(".ipynb"):
             raise NotebookStagePathError(notebook_file)
-        stage_path = Path(notebook_file)
-        if len(stage_path.parts) < 2:
+        # we don't perform any operations on the path, so we don't need to differentiate git repository paths
+        stage_path = StagePath.from_stage_str(notebook_file)
+        if len(stage_path.parts) < 1:
             raise NotebookStagePathError(notebook_file)
 
         return stage_path

snowflake/cli/_plugins/snowpark/snowpark_entity.py

@@ -1,16 +1,228 @@
-from typing import Generic, TypeVar
+from enum import Enum
+from pathlib import Path
+from typing import Generic, List, Optional, TypeVar
 
+from click import ClickException
+from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
+from snowflake.cli._plugins.snowpark import package_utils
+from snowflake.cli._plugins.snowpark.common import DEFAULT_RUNTIME
+from snowflake.cli._plugins.snowpark.package.anaconda_packages import (
+    AnacondaPackages,
+    AnacondaPackagesManager,
+)
+from snowflake.cli._plugins.snowpark.package_utils import (
+    DownloadUnavailablePackagesResult,
+)
 from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
     FunctionEntityModel,
     ProcedureEntityModel,
 )
+from snowflake.cli._plugins.snowpark.zipper import zip_dir
+from snowflake.cli._plugins.workspace.context import ActionContext
 from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli.api.secure_path import SecurePath
+from snowflake.connector import ProgrammingError
 
 T = TypeVar("T")
 
 
+class CreateMode(
+    str, Enum
+):  # This should probably be moved to some common place, think where
+    create = "CREATE"
+    create_or_replace = "CREATE OR REPLACE"
+    create_if_not_exists = "CREATE IF NOT EXISTS"
+
+
 class SnowparkEntity(EntityBase[Generic[T]]):
-    pass
+    def __init__(self, *args, **kwargs):
+
+        if not FeatureFlag.ENABLE_NATIVE_APP_CHILDREN.is_enabled():
+            raise NotImplementedError("Snowpark entity is not implemented yet")
+        super().__init__(*args, **kwargs)
+
+    def action_bundle(
+        self,
+        action_ctx: ActionContext,
+        output_dir: Path | None,
+        ignore_anaconda: bool,
+        skip_version_check: bool,
+        index_url: str | None = None,
+        allow_shared_libraries: bool = False,
+        *args,
+        **kwargs,
+    ) -> List[Path]:
+        return self.bundle(
+            output_dir,
+            ignore_anaconda,
+            skip_version_check,
+            index_url,
+            allow_shared_libraries,
+        )
+
+    def action_deploy(
+        self, action_ctx: ActionContext, mode: CreateMode, *args, **kwargs
+    ):
+        # TODO: After introducing bundle map, we should introduce file copying part here
+        return self._execute_query(self.get_deploy_sql(mode))
+
+    def action_drop(self, action_ctx: ActionContext, *args, **kwargs):
+        return self._execute_query(self.get_drop_sql())
+
+    def action_describe(self, action_ctx: ActionContext, *args, **kwargs):
+        return self._execute_query(self.get_describe_sql())
+
+    def action_execute(
+        self,
+        action_ctx: ActionContext,
+        execution_arguments: List[str] | None = None,
+        *args,
+        **kwargs,
+    ):
+        return self._execute_query(self.get_execute_sql(execution_arguments))
+
+    def bundle(
+        self,
+        output_dir: Path | None,
+        ignore_anaconda: bool,
+        skip_version_check: bool,
+        index_url: str | None = None,
+        allow_shared_libraries: bool = False,
+    ) -> List[Path]:
+        """
+        Bundles the entity artifacts and dependencies into a directory.
+        Parameters:
+            output_dir: The directory to output the bundled artifacts to. Defaults to output dir in project root
+            ignore_anaconda: If True, ignores anaconda chceck and tries to download all packages using pip
+            skip_version_check: If True, skips version check when downloading packages
+            index_url: The index URL to use when downloading packages, if none set - default pip index is used (in most cases- Pypi)
+            allow_shared_libraries: If not set to True, using dependency with .so/.dll files will raise an exception
+        Returns:
+        """
+        # 0 Create a directory for the entity
+        if not output_dir:
+            output_dir = self.root / "output" / "bundle" / "snowpark"
+        output_dir.mkdir(parents=True, exist_ok=True)  # type: ignore
+
+        output_files = []
+
+        # 1 Check if requirements exits
+        if (self.root / "requirements.txt").exists():
+            download_results = self._process_requirements(
+                bundle_dir=output_dir,  # type: ignore
+                archive_name="dependencies.zip",
+                requirements_file=SecurePath(self.root / "requirements.txt"),
+                ignore_anaconda=ignore_anaconda,
+                skip_version_check=skip_version_check,
+                index_url=index_url,
+                allow_shared_libraries=allow_shared_libraries,
+            )
+
+        # 3 get the artifacts list
+        artifacts = self.model.artifacts
+
+        for artifact in artifacts:
+            output_file = output_dir / artifact.dest / artifact.src.name
+
+            if artifact.src.is_file():
+                output_file.mkdir(parents=True, exist_ok=True)
+                SecurePath(artifact.src).copy(output_file)
+            elif artifact.is_dir():
+                output_file.mkdir(parents=True, exist_ok=True)
+
+            output_files.append(output_file)
+
+        return output_files
+
+    def check_if_exists(
+        self, action_ctx: ActionContext
+    ) -> bool:  # TODO it should return current state, so we know if update is necessary
+        try:
+            current_state = self.action_describe(action_ctx)
+            return True
+        except ProgrammingError:
+            return False
+
+    def get_deploy_sql(self, mode: CreateMode):
+        query = [
+            f"{mode.value} {self.model.type.upper()} {self.identifier}",
+            "COPY GRANTS",
+            f"RETURNS {self.model.returns}",
+            f"LANGUAGE PYTHON",
+            f"RUNTIME_VERSION '{self.model.runtime or DEFAULT_RUNTIME}'",
+            f"IMPORTS={','.join(self.model.imports)}",  # TODO: Add source files here after introducing bundlemap
+            f"HANDLER='{self.model.handler}'",
+        ]
+
+        if self.model.external_access_integrations:
+            query.append(self.model.get_external_access_integrations_sql())
+
+        if self.model.secrets:
+            query.append(self.model.get_secrets_sql())
+
+        if self.model.type == "procedure" and self.model.execute_as_caller:
+            query.append("EXECUTE AS CALLER")
+
+        return "\n".join(query)
+
+    def get_execute_sql(self, execution_arguments: List[str] | None = None):
+        raise NotImplementedError
+
+    def _process_requirements(  # TODO: maybe leave all the logic with requirements here - so download, write requirements file etc.
+        self,
+        bundle_dir: Path,
+        archive_name: str,  # TODO: not the best name, think of something else
+        requirements_file: Optional[SecurePath],
+        ignore_anaconda: bool,
+        skip_version_check: bool = False,
+        index_url: Optional[str] = None,
+        allow_shared_libraries: bool = False,
+    ) -> DownloadUnavailablePackagesResult:
+        """
+        Processes the requirements file and downloads the dependencies
+        Parameters:
+
+        """
+        anaconda_packages_manager = AnacondaPackagesManager()
+        with SecurePath.temporary_directory() as tmp_dir:
+            requirements = package_utils.parse_requirements(requirements_file)
+            anaconda_packages = (
+                AnacondaPackages.empty()
+                if ignore_anaconda
+                else anaconda_packages_manager.find_packages_available_in_snowflake_anaconda()
+            )
+            download_result = package_utils.download_unavailable_packages(
+                requirements=requirements,
+                target_dir=tmp_dir,
+                anaconda_packages=anaconda_packages,
+                skip_version_check=skip_version_check,
+                pip_index_url=index_url,
+            )
+
+            if download_result.anaconda_packages:
+                anaconda_packages.write_requirements_file_in_snowflake_format(
+                    file_path=SecurePath(bundle_dir / "requirements.txt"),
+                    requirements=download_result.anaconda_packages,
+                )
+
+            if download_result.downloaded_packages_details:
+                if (
+                    package_utils.detect_and_log_shared_libraries(
+                        download_result.downloaded_packages_details
+                    )
+                    and not allow_shared_libraries
+                ):
+                    raise ClickException(
+                        "Some packages contain shared (.so/.dll) libraries. "
+                        "Try again with allow_shared_libraries_flag."
+                    )
+
+                zip_dir(
+                    source=tmp_dir,
+                    dest_zip=bundle_dir / archive_name,
+                )
+
+        return download_result
 
 
 class FunctionEntity(SnowparkEntity[FunctionEntityModel]):
@@ -18,7 +230,17 @@ class FunctionEntity(SnowparkEntity[FunctionEntityModel]):
     A single UDF
     """
 
-    pass
+    # TO THINK OF
+    # Where will we get imports? Should we rely on bundle map? Or should it be self-sufficient in this matter?
+
+    def get_execute_sql(
+        self, execution_arguments: List[str] | None = None, *args, **kwargs
+    ):
+        if not execution_arguments:
+            execution_arguments = []
+        return (
+            f"SELECT {self.fqn}({', '.join([str(arg) for arg in execution_arguments])})"
+        )
 
 
 class ProcedureEntity(SnowparkEntity[ProcedureEntityModel]):
@@ -26,4 +248,12 @@ class ProcedureEntity(SnowparkEntity[ProcedureEntityModel]):
     A stored procedure
     """
 
-    pass
+    def get_execute_sql(
+        self,
+        execution_arguments: List[str] | None = None,
+    ):
+        if not execution_arguments:
+            execution_arguments = []
+        return (
+            f"CALL {self.fqn}({', '.join([str(arg) for arg in execution_arguments])})"
+        )

snowflake/cli/_plugins/spcs/common.py

@@ -14,7 +14,9 @@
 
 from __future__ import annotations
 
+import json
 import sys
+from datetime import datetime
 from typing import TextIO
 
 from click import ClickException
@@ -23,6 +25,22 @@ from snowflake.cli.api.exceptions import ObjectAlreadyExistsError
 from snowflake.cli.api.project.util import unquote_identifier
 from snowflake.connector.errors import ProgrammingError
 
+EVENT_COLUMN_NAMES = [
+    "TIMESTAMP",
+    "START_TIMESTAMP",
+    "OBSERVED_TIMESTAMP",
+    "TRACE",
+    "RESOURCE",
+    "RESOURCE_ATTRIBUTES",
+    "SCOPE",
+    "SCOPE_ATTRIBUTES",
+    "RECORD_TYPE",
+    "RECORD",
+    "RECORD_ATTRIBUTES",
+    "VALUE",
+    "EXEMPLARS",
+]
+
 if not sys.stdout.closed and sys.stdout.isatty():
     GREEN = "\033[32m"
     BLUE = "\033[34m"
@@ -124,5 +142,116 @@ def new_logs_only(prev_log_records: list[str], new_log_records: list[str]) -> li
     return new_log_records_sorted
 
 
+def build_resource_clause(
+    service_name: str, instance_id: str, container_name: str
+) -> str:
+    resource_filters = []
+    if service_name:
+        resource_filters.append(
+            f"resource_attributes:\"snow.service.name\" = '{service_name}'"
+        )
+    if instance_id:
+        resource_filters.append(
+            f"(resource_attributes:\"snow.service.instance\" = '{instance_id}' "
+            f"OR resource_attributes:\"snow.service.container.instance\" = '{instance_id}')"
+        )
+    if container_name:
+        resource_filters.append(
+            f"resource_attributes:\"snow.service.container.name\" = '{container_name}'"
+        )
+    return " and ".join(resource_filters) if resource_filters else "1=1"
+
+
+def build_time_clauses(
+    since: str | datetime | None, until: str | datetime | None
+) -> tuple[str, str]:
+    since_clause = ""
+    until_clause = ""
+
+    if isinstance(since, datetime):
+        since_clause = f"and timestamp >= '{since}'"
+    elif isinstance(since, str) and since:
+        since_clause = f"and timestamp >= sysdate() - interval '{since}'"
+
+    if isinstance(until, datetime):
+        until_clause = f"and timestamp <= '{until}'"
+    elif isinstance(until, str) and until:
+        until_clause = f"and timestamp <= sysdate() - interval '{until}'"
+
+    return since_clause, until_clause
+
+
+def format_event_row(event_dict: dict) -> dict:
+    try:
+        resource_attributes = json.loads(event_dict.get("RESOURCE_ATTRIBUTES", "{}"))
+        record_attributes = json.loads(event_dict.get("RECORD_ATTRIBUTES", "{}"))
+        record = json.loads(event_dict.get("RECORD", "{}"))
+
+        database_name = resource_attributes.get("snow.database.name", "N/A")
+        schema_name = resource_attributes.get("snow.schema.name", "N/A")
+        service_name = resource_attributes.get("snow.service.name", "N/A")
+        instance_name = resource_attributes.get("snow.service.instance", "N/A")
+        container_name = resource_attributes.get("snow.service.container.name", "N/A")
+        event_name = record_attributes.get("event.name", "Unknown Event")
+        event_value = event_dict.get("VALUE", "Unknown Value")
+        severity = record.get("severity_text", "Unknown Severity")
+
+        return {
+            "TIMESTAMP": event_dict.get("TIMESTAMP", "N/A"),
+            "DATABASE NAME": database_name,
+            "SCHEMA NAME": schema_name,
+            "SERVICE NAME": service_name,
+            "INSTANCE ID": instance_name,
+            "CONTAINER NAME": container_name,
+            "SEVERITY": severity,
+            "EVENT NAME": event_name,
+            "EVENT VALUE": event_value,
+        }
+    except (json.JSONDecodeError, KeyError) as e:
+        raise RecordProcessingError(f"Error processing event row.")
+
+
+def format_metric_row(metric_dict: dict) -> dict:
+    try:
+        resource_attributes = json.loads(metric_dict["RESOURCE_ATTRIBUTES"])
+        record = json.loads(metric_dict["RECORD"])
+
+        database_name = resource_attributes.get("snow.database.name", "N/A")
+        schema_name = resource_attributes.get("snow.schema.name", "N/A")
+        service_name = resource_attributes.get("snow.service.name", "N/A")
+        instance_name = resource_attributes.get(
+            "snow.service.container.instance", "N/A"
+        )
+        container_name = resource_attributes.get("snow.service.container.name", "N/A")
+
+        metric_name = record["metric"].get("name", "Unknown Metric")
+        metric_value = metric_dict.get("VALUE", "Unknown Value")
+
+        return {
+            "TIMESTAMP": metric_dict.get("TIMESTAMP", "N/A"),
+            "DATABASE NAME": database_name,
+            "SCHEMA NAME": schema_name,
+            "SERVICE NAME": service_name,
+            "INSTANCE ID": instance_name,
+            "CONTAINER NAME": container_name,
+            "METRIC NAME": metric_name,
+            "METRIC VALUE": metric_value,
+        }
+    except (json.JSONDecodeError, KeyError) as e:
+        raise RecordProcessingError(f"Error processing metric row.")
+
+
+class RecordProcessingError(ClickException):
+    """Raised when processing an event or metric record fails due to invalid data."""
+
+    pass
+
+
+class SPCSEventTableError(ClickException):
+    """Raised when there is an issue related to the SPCS event table."""
+
+    pass
+
+
 class NoPropertiesProvidedError(ClickException):
     pass