snowflake-cli-labs 2.8.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

snowflake/cli/{plugins → _plugins}/sql/commands.py

@@ -17,43 +17,46 @@ from __future__ import annotations
 from pathlib import Path
 from typing import List, Optional
 
-import typer
+from snowflake.cli._plugins.sql.manager import SqlManager
 from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
-    parse_key_value_variables,
     variables_option,
 )
+from snowflake.cli.api.commands.overrideable_parameter import OverrideableOption
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.output.types import CommandResult, MultipleResults, QueryResult
-from snowflake.cli.plugins.sql.manager import SqlManager
 
 # simple Typer with defaults because it won't become a command group as it contains only one command
 app = SnowTyperFactory()
 
+SOURCE_EXCLUSIVE_OPTIONS_NAMES = ["query", "files", "std_in"]
+
+SourceOption = OverrideableOption(
+    mutually_exclusive=SOURCE_EXCLUSIVE_OPTIONS_NAMES, show_default=False
+)
+
 
 @app.command(name="sql", requires_connection=True, no_args_is_help=True)
 @with_project_definition(is_optional=True)
 def execute_sql(
-    query: Optional[str] = typer.Option(
-        None,
-        "--query",
-        "-q",
+    query: Optional[str] = SourceOption(
+        default=None,
+        param_decls=["--query", "-q"],
         help="Query to execute.",
     ),
-    files: Optional[List[Path]] = typer.Option(
-        None,
-        "--filename",
-        "-f",
+    files: Optional[List[Path]] = SourceOption(
+        default=[],
+        param_decls=["--filename", "-f"],
         exists=True,
         file_okay=True,
         dir_okay=False,
         readable=True,
         help="File to execute.",
     ),
-    std_in: Optional[bool] = typer.Option(
-        False,
-        "--stdin",
-        "-i",
+    std_in: Optional[bool] = SourceOption(
+        default=False,
+        param_decls=["--stdin", "-i"],
         help="Read the query from standard input. Use it when piping input to this command.",
     ),
     data_override: List[str] = variables_option(
@@ -70,9 +73,9 @@ def execute_sql(
     Query to execute can be specified using query option, filename option (all queries from file will be executed)
     or via stdin by piping output from other command. For example `cat my.sql | snow sql -i`.
 
-    The command supports variable substitution that happens on client-side. Both &VARIABLE or &{ VARIABLE }
-    syntax are supported.
+    The command supports variable substitution that happens on client-side.
     """
+
     data = {}
     if data_override:
         data = {v.key: v.value for v in parse_key_value_variables(data_override)}

snowflake/cli/{plugins → _plugins}/sql/manager.py

@@ -22,10 +22,10 @@ from typing import Dict, Iterable, List, Tuple
 
 from click import ClickException, UsageError
 from jinja2 import UndefinedError
+from snowflake.cli._plugins.sql.snowsql_templating import transpile_snowsql_templates
 from snowflake.cli.api.rendering.sql_templates import snowflake_sql_jinja_render
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin, VerboseCursor
-from snowflake.cli.plugins.sql.snowsql_templating import transpile_snowsql_templates
 from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.util_text import split_statements
 

snowflake/cli/{plugins → _plugins}/sql/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.sql import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.sql import commands
 
 
 @plugin_hook_impl

snowflake/cli/{plugins → _plugins}/stage/commands.py

@@ -21,12 +21,23 @@ from typing import List, Optional
 
 import click
 import typer
-from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli._plugins.object.command_aliases import (
+    add_object_command_aliases,
+    scope_option,
+)
+from snowflake.cli._plugins.stage.diff import (
+    DiffResult,
+    compute_stage_diff,
+)
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli._plugins.stage.utils import print_diff_to_console
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.commands.common import OnErrorType
 from snowflake.cli.api.commands.flags import (
     ExecuteVariablesOption,
     OnErrorOption,
     PatternOption,
-    identifier_argument,
+    identifier_stage_argument,
     like_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
@@ -42,23 +53,13 @@ from snowflake.cli.api.output.types import (
     SingleQueryResult,
 )
 from snowflake.cli.api.utils.path_utils import is_stage_path
-from snowflake.cli.plugins.object.command_aliases import (
-    add_object_command_aliases,
-    scope_option,
-)
-from snowflake.cli.plugins.stage.diff import (
-    DiffResult,
-    compute_stage_diff,
-    print_diff_to_console,
-)
-from snowflake.cli.plugins.stage.manager import OnErrorType, StageManager
 
 app = SnowTyperFactory(
     name="stage",
     help="Manages stages.",
 )
 
-StageNameArgument = identifier_argument(sf_object="stage", example="@my_stage")
+StageNameArgument = identifier_stage_argument(sf_object="stage", example="@my_stage")
 
 add_object_command_aliases(
     app=app,
@@ -188,7 +189,7 @@ def stage_diff(
     diff: DiffResult = compute_stage_diff(
         local_root=Path(folder_name), stage_fqn=stage_name
     )
-    if cli_context.output_format == OutputFormat.JSON:
+    if get_cli_context().output_format == OutputFormat.JSON:
         return ObjectResult(diff.to_dict())
     else:
         print_diff_to_console(diff)

snowflake/cli/{plugins → _plugins}/stage/diff.py

@@ -19,11 +19,10 @@ from dataclasses import dataclass, field
 from pathlib import Path, PurePosixPath
 from typing import Collection, Dict, List, Optional, Tuple
 
-from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli.api.exceptions import (
     SnowflakeSQLExecutionError,
 )
-from snowflake.cli.plugins.nativeapp.artifacts import BundleMap
 from snowflake.connector.cursor import DictCursor
 
 from .manager import StageManager
@@ -279,48 +278,3 @@ def _to_diff_line(status: str, src: Optional[str], dest: str) -> str:
     status_prefix = f"[red]{status}[/red]: {padding}"
 
     return f"{status_prefix}{src_prefix}{dest}"
-
-
-def print_diff_to_console(
-    diff: DiffResult,
-    bundle_map: Optional[BundleMap] = None,
-):
-    if not diff.has_changes():
-        cc.message("Your stage is up-to-date with your local deploy root.")
-        return
-
-    blank_line_needed = False
-    if diff.only_local or diff.different:
-        cc.message("Local changes to be deployed:")
-        messages_to_output = []
-        for p in diff.different:
-            src_dest_pair = _to_src_dest_pair(p, bundle_map)
-            messages_to_output.append(
-                (
-                    src_dest_pair,
-                    _to_diff_line("modified", src_dest_pair[0], src_dest_pair[1]),
-                )
-            )
-        for p in diff.only_local:
-            src_dest_pair = _to_src_dest_pair(p, bundle_map)
-            messages_to_output.append(
-                (
-                    src_dest_pair,
-                    _to_diff_line("added", src_dest_pair[0], src_dest_pair[1]),
-                )
-            )
-
-        with cc.indented():
-            for key, message in sorted(messages_to_output, key=lambda pair: pair[0]):
-                cc.message(message)
-
-        blank_line_needed = True
-
-    if diff.only_on_stage:
-        if blank_line_needed:
-            cc.message("")
-        cc.message(f"Deleted paths to be removed from your stage:")
-        with cc.indented():
-            for p in sorted(diff.only_on_stage):
-                diff_line = _to_diff_line("deleted", src=None, dest=str(p))
-                cc.message(diff_line)

snowflake/cli/{plugins → _plugins}/stage/manager.py

@@ -27,11 +27,12 @@ from textwrap import dedent
 from typing import Dict, List, Optional, Union
 
 from click import ClickException
-from snowflake.cli.api.commands.flags import (
+from snowflake.cli._plugins.snowpark.package_utils import parse_requirements
+from snowflake.cli.api.commands.common import (
     OnErrorType,
     Variable,
-    parse_key_value_variables,
 )
+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
@@ -39,7 +40,6 @@ from snowflake.cli.api.project.util import to_string_literal
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.utils.path_utils import path_resolver
-from snowflake.cli.plugins.snowpark.package_utils import parse_requirements
 from snowflake.connector import DictCursor, ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
 
@@ -57,6 +57,9 @@ EXECUTE_SUPPORTED_FILES_FORMATS = (
     ".py",
 )  # tuple to preserve order but it's a set
 
+# Replace magic numbers with constants
+OMIT_FIRST = slice(1, None)
+
 
 @dataclass
 class StagePathParts:
@@ -67,7 +70,7 @@ class StagePathParts:
 
     @classmethod
     def get_directory(cls, stage_path: str) -> str:
-        return "/".join(Path(stage_path).parts[1:])
+        return "/".join(Path(stage_path).parts[OMIT_FIRST])
 
     @property
     def path(self) -> str:
@@ -119,7 +122,9 @@ class DefaultStagePathParts(StagePathParts):
         self.directory = self.get_directory(stage_path)
         self.stage = StageManager.get_stage_from_path(stage_path)
         stage_name = self.stage.split(".")[-1]
-        stage_name = stage_name[1:] if stage_name.startswith("@") else stage_name
+        stage_name = (
+            stage_name[OMIT_FIRST] if stage_name.startswith("@") else stage_name
+        )
         self.stage_name = stage_name
         self.is_directory = True if stage_path.endswith("/") else False
 
@@ -133,7 +138,7 @@ class DefaultStagePathParts(StagePathParts):
 
     def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
-        file_path_without_prefix = Path(file_path).parts[1:]
+        file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
     def add_stage_prefix(self, file_path: str) -> str:
@@ -461,7 +466,7 @@ class StageManager(SqlExecutionMixin):
         on_error: OnErrorType,
     ) -> Dict:
         try:
-            query = f"execute immediate from {file_stage_path}"
+            query = f"execute immediate from {self.quote_stage_name(file_stage_path)}"
             if variables:
                 query += variables
             self._execute_query(query)

snowflake/cli/{plugins → _plugins}/stage/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.stage import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.stage import commands
 
 
 @plugin_hook_impl

snowflake/cli/_plugins/stage/utils.py

@@ -0,0 +1,54 @@
+from typing import Optional
+
+from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
+from snowflake.cli._plugins.stage.diff import (
+    DiffResult,
+    _to_diff_line,
+    _to_src_dest_pair,
+)
+from snowflake.cli.api.console import cli_console as cc
+
+
+def print_diff_to_console(
+    diff: DiffResult,
+    bundle_map: Optional[BundleMap] = None,
+):
+    if not diff.has_changes():
+        cc.message("Your stage is up-to-date with your local deploy root.")
+        return
+
+    blank_line_needed = False
+    if diff.only_local or diff.different:
+        cc.message("Local changes to be deployed:")
+        messages_to_output = []
+        for p in diff.different:
+            src_dest_pair = _to_src_dest_pair(p, bundle_map)
+            messages_to_output.append(
+                (
+                    src_dest_pair,
+                    _to_diff_line("modified", src_dest_pair[0], src_dest_pair[1]),
+                )
+            )
+        for p in diff.only_local:
+            src_dest_pair = _to_src_dest_pair(p, bundle_map)
+            messages_to_output.append(
+                (
+                    src_dest_pair,
+                    _to_diff_line("added", src_dest_pair[0], src_dest_pair[1]),
+                )
+            )
+
+        with cc.indented():
+            for key, message in sorted(messages_to_output, key=lambda pair: pair[0]):
+                cc.message(message)
+
+        blank_line_needed = True
+
+    if diff.only_on_stage:
+        if blank_line_needed:
+            cc.message("")
+        cc.message(f"Deleted paths to be removed from your stage:")
+        with cc.indented():
+            for p in sorted(diff.only_on_stage):
+                diff_line = _to_diff_line("deleted", src=None, dest=str(p))
+                cc.message(diff_line)

snowflake/cli/{plugins → _plugins}/streamlit/commands.py

@@ -16,36 +16,42 @@ from __future__ import annotations
 
 import logging
 from pathlib import Path
+from typing import Dict
 
 import click
 import typer
-from click import ClickException
-from snowflake.cli.api.cli_global_context import cli_context
+from click import ClickException, UsageError
+from snowflake.cli._plugins.object.command_aliases import (
+    add_object_command_aliases,
+    scope_option,
+)
+from snowflake.cli._plugins.streamlit.manager import StreamlitManager
+from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
+    StreamlitEntityModel,
+)
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.decorators import (
     with_experimental_behaviour,
     with_project_definition,
 )
 from snowflake.cli.api.commands.flags import (
     ReplaceOption,
+    entity_argument,
     identifier_argument,
     like_option,
 )
-from snowflake.cli.api.commands.project_initialisation import add_init_command
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.exceptions import NoProjectDefinitionError
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
     CommandResult,
     MessageResult,
     SingleQueryResult,
 )
-from snowflake.cli.api.project.project_verification import assert_project_type
-from snowflake.cli.api.project.schemas.streamlit.streamlit import Streamlit
-from snowflake.cli.plugins.object.command_aliases import (
-    add_object_command_aliases,
-    scope_option,
+from snowflake.cli.api.project.definition_conversion import (
+    convert_project_definition_to_v2,
 )
-from snowflake.cli.plugins.streamlit.manager import StreamlitManager
 
 app = SnowTyperFactory(
     name="streamlit",
@@ -63,12 +69,6 @@ OpenOption = typer.Option(
     is_flag=True,
 )
 
-add_init_command(
-    app,
-    project_type="Streamlit",
-    template="default_streamlit",
-    help_message="Name of the Streamlit app project directory you want to create. Defaults to `example_streamlit`.",
-)
 
 add_object_command_aliases(
     app=app,
@@ -81,11 +81,25 @@ add_object_command_aliases(
 )
 
 
+@app.command(requires_connection=True)
+def execute(
+    name: FQN = StreamlitNameArgument,
+    **options,
+):
+    """
+    Executes a streamlit in a headless mode.
+    """
+    _ = StreamlitManager().execute(app_name=name)
+    return MessageResult(f"Streamlit {name} executed.")
+
+
 @app.command("share", requires_connection=True)
 def streamlit_share(
     name: FQN = StreamlitNameArgument,
     to_role: str = typer.Argument(
-        ..., help="Role with which to share the Streamlit app."
+        ...,
+        help="Role with which to share the Streamlit app.",
+        show_default=False,
     ),
     **options,
 ) -> CommandResult:
@@ -118,48 +132,50 @@ def streamlit_deploy(
     replace: bool = ReplaceOption(
         help="Replace the Streamlit app if it already exists."
     ),
+    entity_id: str = entity_argument("streamlit"),
     open_: bool = OpenOption,
     **options,
 ) -> CommandResult:
     """
     Deploys a Streamlit app defined in the project definition file (snowflake.yml). By default, the command uploads
     environment.yml and any other pages or folders, if present. If you don’t specify a stage name, the `streamlit`
-    stage is used. If the specified stage does not exist, the command creates it.
+    stage is used. If the specified stage does not exist, the command creates it. If multiple Streamlits are defined
+    in snowflake.yml and no entity_id is provided then command will raise an error.
     """
 
-    assert_project_type("streamlit")
-
-    streamlit: Streamlit = cli_context.project_definition.streamlit
-    if not streamlit:
-        return MessageResult("No streamlit were specified in project definition.")
-
-    environment_file = streamlit.env_file
-    if environment_file and not Path(environment_file).exists():
-        raise ClickException(f"Provided file {environment_file} does not exist")
-    elif environment_file is None:
-        environment_file = "environment.yml"
-
-    pages_dir = streamlit.pages_dir
-    if pages_dir and not Path(pages_dir).exists():
-        raise ClickException(f"Provided file {pages_dir} does not exist")
-    elif pages_dir is None:
-        pages_dir = "pages"
-
-    streamlit_id = FQN.from_identifier_model(streamlit).using_context()
-
-    url = StreamlitManager().deploy(
-        streamlit_id=streamlit_id,
-        environment_file=Path(environment_file),
-        pages_dir=Path(pages_dir),
-        stage_name=streamlit.stage,
-        main_file=Path(streamlit.main_file),
-        replace=replace,
-        query_warehouse=streamlit.query_warehouse,
-        additional_source_files=streamlit.additional_source_files,
-        title=streamlit.title,
-        **options,
+    cli_context = get_cli_context()
+    pd = cli_context.project_definition
+    if not pd.meets_version_requirement("2"):
+        if not pd.streamlit:
+            raise NoProjectDefinitionError(
+                project_type="streamlit", project_root=cli_context.project_root
+            )
+        pd = convert_project_definition_to_v2(cli_context.project_root, pd)
+
+    streamlits: Dict[str, StreamlitEntityModel] = pd.get_entities_by_type(
+        entity_type="streamlit"
     )
 
+    if not streamlits:
+        raise NoProjectDefinitionError(
+            project_type="streamlit", project_root=cli_context.project_root
+        )
+
+    if entity_id and entity_id not in streamlits:
+        raise UsageError(f"No '{entity_id}' entity in project definition file.")
+
+    if len(streamlits.keys()) == 1:
+        entity_id = list(streamlits.keys())[0]
+
+    if entity_id is None:
+        raise UsageError(
+            "Multiple Streamlit apps found. Please provide entity id for the operation."
+        )
+
+    # Get first streamlit
+    streamlit: StreamlitEntityModel = streamlits[entity_id]
+    url = StreamlitManager().deploy(streamlit=streamlit, replace=replace)
+
     if open_:
         typer.launch(url)