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

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

@@ -37,9 +37,13 @@ from snowflake.cli.api.commands.flags import (
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
-from snowflake.cli.api.exceptions import IncompatibleParametersError
+from snowflake.cli.api.exceptions import (
+    IncompatibleParametersError,
+)
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
+    CollectionResult,
     CommandResult,
     MessageResult,
     QueryJsonValueResult,
@@ -55,6 +59,38 @@ app = SnowTyperFactory(
     short_help="Manages services.",
 )
 
+# Define common options
+container_name_option = typer.Option(
+    ...,
+    "--container-name",
+    help="Name of the container.",
+    show_default=False,
+)
+
+instance_id_option = typer.Option(
+    ...,
+    "--instance-id",
+    help="ID of the service instance, starting with 0.",
+    show_default=False,
+)
+
+since_option = typer.Option(
+    default="",
+    help="Fetch events that are newer than this time ago, in Snowflake interval syntax.",
+)
+
+until_option = typer.Option(
+    default="",
+    help="Fetch events that are older than this time ago, in Snowflake interval syntax.",
+)
+
+show_all_columns_option = typer.Option(
+    False,
+    "--all",
+    is_flag=True,
+    help="Fetch all columns.",
+)
+
 
 def _service_name_callback(name: FQN) -> FQN:
     if not is_valid_object_name(name.identifier, max_depth=2, allow_quoted=False):
@@ -209,18 +245,8 @@ def status(name: FQN = ServiceNameArgument, **options) -> CommandResult:
 @app.command(requires_connection=True)
 def logs(
     name: FQN = ServiceNameArgument,
-    container_name: str = typer.Option(
-        ...,
-        "--container-name",
-        help="Name of the container.",
-        show_default=False,
-    ),
-    instance_id: str = typer.Option(
-        ...,
-        "--instance-id",
-        help="ID of the service instance, starting with 0.",
-        show_default=False,
-    ),
+    container_name: str = container_name_option,
+    instance_id: str = instance_id_option,
     num_lines: int = typer.Option(
         DEFAULT_NUM_LINES, "--num-lines", help="Number of lines to retrieve."
     ),
@@ -237,12 +263,17 @@ def logs(
         False, "--include-timestamps", help="Include timestamps in logs.", is_flag=True
     ),
     follow: bool = typer.Option(
-        False, "--follow", help="Stream logs in real-time.", is_flag=True
+        False,
+        "--follow",
+        help="Stream logs in real-time.",
+        is_flag=True,
+        hidden=True,
     ),
     follow_interval: int = typer.Option(
         2,
         "--follow-interval",
         help="Set custom polling intervals for log streaming (--follow flag) in seconds.",
+        hidden=True,
     ),
     **options,
 ):
@@ -288,6 +319,95 @@ def logs(
     return StreamResult(cast(Generator[CommandResult, None, None], stream))
 
 
+@app.command(
+    requires_connection=True,
+    is_enabled=FeatureFlag.ENABLE_SPCS_SERVICE_EVENTS.is_enabled,
+)
+def events(
+    name: FQN = ServiceNameArgument,
+    container_name: str = container_name_option,
+    instance_id: str = instance_id_option,
+    since: str = since_option,
+    until: str = until_option,
+    first: int = typer.Option(
+        default=None,
+        show_default=False,
+        help="Fetch only the first N events. Cannot be used with --last.",
+    ),
+    last: int = typer.Option(
+        default=None,
+        show_default=False,
+        help="Fetch only the last N events. Cannot be used with --first.",
+    ),
+    show_all_columns: bool = show_all_columns_option,
+    **options,
+):
+    """
+    Retrieve platform events for a service container.
+    """
+
+    if first is not None and last is not None:
+        raise IncompatibleParametersError(["--first", "--last"])
+
+    manager = ServiceManager()
+    events = manager.get_events(
+        service_name=name.identifier,
+        container_name=container_name,
+        instance_id=instance_id,
+        since=since,
+        until=until,
+        first=first,
+        last=last,
+        show_all_columns=show_all_columns,
+    )
+
+    if not events:
+        return MessageResult("No events found.")
+
+    return CollectionResult(events)
+
+
+@app.command(
+    requires_connection=True,
+    is_enabled=FeatureFlag.ENABLE_SPCS_SERVICE_METRICS.is_enabled,
+)
+def metrics(
+    name: FQN = ServiceNameArgument,
+    container_name: str = container_name_option,
+    instance_id: str = instance_id_option,
+    since: str = since_option,
+    until: str = until_option,
+    show_all_columns: bool = show_all_columns_option,
+    **options,
+):
+    """
+    Retrieve platform metrics for a service container.
+    """
+
+    manager = ServiceManager()
+    if since or until:
+        metrics = manager.get_all_metrics(
+            service_name=name.identifier,
+            container_name=container_name,
+            instance_id=instance_id,
+            since=since,
+            until=until,
+            show_all_columns=show_all_columns,
+        )
+    else:
+        metrics = manager.get_latest_metrics(
+            service_name=name.identifier,
+            container_name=container_name,
+            instance_id=instance_id,
+            show_all_columns=show_all_columns,
+        )
+
+    if not metrics:
+        return MessageResult("No metrics found.")
+
+    return CollectionResult(metrics)
+
+
 @app.command(requires_connection=True)
 def upgrade(
     name: FQN = ServiceNameArgument,

snowflake/cli/_plugins/spcs/services/manager.py

@@ -16,14 +16,21 @@ from __future__ import annotations
 
 import json
 import time
+from datetime import datetime
 from pathlib import Path
 from typing import List, Optional
 
 import yaml
 from snowflake.cli._plugins.object.common import Tag
 from snowflake.cli._plugins.spcs.common import (
+    EVENT_COLUMN_NAMES,
     NoPropertiesProvidedError,
+    SPCSEventTableError,
+    build_resource_clause,
+    build_time_clauses,
     filter_log_timestamp,
+    format_event_row,
+    format_metric_row,
     handle_object_already_exists,
     new_logs_only,
     strip_empty_lines,
@@ -31,7 +38,7 @@ from snowflake.cli._plugins.spcs.common import (
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, ObjectType
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
-from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
 
@@ -199,6 +206,167 @@ class ServiceManager(SqlExecutionMixin):
         except KeyboardInterrupt:
             return
 
+    def get_account_event_table(self):
+        query = "show parameters like 'event_table' in account"
+        results = self.execute_query(query, cursor_class=DictCursor)
+        event_table = next(
+            (r["value"] for r in results if r["key"] == "EVENT_TABLE"), ""
+        )
+        if not event_table:
+            raise SPCSEventTableError("No SPCS event table configured in the account.")
+        return event_table
+
+    def get_events(
+        self,
+        service_name: str,
+        instance_id: str,
+        container_name: str,
+        since: str | datetime | None = None,
+        until: str | datetime | None = None,
+        first: Optional[int] = None,
+        last: Optional[int] = None,
+        show_all_columns: bool = False,
+    ):
+
+        account_event_table = self.get_account_event_table()
+        resource_clause = build_resource_clause(
+            service_name, instance_id, container_name
+        )
+        since_clause, until_clause = build_time_clauses(since, until)
+
+        first_clause = f"limit {first}" if first is not None else ""
+        last_clause = f"limit {last}" if last is not None else ""
+
+        query = f"""\
+                     select *
+                    from (
+                        select *
+                        from {account_event_table}
+                        where (
+                            {resource_clause}
+                            {since_clause}
+                            {until_clause}
+                        )
+                        and record_type = 'LOG'
+                        and scope['name'] = 'snow.spcs.platform'
+                        order by timestamp desc
+                        {last_clause}
+                    )
+                    order by timestamp asc
+                    {first_clause}
+                """
+
+        cursor = self.execute_query(query)
+        raw_events = cursor.fetchall()
+        if not raw_events:
+            return []
+
+        if show_all_columns:
+            return [dict(zip(EVENT_COLUMN_NAMES, event)) for event in raw_events]
+
+        formatted_events = []
+        for raw_event in raw_events:
+            event_dict = dict(zip(EVENT_COLUMN_NAMES, raw_event))
+            formatted = format_event_row(event_dict)
+            formatted_events.append(formatted)
+
+        return formatted_events
+
+    def get_all_metrics(
+        self,
+        service_name: str,
+        instance_id: str,
+        container_name: str,
+        since: str | datetime | None = None,
+        until: str | datetime | None = None,
+        show_all_columns: bool = False,
+    ):
+
+        account_event_table = self.get_account_event_table()
+        resource_clause = build_resource_clause(
+            service_name, instance_id, container_name
+        )
+        since_clause, until_clause = build_time_clauses(since, until)
+
+        query = f"""\
+                    select *
+                    from {account_event_table}
+                    where (
+                        {resource_clause}
+                        {since_clause}
+                        {until_clause}
+                    )
+                    and record_type = 'METRIC'
+                    and scope['name'] = 'snow.spcs.platform'
+                    order by timestamp desc
+                """
+
+        cursor = self.execute_query(query)
+        raw_metrics = cursor.fetchall()
+        if not raw_metrics:
+            return []
+
+        if show_all_columns:
+            return [dict(zip(EVENT_COLUMN_NAMES, metric)) for metric in raw_metrics]
+
+        formatted_metrics = []
+        for raw_metric in raw_metrics:
+            metric_dict = dict(zip(EVENT_COLUMN_NAMES, raw_metric))
+            formatted = format_metric_row(metric_dict)
+            formatted_metrics.append(formatted)
+
+        return formatted_metrics
+
+    def get_latest_metrics(
+        self,
+        service_name: str,
+        instance_id: str,
+        container_name: str,
+        show_all_columns: bool = False,
+    ):
+
+        account_event_table = self.get_account_event_table()
+        resource_clause = build_resource_clause(
+            service_name, instance_id, container_name
+        )
+
+        query = f"""
+            with rankedmetrics as (
+                select
+                    *,
+                    row_number() over (
+                        partition by record['metric']['name']
+                        order by timestamp desc
+                    ) as rank
+                from {account_event_table}
+                where
+                    record_type = 'METRIC'
+                    and scope['name'] = 'snow.spcs.platform'
+                    and {resource_clause}
+                    and timestamp > dateadd('hour', -1, current_timestamp)
+            )
+            select *
+            from rankedmetrics
+            where rank = 1
+            order by timestamp desc;
+        """
+
+        cursor = self.execute_query(query)
+        raw_metrics = cursor.fetchall()
+        if not raw_metrics:
+            return []
+
+        if show_all_columns:
+            return [dict(zip(EVENT_COLUMN_NAMES, metric)) for metric in raw_metrics]
+
+        formatted_metrics = []
+        for raw_metric in raw_metrics:
+            metric_dict = dict(zip(EVENT_COLUMN_NAMES, raw_metric))
+            formatted = format_metric_row(metric_dict)
+            formatted_metrics.append(formatted)
+
+        return formatted_metrics
+
     def upgrade_spec(self, service_name: str, spec_path: Path):
         spec = self._read_yaml(spec_path)
         query = f"alter service {service_name} from specification $$ {spec} $$"

snowflake/cli/_plugins/stage/manager.py

@@ -41,7 +41,7 @@ from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import PYTHON_3_12
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.util import to_string_literal
+from snowflake.cli.api.project.util import extract_schema, to_string_literal
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
@@ -86,6 +86,10 @@ class StagePathParts:
     def full_path(self) -> str:
         raise NotImplementedError
 
+    @property
+    def schema(self) -> str | None:
+        raise NotImplementedError
+
     def replace_stage_prefix(self, file_path: str) -> str:
         raise NotImplementedError
 
@@ -139,11 +143,15 @@ class DefaultStagePathParts(StagePathParts):
 
     @property
     def path(self) -> str:
-        return f"{self.stage_name.rstrip('/')}/{self.directory}"
+        return f"{self.stage_name.rstrip('/')}/{self.directory}".rstrip("/")
 
     @property
     def full_path(self) -> str:
-        return f"{self.stage.rstrip('/')}/{self.directory}"
+        return f"{self.stage.rstrip('/')}/{self.directory}".rstrip("/")
+
+    @property
+    def schema(self) -> str | None:
+        return extract_schema(self.stage)
 
     def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
@@ -193,7 +201,7 @@ class UserStagePathParts(StagePathParts):
 
     @property
     def full_path(self) -> str:
-        return f"{self.stage}/{self.directory}"
+        return f"{self.stage}/{self.directory}".rstrip("/")
 
     def replace_stage_prefix(self, file_path: str) -> str:
         if Path(file_path).parts[0] == self.stage_name:

snowflake/cli/_plugins/streamlit/manager.py

@@ -104,8 +104,15 @@ class StreamlitManager(SqlExecutionMixin):
         query.append(f"MAIN_FILE = '{streamlit.main_file}'")
         if streamlit.imports:
             query.append(streamlit.get_imports_sql())
-        if streamlit.query_warehouse:
+
+        if not streamlit.query_warehouse:
+            cli_console.warning(
+                "[Deprecation] In next major version we will remove default query_warehouse='streamlit'."
+            )
+            query.append(f"QUERY_WAREHOUSE = 'streamlit'")
+        else:
             query.append(f"QUERY_WAREHOUSE = {streamlit.query_warehouse}")
+
         if streamlit.title:
             query.append(f"TITLE = '{streamlit.title}'")
 

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -1,7 +1,17 @@
+import functools
+from pathlib import Path
+from typing import Optional
+
+from click import ClickException
+from snowflake.cli._plugins.connection.util import make_snowsight_url
+from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
-from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli._plugins.workspace.context import ActionContext
+from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
+from snowflake.cli.api.secure_path import SecurePath
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 class StreamlitEntity(EntityBase[StreamlitEntityModel]):
@@ -9,4 +19,145 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
     A Streamlit app.
     """
 
-    pass
+    def __init__(self, *args, **kwargs):
+        if not FeatureFlag.ENABLE_NATIVE_APP_CHILDREN.is_enabled():
+            raise NotImplementedError("Streamlit entity is not implemented yet")
+        super().__init__(*args, **kwargs)
+
+    @property
+    def root(self):
+        return self._workspace_ctx.project_root
+
+    @property
+    def artifacts(self):
+        return self._entity_model.artifacts
+
+    @functools.cached_property
+    def _sql_executor(self):
+        return get_sql_executor()
+
+    @functools.cached_property
+    def _conn(self):
+        return self._sql_executor._conn  # noqa
+
+    @property
+    def model(self):
+        return self._entity_model  # noqa
+
+    def action_bundle(self, action_ctx: ActionContext, *args, **kwargs):
+        return self.bundle()
+
+    def action_deploy(self, action_ctx: ActionContext, *args, **kwargs):
+        # After adding bundle map- we should use it's mapping here
+        # To copy artifacts to destination on stage.
+
+        return self._sql_executor.execute_query(self.get_deploy_sql())
+
+    def action_drop(self, action_ctx: ActionContext, *args, **kwargs):
+        return self._sql_executor.execute_query(self.get_drop_sql())
+
+    def action_execute(
+        self, action_ctx: ActionContext, *args, **kwargs
+    ) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(self.get_execute_sql())
+
+    def action_get_url(
+        self, action_ctx: ActionContext, *args, **kwargs
+    ):  # maybe this should be a property
+        name = self._entity_model.fqn.using_connection(self._conn)
+        return make_snowsight_url(
+            self._conn, f"/#/streamlit-apps/{name.url_identifier}"
+        )
+
+    def bundle(self, output_dir: Optional[Path] = None):
+
+        if not output_dir:
+            output_dir = self.root / "output" / self._entity_model.stage
+
+        artifacts = self._entity_model.artifacts
+
+        output_dir.mkdir(parents=True, exist_ok=True)  # type: ignore
+
+        output_files = []
+
+        # This is far from , but will be replaced by bundlemap mappings.
+        for file in artifacts:
+            output_file = output_dir / file.name
+
+            if file.is_file():
+                SecurePath(file).copy(output_file)
+            elif file.is_dir():
+                output_file.mkdir(parents=True, exist_ok=True)
+                SecurePath(file).copy(output_file, dirs_exist_ok=True)
+
+                output_files.append(output_file)
+
+        return output_files
+
+    def action_share(
+        self, action_ctx: ActionContext, to_role: str, *args, **kwargs
+    ) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(self.get_share_sql(to_role))
+
+    def get_deploy_sql(
+        self,
+        if_not_exists: bool = False,
+        replace: bool = False,
+        from_stage_name: Optional[str] = None,
+        artifacts_dir: Optional[Path] = None,
+        schema: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
+        if replace and if_not_exists:
+            raise ClickException("Cannot specify both replace and if_not_exists")
+
+        if replace:
+            query = "CREATE OR REPLACE "
+        elif if_not_exists:
+            query = "CREATE IF NOT EXISTS "
+        else:
+            query = "CREATE "
+
+        schema_to_use = schema or self._entity_model.fqn.schema
+        query += f"STREAMLIT {self._entity_model.fqn.set_schema(schema_to_use).sql_identifier}"
+
+        if from_stage_name:
+            query += f"\nROOT_LOCATION = '{from_stage_name}'"
+        elif artifacts_dir:
+            query += f"\nFROM '{artifacts_dir}'"
+
+        query += f"\nMAIN_FILE = '{self._entity_model.main_file}'"
+
+        if self.model.imports:
+            query += "\n" + self.model.get_imports_sql()
+
+        if self.model.query_warehouse:
+            query += f"\nQUERY_WAREHOUSE = '{self.model.query_warehouse}'"
+
+        if self.model.title:
+            query += f"\nTITLE = '{self.model.title}'"
+
+        if self.model.comment:
+            query += f"\nCOMMENT = '{self.model.comment}'"
+
+        if self.model.external_access_integrations:
+            query += "\n" + self.model.get_external_access_integrations_sql()
+
+        if self.model.secrets:
+            query += "\n" + self.model.get_secrets_sql()
+
+        return query + ";"
+
+    def get_share_sql(self, to_role: str) -> str:
+        return f"GRANT USAGE ON STREAMLIT {self.model.fqn.sql_identifier} TO ROLE {to_role};"
+
+    def get_execute_sql(self):
+        return f"EXECUTE STREAMLIT {self._entity_model.fqn}();"
+
+    def get_usage_grant_sql(self, app_role: str, schema: Optional[str] = None) -> str:
+        entity_id = self.entity_id
+        streamlit_name = f"{schema}.{entity_id}" if schema else entity_id
+        return (
+            f"GRANT USAGE ON STREAMLIT {streamlit_name} TO APPLICATION ROLE {app_role};"
+        )

snowflake/cli/_plugins/workspace/commands.py

@@ -34,7 +34,7 @@ from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.entities.common import EntityActions
 from snowflake.cli.api.exceptions import IncompatibleParametersError
-from snowflake.cli.api.output.types import MessageResult, QueryResult
+from snowflake.cli.api.output.types import CollectionResult, MessageResult
 
 ws = SnowTyperFactory(
     name="ws",
@@ -243,7 +243,7 @@ def version_list(
         entity_id,
         EntityActions.VERSION_LIST,
     )
-    return QueryResult(cursor)
+    return CollectionResult(cursor)
 
 
 @version.command(name="create", requires_connection=True, hidden=True)
@@ -293,6 +293,7 @@ def version_create(
         skip_git_check=skip_git_check,
         interactive=interactive,
         force=force,
+        from_stage=False,
     )
 
 

snowflake/cli/_plugins/workspace/manager.py

@@ -1,3 +1,4 @@
+from functools import cached_property
 from pathlib import Path
 from typing import Dict
 
@@ -58,10 +59,7 @@ class WorkspaceManager:
         """
         entity = self.get_entity(entity_id)
         if entity.supports(action):
-            action_ctx = ActionContext(
-                get_entity=self.get_entity,
-            )
-            return entity.perform(action, action_ctx, *args, **kwargs)
+            return entity.perform(action, self.action_ctx, *args, **kwargs)
         else:
             raise ValueError(f'This entity type does not support "{action.value}"')
 
@@ -69,6 +67,12 @@ class WorkspaceManager:
     def project_root(self) -> Path:
         return self._project_root
 
+    @cached_property
+    def action_ctx(self) -> ActionContext:
+        return ActionContext(
+            get_entity=self.get_entity,
+        )
+
 
 def _get_default_role() -> str:
     role = default_role()