snowflake-cli 3.7.2__py3-none-any.whl → 3.8.1__py3-none-any.whl

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -1,19 +1,27 @@
+import logging
 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.artifacts import build_bundle
-from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
+from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
 from snowflake.cli._plugins.workspace.context import ActionContext
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli.api.entities.utils import EntityActions, sync_deploy_root_with_stage
+from snowflake.cli.api.feature_flags import FeatureFlag as GlobalFeatureFlag
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.project_paths import bundle_root
-from snowflake.cli.api.project.schemas.entities.common import PathMapping
+from snowflake.cli.api.project.schemas.entities.common import Identifier, PathMapping
+from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
 
+log = logging.getLogger(__name__)
+
 
 class StreamlitEntity(EntityBase[StreamlitEntityModel]):
     """
@@ -21,8 +29,6 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
     """
 
     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
@@ -37,10 +43,10 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         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.deploy(action_ctx, *args, **kwargs)
 
-        return self.deploy()
+    def action_describe(self, action_ctx: ActionContext, *args, **kwargs):
+        return self.describe()
 
     def action_drop(self, action_ctx: ActionContext, *args, **kwargs):
         return self._execute_query(self.get_drop_sql())
@@ -58,10 +64,10 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             self._conn, f"/#/streamlit-apps/{name.url_identifier}"
         )
 
-    def bundle(self, output_dir: Optional[Path] = None):
-        build_bundle(
+    def bundle(self, output_dir: Optional[Path] = None) -> BundleMap:
+        return build_bundle(
             self.root,
-            output_dir or bundle_root(self.root, "streamlit"),
+            output_dir or bundle_root(self.root, "streamlit") / self.entity_id,
             [
                 PathMapping(
                     src=artifact.src, dest=artifact.dest, processors=artifact.processors
@@ -70,14 +76,89 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             ],
         )
 
-    def deploy(self, *args, **kwargs):
-        return self._execute_query(self.get_deploy_sql())
+    def deploy(
+        self,
+        action_context: ActionContext,
+        _open: bool,
+        replace: bool,
+        prune: bool = False,
+        bundle_map: Optional[BundleMap] = None,
+        experimental: Optional[bool] = False,
+        *args,
+        **kwargs,
+    ):
+        if (
+            bundle_map is None
+        ):  # TODO: maybe we could hold bundle map as a cached property?
+            bundle_map = self.bundle()
+
+        console = self._workspace_ctx.console
+        console.step(f"Checking if object exists")
+        if self._object_exists() and not replace:
+            raise ClickException(
+                f"Streamlit {self.model.fqn.sql_identifier} already exists. Use 'replace' option to overwrite."
+            )
+
+        console.step(f"Creating stage {self.model.stage} if not exists")
+        stage = self._create_stage_if_not_exists()
+
+        if (
+            experimental
+            or GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled()
+            or GlobalFeatureFlag.ENABLE_STREAMLIT_EMBEDDED_STAGE.is_enabled()
+        ):
+            self._deploy_experimental(bundle_map=bundle_map, replace=replace)
+        else:
+            console.step(f"Uploading artifacts to stage {self.model.stage}")
+
+            # We use a static method from StageManager here, but maybe this logic could be implemented elswhere, as we implement entities?
+            name = (
+                self.model.identifier.name
+                if isinstance(self.model.identifier, Identifier)
+                else self.model.identifier
+            )
+            stage_root = StageManager.get_standard_stage_prefix(
+                f"{FQN.from_string(self.model.stage).using_connection(self._conn)}/{name}"
+            )
+            if prune:
+                sync_deploy_root_with_stage(
+                    console=self._workspace_ctx.console,
+                    deploy_root=bundle_map.deploy_root(),
+                    bundle_map=bundle_map,
+                    prune=prune,
+                    recursive=True,
+                    stage_path=StageManager().stage_path_parts_from_str(stage_root),
+                    print_diff=True,
+                )
+            else:
+                self._upload_files_to_stage(stage, bundle_map, None)
+
+            console.step(f"Creating Streamlit object {self.model.fqn.sql_identifier}")
+
+            self._execute_query(
+                self.get_deploy_sql(replace=replace, from_stage_name=stage_root)
+            )
+
+        return self.perform(EntityActions.GET_URL, action_context, *args, **kwargs)
+
+    def describe(self) -> SnowflakeCursor:
+        return self._execute_query(self.get_describe_sql())
 
     def action_share(
         self, action_ctx: ActionContext, to_role: str, *args, **kwargs
     ) -> SnowflakeCursor:
         return self._execute_query(self.get_share_sql(to_role))
 
+    def get_add_live_version_sql(
+        self, schema: Optional[str] = None, database: Optional[str] = None
+    ):
+        return f"ALTER STREAMLIT {self._get_identifier(schema,database)} ADD LIVE VERSION FROM LAST;"
+
+    def get_checkout_sql(
+        self, schema: Optional[str] = None, database: Optional[str] = None
+    ):
+        return f"ALTER STREAMLIT {self._get_identifier(schema,database)} CHECKOUT;"
+
     def get_deploy_sql(
         self,
         if_not_exists: bool = False,
@@ -85,21 +166,19 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         from_stage_name: Optional[str] = None,
         artifacts_dir: Optional[Path] = None,
         schema: Optional[str] = None,
+        database: Optional[str] = None,
         *args,
         **kwargs,
-    ):
-        if replace and if_not_exists:
-            raise ClickException("Cannot specify both replace and if_not_exists")
+    ) -> str:
 
         if replace:
-            query = "CREATE OR REPLACE "
+            query = "CREATE OR REPLACE STREAMLIT"
         elif if_not_exists:
-            query = "CREATE IF NOT EXISTS "
+            query = "CREATE STREAMLIT IF NOT EXISTS"
         else:
-            query = "CREATE "
+            query = "CREATE STREAMLIT"
 
-        schema_to_use = schema or self._entity_model.fqn.schema
-        query += f"STREAMLIT {self._entity_model.fqn.set_schema(schema_to_use).sql_identifier}"
+        query += f" {self._get_identifier(schema, database)}"
 
         if from_stage_name:
             query += f"\nROOT_LOCATION = '{from_stage_name}'"
@@ -112,7 +191,12 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             query += "\n" + self.model.get_imports_sql()
 
         if self.model.query_warehouse:
-            query += f"\nQUERY_WAREHOUSE = '{self.model.query_warehouse}'"
+            query += f"\nQUERY_WAREHOUSE = {self.model.query_warehouse}"
+        else:
+            self._workspace_ctx.console.warning(
+                "[Deprecation] In next major version we will remove default query_warehouse='streamlit'."
+            )
+            query += f"\nQUERY_WAREHOUSE = 'streamlit'"
 
         if self.model.title:
             query += f"\nTITLE = '{self.model.title}'"
@@ -128,11 +212,14 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
 
         return query + ";"
 
+    def get_describe_sql(self) -> str:
+        return f"DESCRIBE STREAMLIT {self._get_identifier()};"
+
     def get_share_sql(self, to_role: str) -> str:
-        return f"GRANT USAGE ON STREAMLIT {self.model.fqn.sql_identifier} TO ROLE {to_role};"
+        return f"GRANT USAGE ON STREAMLIT {self._get_identifier()} TO ROLE {to_role};"
 
     def get_execute_sql(self):
-        return f"EXECUTE STREAMLIT {self._entity_model.fqn}();"
+        return f"EXECUTE STREAMLIT {self._get_identifier()}();"
 
     def get_usage_grant_sql(self, app_role: str, schema: Optional[str] = None) -> str:
         entity_id = self.entity_id
@@ -140,3 +227,56 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         return (
             f"GRANT USAGE ON STREAMLIT {streamlit_name} TO APPLICATION ROLE {app_role};"
         )
+
+    def _object_exists(self) -> bool:
+        try:
+            self.describe()
+            return True
+        except ProgrammingError:
+            return False
+
+    def _deploy_experimental(
+        self, bundle_map: BundleMap, replace: bool = False, prune: bool = False
+    ):
+        self._execute_query(
+            self.get_deploy_sql(
+                if_not_exists=True,
+                replace=replace,
+            )
+        )
+        try:
+            if GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled():
+                self._execute_query(self.get_add_live_version_sql())
+            elif not GlobalFeatureFlag.ENABLE_STREAMLIT_NO_CHECKOUTS.is_enabled():
+                self._execute_query(self.get_checkout_sql())
+        except ProgrammingError as e:
+            if "Checkout already exists" in str(
+                e
+            ) or "There is already a live version" in str(e):
+                log.info("Checkout already exists, continuing")
+            else:
+                raise
+
+        embeded_stage_name = (
+            f"snow://streamlit/{self.model.fqn.using_connection(self._conn).identifier}"
+        )
+
+        if GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled():
+            stage_root = f"{embeded_stage_name}/versions/live"
+        else:
+            stage_root = f"{embeded_stage_name}/default_checkout"
+
+        stage_resource = self._create_stage_if_not_exists(embeded_stage_name)
+
+        if prune:
+            sync_deploy_root_with_stage(
+                console=self._workspace_ctx.console,
+                deploy_root=bundle_map.deploy_root(),
+                bundle_map=bundle_map,
+                prune=prune,
+                recursive=True,
+                stage_path=StageManager().stage_path_parts_from_str(stage_root),
+                print_diff=True,
+            )
+        else:
+            self._upload_files_to_stage(stage_resource, bundle_map)

snowflake/cli/api/artifacts/upload.py

@@ -6,6 +6,7 @@ from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.entities.utils import sync_deploy_root_with_stage
 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
 
 
 def sync_artifacts_with_stage(
@@ -17,6 +18,9 @@ def sync_artifacts_with_stage(
     if artifacts is None:
         artifacts = []
 
+    project_paths.remove_up_bundle_root()
+    SecurePath(project_paths.bundle_root).mkdir(parents=True, exist_ok=True)
+
     bundle_map = bundle_artifacts(project_paths, artifacts)
     stage_path_parts = StageManager().stage_path_parts_from_str(stage_root)
     # We treat the bundle root as deploy root
@@ -29,6 +33,7 @@ def sync_artifacts_with_stage(
         stage_path=stage_path_parts,
         print_diff=True,
     )
+    project_paths.clean_up_output()
 
 
 def put_files(

snowflake/cli/api/artifacts/utils.py

@@ -68,8 +68,6 @@ def bundle_artifacts(project_paths: ProjectPaths, artifacts: Artifacts) -> Bundl
     for artifact in artifacts:
         bundle_map.add(artifact)
 
-    project_paths.remove_up_bundle_root()
-    SecurePath(project_paths.bundle_root).mkdir(parents=True, exist_ok=True)
     for absolute_src, absolute_dest in bundle_map.all_mappings(
         absolute=True, expand_directories=True
     ):

snowflake/cli/api/cli_global_context.py

@@ -31,6 +31,7 @@ from snowflake.connector import SnowflakeConnection
 if TYPE_CHECKING:
     from snowflake.cli.api.project.definition_manager import DefinitionManager
     from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
+    from snowflake.core import Root
 
 _CONNECTION_CACHE = OpenConnectionCache()
 
@@ -47,6 +48,7 @@ class _CliGlobalContextManager:
     verbose: bool = False
     experimental: bool = False
     enable_tracebacks: bool = True
+    is_repl: bool = False
 
     metrics: CLIMetrics = field(default_factory=CLIMetrics)
 
@@ -200,9 +202,7 @@ class _CliGlobalContextAccess:
     @property
     def snow_api_root(
         self,
-    ) -> Optional[
-        object
-    ]:  # Should be Optional[Root], but we need local import for performance reasons
+    ) -> Optional[Root]:
         from snowflake.core import Root
 
         if self.connection:
@@ -214,6 +214,10 @@ class _CliGlobalContextAccess:
     def enhanced_exit_codes(self) -> bool:
         return self._manager.enhanced_exit_codes
 
+    @property
+    def is_repl(self) -> bool:
+        return self._manager.is_repl
+
 
 _CLI_CONTEXT_MANAGER: ContextVar[_CliGlobalContextManager | None] = ContextVar(
     "cli_context", default=None

snowflake/cli/api/commands/decorators.py

@@ -23,6 +23,7 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.flags import (
     AccountOption,
     AuthenticatorOption,
+    ClientStoreTemporaryCredentialOption,
     ConnectionOption,
     DatabaseOption,
     DebugOption,
@@ -33,6 +34,15 @@ from snowflake.cli.api.commands.flags import (
     HostOption,
     MasterTokenOption,
     MfaPasscodeOption,
+    OauthAuthorizationUrlOption,
+    OauthClientIdOption,
+    OauthClientSecretOption,
+    OauthDisablePkceOption,
+    OauthEnableRefreshTokensOption,
+    OauthEnableSingleUseRefreshTokensOption,
+    OauthRedirectUriOption,
+    OauthScopeOption,
+    OauthTokenRequestUrlOption,
     OutputFormatOption,
     PasswordOption,
     PortOption,
@@ -329,6 +339,66 @@ GLOBAL_CONNECTION_OPTIONS = [
         annotation=Optional[str],
         default=DiagAllowlistPathOption,
     ),
+    inspect.Parameter(
+        "oauth_client_id",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=OauthClientIdOption,
+    ),
+    inspect.Parameter(
+        "oauth_client_secret",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=OauthClientSecretOption,
+    ),
+    inspect.Parameter(
+        "oauth_authorization_url",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=OauthAuthorizationUrlOption,
+    ),
+    inspect.Parameter(
+        "oauth_token_request_url",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=OauthTokenRequestUrlOption,
+    ),
+    inspect.Parameter(
+        "oauth_redirect_uri",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=OauthRedirectUriOption,
+    ),
+    inspect.Parameter(
+        "oauth_scope",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=OauthScopeOption,
+    ),
+    inspect.Parameter(
+        "oauth_disable_pkce",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[bool],
+        default=OauthDisablePkceOption,
+    ),
+    inspect.Parameter(
+        "oauth_enable_refresh_tokens",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[bool],
+        default=OauthEnableRefreshTokensOption,
+    ),
+    inspect.Parameter(
+        "oauth_enable_single_use_refresh_tokens",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[bool],
+        default=OauthEnableSingleUseRefreshTokensOption,
+    ),
+    inspect.Parameter(
+        "client_store_temporary_credential",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[bool],
+        default=ClientStoreTemporaryCredentialOption,
+    ),
 ]
 
 GLOBAL_OPTIONS = [

snowflake/cli/api/commands/flags.py

@@ -284,6 +284,99 @@ EnableDiagOption = typer.Option(
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+OauthClientIdOption = typer.Option(
+    None,
+    "--oauth-client-id",
+    help="Value of client id provided by the Identity Provider for Snowflake integration.",
+    callback=_connection_callback("oauth_client_id"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthClientSecretOption = typer.Option(
+    None,
+    help="Value of the client secret provided by the Identity Provider for Snowflake integration.",
+    callback=_connection_callback("oauth_client_secret"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthAuthorizationUrlOption = typer.Option(
+    None,
+    "--oauth-authorization-url",
+    help="Identity Provider endpoint supplying the authorization code to the driver.",
+    callback=_connection_callback("oauth_authorization_url"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthTokenRequestUrlOption = typer.Option(
+    None,
+    "--oauth-token-request-url",
+    help="Identity Provider endpoint supplying the access tokens to the driver.",
+    callback=_connection_callback("oauth_token_request_url"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthRedirectUriOption = typer.Option(
+    None,
+    "--oauth-redirect-uri",
+    help="URI to use for authorization code redirection.",
+    callback=_connection_callback("oauth_redirect_uri"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthScopeOption = typer.Option(
+    None,
+    "--oauth-scope",
+    help="Scope requested in the Identity Provider authorization request.",
+    callback=_connection_callback("oauth_scope"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthDisablePkceOption = typer.Option(
+    None,
+    "--oauth-disable-pkce",
+    help="Disables Proof Key for Code Exchange (PKCE). Default: `False`.",
+    callback=_connection_callback("oauth_disable_pkce"),
+    show_default=False,
+    is_flag=True,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthEnableRefreshTokensOption = typer.Option(
+    None,
+    "--oauth-enable-refresh-tokens",
+    help="Enables a silent re-authentication when the actual access token becomes outdated. Default: `False`.",
+    callback=_connection_callback("oauth_enable_refresh_tokens"),
+    show_default=False,
+    is_flag=True,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+OauthEnableSingleUseRefreshTokensOption = typer.Option(
+    None,
+    "--oauth-enable-single-use-refresh-tokens",
+    help="Whether to opt-in to single-use refresh token semantics. Default: `False`.",
+    callback=_connection_callback("oauth_enable_single_use_refresh_tokens"),
+    show_default=False,
+    is_flag=True,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+ClientStoreTemporaryCredentialOption = typer.Option(
+    None,
+    "--client-store-temporary-credential",
+    help="Store the temporary credential.",
+    callback=_connection_callback("client_store_temporary_credential"),
+    is_flag=True,
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
 # Set default via callback to avoid including tempdir path in generated docs (snow --docs).
 # Use constant instead of None, as None is removed from telemetry data.
 _DIAG_LOG_DEFAULT_VALUE = "<system_temporary_directory>"
@@ -382,7 +475,6 @@ EnhancedExitCodesOption = typer.Option(
     envvar="SNOWFLAKE_ENHANCED_EXIT_CODES",
 )
 
-
 # If IfExistsOption, IfNotExistsOption, or ReplaceOption are used with names other than those in CREATE_MODE_OPTION_NAMES,
 # you must also override mutually_exclusive if you want to retain the validation that at most one of these flags is
 # passed.
@@ -425,9 +517,9 @@ NoInteractiveOption = typer.Option(False, "--no-interactive", help="Disable prom
 
 PruneOption = OverrideableOption(
     False,
-    "--prune",
+    "--prune/--no-prune",
     help=f"Delete files that exist in the stage, but not in the local filesystem.",
-    show_default=False,
+    show_default=True,
 )
 
 

snowflake/cli/api/config.py

@@ -83,6 +83,16 @@ class ConnectionConfig:
     authenticator: Optional[str] = None
     private_key_file: Optional[str] = None
     token_file_path: Optional[str] = None
+    oauth_client_id: Optional[str] = None
+    oauth_client_secret: Optional[str] = None
+    oauth_authorization_url: Optional[str] = None
+    oauth_token_request_url: Optional[str] = None
+    oauth_redirect_uri: Optional[str] = None
+    oauth_scope: Optional[str] = None
+    oatuh_enable_pkce: Optional[bool] = None
+    oauth_enable_refresh_tokens: Optional[bool] = None
+    oauth_enable_single_use_refresh_tokens: Optional[bool] = None
+    client_store_temporary_credential: Optional[bool] = None
 
     _other_settings: dict = field(default_factory=lambda: {})
 

snowflake/cli/api/connections.py

@@ -55,6 +55,16 @@ class ConnectionContext:
     session_token: Optional[str] = None
     master_token: Optional[str] = None
     token_file_path: Optional[Path] = None
+    oauth_client_id: Optional[str] = None
+    oauth_client_secret: Optional[str] = None
+    oauth_authorization_url: Optional[str] = None
+    oauth_token_request_url: Optional[str] = None
+    oauth_redirect_uri: Optional[str] = None
+    oauth_scope: Optional[str] = None
+    oauth_disable_pkce: Optional[bool] = None
+    oauth_enable_refresh_tokens: Optional[bool] = None
+    oauth_enable_single_use_refresh_tokens: Optional[bool] = None
+    client_store_temporary_credential: Optional[bool] = None
 
     VALIDATED_FIELD_NAMES = ["schema"]
 

snowflake/cli/api/console/abc.py

@@ -19,7 +19,7 @@ from contextlib import contextmanager
 from typing import Callable, Iterator, Optional
 
 from rich import print as rich_print
-from rich.text import Text
+from rich.jupyter import JupyterMixin
 from snowflake.cli.api.cli_global_context import (
     _CliGlobalContextAccess,
     get_cli_context,
@@ -57,7 +57,7 @@ class AbstractConsole(ABC):
         """Indicated whether output should be grouped."""
         return self._in_phase
 
-    def _print(self, text: Text):
+    def _print(self, text: JupyterMixin):
         if self.is_silent:
             return
         rich_print(text)
@@ -92,3 +92,9 @@ class AbstractConsole(ABC):
         """Displays message in a style that makes it visually stand out from other output.
 
         Intended for displaying messages related to important messages."""
+
+    @abstractmethod
+    def panel(self, message: str):
+        """Displays message in a panel that makes it visually stand out from other output.
+
+        Intended for displaying visually separated messages."""

snowflake/cli/api/console/console.py

@@ -17,14 +17,23 @@ from __future__ import annotations
 from contextlib import contextmanager
 from typing import Optional
 
+from rich import get_console
+from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
 from snowflake.cli.api.console.abc import AbstractConsole
 from snowflake.cli.api.console.enum import Output
 
+# ensure we do not break URLs that wrap lines
+get_console().soft_wrap = True
+
+# Disable markup to avoid escaping errors
+get_console()._markup = False  # noqa: SLF001
+
 PHASE_STYLE: Style = Style(bold=True)
 STEP_STYLE: Style = Style(italic=True)
 INFO_STYLE: Style = Style()
+PANEL_STYLE: Style = Style()
 IMPORTANT_STYLE: Style = Style(bold=True, italic=True)
 INDENTATION_LEVEL: int = 2
 
@@ -47,6 +56,7 @@ class CliConsole(AbstractConsole):
         Output.STEP: STEP_STYLE,
         Output.INFO: None,
         Output.IMPORTANT: IMPORTANT_STYLE,
+        Output.PANEL: PANEL_STYLE,
     }
 
     def _format_message(self, message: str, output: Output) -> Text:
@@ -110,6 +120,12 @@ class CliConsole(AbstractConsole):
         text = self._format_message(message, Output.IMPORTANT)
         self._print(text)
 
+    def panel(self, message: str):
+        """Displays a message in a panel."""
+        style = self._styles.get(Output.PANEL, Style())
+        panel = Panel(message, style=style)
+        self._print(panel)
+
 
 def get_cli_console() -> AbstractConsole:
     console = CliConsole()

snowflake/cli/api/console/enum.py

@@ -14,4 +14,4 @@
 
 from enum import Enum
 
-Output = Enum("Output", ("PHASE", "STEP", "INFO", "IMPORTANT"))
+Output = Enum("Output", ("PHASE", "STEP", "INFO", "IMPORTANT", "PANEL"))