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

snowflake/cli/_plugins/logs/manager.py

@@ -11,6 +11,7 @@ from snowflake.cli._plugins.logs.utils import (
 )
 from snowflake.cli._plugins.object.commands import NameArgument, ObjectArgument
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.util import escape_like_pattern
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
 
@@ -24,6 +25,7 @@ class LogsManager(SqlExecutionMixin):
         from_time: Optional[datetime] = None,
         event_table: Optional[str] = None,
         log_level: Optional[str] = "INFO",
+        partial_match: bool = False,
     ) -> Iterable[List[LogsQueryRow]]:
         try:
             previous_end = from_time
@@ -36,6 +38,7 @@ class LogsManager(SqlExecutionMixin):
                     to_time=None,
                     event_table=event_table,
                     log_level=log_level,
+                    partial_match=partial_match,
                 ).fetchall()
 
                 if raw_logs:
@@ -56,6 +59,7 @@ class LogsManager(SqlExecutionMixin):
         to_time: Optional[datetime] = None,
         event_table: Optional[str] = None,
         log_level: Optional[str] = "INFO",
+        partial_match: bool = False,
     ) -> Iterable[LogsQueryRow]:
         """
         Basic function to get a single batch of logs from the server
@@ -68,6 +72,7 @@ class LogsManager(SqlExecutionMixin):
             to_time=to_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
 
         return sanitize_logs(logs)
@@ -80,10 +85,25 @@ class LogsManager(SqlExecutionMixin):
         to_time: Optional[datetime] = None,
         event_table: Optional[str] = None,
         log_level: Optional[str] = "INFO",
+        partial_match: bool = False,
     ) -> SnowflakeCursor:
 
         table = event_table if event_table else "SNOWFLAKE.TELEMETRY.EVENTS"
 
+        # Escape single quotes in object_name to prevent SQL injection
+        escaped_object_name = str(object_name).replace("'", "''")
+
+        # Build the object name condition based on partial_match flag
+        if partial_match:
+            # Use ILIKE for case-insensitive partial matching with wildcards
+            escaped_pattern = escape_like_pattern(
+                escaped_object_name, escape_sequence="\\"
+            )
+            object_condition = f"object_name ILIKE '%{escaped_pattern}%'"
+        else:
+            # Use exact match (original behavior)
+            object_condition = f"object_name = '{escaped_object_name}'"
+
         query = dedent(
             f"""
             SELECT
@@ -96,7 +116,7 @@ class LogsManager(SqlExecutionMixin):
             FROM {table}
             WHERE record_type = 'LOG'
             AND (record:severity_text IN ({parse_log_levels_for_query((log_level))}) or record:severity_text is NULL )
-            AND object_name = '{object_name}'
+            AND {object_condition}
             {get_timestamp_query(from_time, to_time)}
             ORDER BY timestamp;
 """

snowflake/cli/_plugins/nativeapp/sf_sql_facade.py

@@ -632,6 +632,7 @@ class SnowflakeSQLFacade:
         role: str | None = None,
         database: str | None = None,
         schema: str | None = None,
+        temporary: bool = False,
     ):
         """
         Creates a stage.
@@ -641,13 +642,14 @@ class SnowflakeSQLFacade:
         @param [Optional] role: Role to switch to while running this script. Current role will be used if no role is passed in.
         @param [Optional] database: Database to use while running this script, unless the stage name is database-qualified.
         @param [Optional] schema: Schema to use while running this script, unless the stage name is schema-qualified.
+        @param [Optional] temporary: determines if stage should be temporary. Default is false.
         """
         fqn = FQN.from_string(name)
         identifier = to_identifier(fqn.name)
         database = fqn.database or database
         schema = fqn.schema or schema
 
-        query = f"create stage if not exists {identifier}"
+        query = f"create{' temporary' if temporary else ''} stage if not exists {identifier}"
         if encryption_type:
             query += f" encryption = (type = '{encryption_type}')"
         if enable_directory:

snowflake/cli/_plugins/notebook/notebook_entity.py

@@ -60,6 +60,8 @@ class NotebookEntity(EntityBase[NotebookEntityModel]):
             query += f"\nCOMPUTE_POOL = '{self.model.compute_pool}'"
         if self.model.runtime_name:
             query += f"\nRUNTIME_NAME = '{self.model.runtime_name}'"
+        if self.model.runtime_environment_version and not self.model.compute_pool:
+            query += f"\nRUNTIME_ENVIRONMENT_VERSION = '{self.model.runtime_environment_version}'"
 
         query += (
             ";\n// Cannot use IDENTIFIER(...)"

snowflake/cli/_plugins/notebook/notebook_entity_model.py

@@ -20,6 +20,9 @@ class NotebookEntityModel(EntityModelBaseWithArtifacts):
     )
     notebook_file: Path = Field(title="Notebook file")
     query_warehouse: str = Field(title="Snowflake warehouse to execute the notebook")
+    runtime_environment_version: Optional[str] = Field(
+        title="Runtime environment version", default=None
+    )
     compute_pool: Optional[str] = Field(
         title="Compute pool to run the notebook in", default=None
     )
@@ -37,6 +40,10 @@ class NotebookEntityModel(EntityModelBaseWithArtifacts):
     def validate_container_setup(self):
         if self.compute_pool and not self.runtime_name:
             raise ValueError("compute_pool is specified without runtime_name")
-        if self.runtime_name and not self.compute_pool and not self:
+        if self.runtime_name and not self.compute_pool:
             raise ValueError("runtime_name is specified without compute_pool")
+        if self.compute_pool and self.runtime_environment_version:
+            raise ValueError(
+                "runtime_environment_version is only applicable for notebooks using warehouse, not compute pool"
+            )
         return self

snowflake/cli/_plugins/object/command_aliases.py

@@ -22,8 +22,10 @@ from snowflake.cli._plugins.object.commands import (
     ScopeOption,
     describe,
     drop,
+    limit_option_,
     list_,
     scope_option,  # noqa: F401
+    terse_option_,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
@@ -37,6 +39,8 @@ def add_object_command_aliases(
     like_option: Optional[typer.Option],
     scope_option: Optional[typer.Option],
     ommit_commands: Optional[List[str]] = None,
+    terse_option: Optional[typer.Option] = None,
+    limit_option: Optional[typer.Option] = None,
 ):
     if ommit_commands is None:
         ommit_commands = list()
@@ -47,11 +51,18 @@ def add_object_command_aliases(
         if not scope_option:
 
             @app.command("list", requires_connection=True)
-            def list_cmd(like: str = like_option, **options):  # type: ignore
+            def list_cmd(
+                like: str = like_option,  # type: ignore
+                terse: bool = terse_option if terse_option else terse_option_(),  # type: ignore
+                limit: Optional[int] = limit_option if limit_option else limit_option_(),  # type: ignore
+                **options,
+            ):
                 return list_(
                     object_type=object_type.value.cli_name,
                     like=like,
                     scope=ScopeOption.default,
+                    terse=terse,
+                    limit=limit,
                     **options,
                 )
 
@@ -61,12 +72,16 @@ def add_object_command_aliases(
             def list_cmd(
                 like: str = like_option,  # type: ignore
                 scope: Tuple[str, str] = scope_option,  # type: ignore
+                terse: bool = terse_option if terse_option else terse_option_(),  # type: ignore
+                limit: Optional[int] = limit_option if limit_option else limit_option_(),  # type: ignore
                 **options,
             ):
                 return list_(
                     object_type=object_type.value.cli_name,
                     like=like,
                     scope=scope,
+                    terse=terse,
+                    limit=limit,
                     **options,
                 )
 

snowflake/cli/_plugins/object/commands.py

@@ -94,6 +94,24 @@ def scope_option(help_example: str):
     )
 
 
+def terse_option_():
+    return typer.Option(
+        None,
+        "--terse",
+        help=f"Returns only a subset of available columns.",
+        hidden=True,
+    )
+
+
+def limit_option_():
+    return typer.Option(
+        None,
+        "--limit",
+        help=f"Limits the maximum number of rows returned.",
+        hidden=True,
+    )
+
+
 ScopeOption = scope_option(
     help_example="`list table --in database my_db`. Some object types have specialized scopes (e.g. list service --in compute-pool my_pool)"
 )
@@ -110,11 +128,19 @@ def list_(
     object_type: str = ObjectArgument,
     like: str = LikeOption,
     scope: Tuple[str, str] = ScopeOption,
+    terse: Optional[bool] = terse_option_(),
+    limit: Optional[int] = limit_option_(),
     **options,
 ):
     _scope_validate(object_type, scope)
     return QueryResult(
-        ObjectManager().show(object_type=object_type, like=like, scope=scope)
+        ObjectManager().show(
+            object_type=object_type,
+            like=like,
+            scope=scope,
+            terse=terse,
+            limit=limit,
+        )
     )
 
 

snowflake/cli/_plugins/object/manager.py

@@ -44,14 +44,25 @@ class ObjectManager(SqlExecutionMixin):
         object_type: str,
         like: Optional[str] = None,
         scope: Union[Tuple[str, str], Tuple[None, None]] = (None, None),
+        terse: Optional[bool] = False,
+        limit: Optional[int] = None,
         **kwargs,
     ) -> SnowflakeCursor:
         object_name = _get_object_names(object_type).sf_plural_name
-        query = f"show {object_name}"
+        query_parts = ["show"]
+
+        if terse:
+            query_parts.append("terse")
+
+        query_parts.append(object_name)
+        query = " ".join(query_parts)
+
         if like:
             query += f" like '{like}'"
         if scope[0] is not None:
             query += f" in {scope[0].replace('-', ' ')} {scope[1]}"
+        if limit is not None:
+            query += f" limit {limit}"
         return self.execute_query(query, **kwargs)
 
     def drop(self, *, object_type: str, fqn: FQN) -> SnowflakeCursor:

snowflake/cli/_plugins/snowpark/commands.py

@@ -448,7 +448,14 @@ def list_(
     **options,
 ):
     """Lists all available procedures or functions."""
-    return object_list(object_type=object_type.value, like=like, scope=scope, **options)
+    return object_list(
+        object_type=object_type.value,
+        like=like,
+        scope=scope,
+        terse=None,
+        limit=None,
+        **options,
+    )
 
 
 @app.command("drop", requires_connection=True)

snowflake/cli/_plugins/snowpark/common.py

@@ -349,6 +349,7 @@ def user_to_sql_type_mapper(user_provided_type: str) -> str:
             "FLOAT4",
             "FLOAT8",
         ),
+        ("DECFLOAT", ""): ("DECFLOAT",),
         ("TIMESTAMP_NTZ", ""): ("TIMESTAMP_NTZ", "TIMESTAMPNTZ", "DATETIME"),
         ("TIMESTAMP_LTZ", ""): ("TIMESTAMP_LTZ", "TIMESTAMPLTZ"),
         ("TIMESTAMP_TZ", ""): ("TIMESTAMP_TZ", "TIMESTAMPTZ"),

snowflake/cli/_plugins/snowpark/package/anaconda_packages.py

@@ -153,13 +153,37 @@ class AnacondaPackages:
     ):
         """Saves requirements to a file in format accepted by Snowflake SQL commands."""
         log.info("Writing requirements into file %s", file_path.path)
-        formatted_requirements = []
+
+        # Deduplicate requirements by package name, keeping the first occurrence
+        seen_packages = set()
+        deduplicated_requirements = []
+        duplicate_packages = set()
+
         for requirement in requirements:
             if requirement.name and requirement.name in self._packages:
-                snowflake_name = self._packages[requirement.name].snowflake_name
-                formatted_requirements.append(
-                    snowflake_name + requirement.formatted_specs
-                )
+                if requirement.name in seen_packages:
+                    duplicate_packages.add(requirement.name)
+                    log.warning(
+                        "Duplicate package '%s' found in Anaconda requirements. "
+                        "Ignoring: %s",
+                        requirement.name,
+                        requirement.name_and_version,
+                    )
+                else:
+                    seen_packages.add(requirement.name)
+                    deduplicated_requirements.append(requirement)
+
+        if duplicate_packages:
+            log.warning(
+                "Found duplicate Anaconda packages: %s. "
+                "Consider consolidating package versions in requirements.txt.",
+                ", ".join(sorted(duplicate_packages)),
+            )
+
+        formatted_requirements = []
+        for requirement in deduplicated_requirements:
+            snowflake_name = self._packages[requirement.name].snowflake_name
+            formatted_requirements.append(snowflake_name + requirement.formatted_specs)
 
         if formatted_requirements:
             file_path.write_text("\n".join(formatted_requirements))

snowflake/cli/_plugins/snowpark/package_utils.py

@@ -255,14 +255,55 @@ def split_downloaded_dependencies(
     anaconda_packages: AnacondaPackages,
     skip_version_check: bool,
 ) -> SplitDownloadedDependenciesResult:
-    packages_metadata: Dict[str, WheelMetadata] = {
-        meta.name: meta
+    # Build metadata for all downloaded wheels
+    all_wheels_metadata = [
+        meta
         for meta in (
             WheelMetadata.from_wheel(wheel_path)
             for wheel_path in downloads_dir.glob("*.whl")
         )
         if meta is not None
-    }
+    ]
+
+    # Detect and handle duplicate packages
+    packages_metadata: Dict[str, WheelMetadata] = {}
+    duplicate_packages = set()
+
+    for meta in all_wheels_metadata:
+        if meta.name in packages_metadata:
+            duplicate_packages.add(meta.name)
+            log.warning(
+                "Multiple versions of package '%s' found in dependencies. "
+                "Using: %s, Ignoring: %s",
+                meta.name,
+                packages_metadata[meta.name].wheel_path.name,
+                meta.wheel_path.name,
+            )
+        else:
+            packages_metadata[meta.name] = meta
+
+    if duplicate_packages:
+        log.warning(
+            "Found duplicate packages: %s. This may cause deployment issues. "
+            "Consider pinning package versions in requirements.txt to avoid conflicts.",
+            ", ".join(sorted(duplicate_packages)),
+        )
+
+        # Remove duplicate wheel files to prevent them from being extracted
+        for meta in all_wheels_metadata:
+            if (
+                meta.name in duplicate_packages
+                and meta not in packages_metadata.values()
+            ):
+                try:
+                    meta.wheel_path.unlink()
+                    log.debug("Removed duplicate wheel file: %s", meta.wheel_path.name)
+                except Exception as e:
+                    log.warning(
+                        "Failed to remove duplicate wheel file %s: %s",
+                        meta.wheel_path.name,
+                        e,
+                    )
     available_in_snowflake_dependencies: Dict = {}
     unavailable_dependencies: Dict = {}
 

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

@@ -313,11 +313,12 @@ class ServiceManager(SqlExecutionMixin):
 
                 if new_log_records:
                     dedup_log_records = new_logs_only(prev_log_records, new_log_records)
-                    for log in dedup_log_records:
-                        yield filter_log_timestamp(log, include_timestamps)
+                    if dedup_log_records:
+                        for log in dedup_log_records:
+                            yield filter_log_timestamp(log, include_timestamps)
 
-                    prev_timestamp = dedup_log_records[-1].split(" ", 1)[0]
-                    prev_log_records = dedup_log_records
+                        prev_timestamp = dedup_log_records[-1].split(" ", 1)[0]
+                        prev_log_records = dedup_log_records
 
                 time.sleep(interval_seconds)
 

snowflake/cli/_plugins/sql/lexer/types.py

@@ -11,6 +11,7 @@ TYPES = (
     "DATETIME",
     "DEC",
     "DECIMAL",
+    "DECFLOAT",
     "DOUBLE",
     "FLOAT",
     "INT",

snowflake/cli/_plugins/sql/repl.py

@@ -1,3 +1,4 @@
+from contextlib import contextmanager
 from logging import getLogger
 from typing import Iterable
 
@@ -10,6 +11,7 @@ from prompt_toolkit.lexers import PygmentsLexer
 from snowflake.cli._app.printing import print_result
 from snowflake.cli._plugins.sql.lexer import CliLexer, cli_completer
 from snowflake.cli._plugins.sql.manager import SqlManager
+from snowflake.cli._plugins.sql.repl_commands import detect_command
 from snowflake.cli.api.cli_global_context import get_cli_context_manager
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.output.types import MultipleResults, QueryResult
@@ -28,6 +30,21 @@ EXIT_KEYWORDS = ("exit", "quit")
 log.debug("setting history file to: %s", HISTORY_FILE.as_posix())
 
 
+@contextmanager
+def repl_context(repl_instance):
+    """Context manager for REPL execution that handles CLI context registration."""
+    context_manager = get_cli_context_manager()
+    context_manager.is_repl = True
+    context_manager.repl_instance = repl_instance
+
+    try:
+        yield
+    finally:
+        # Clean up REPL context
+        context_manager.is_repl = False
+        context_manager.repl_instance = None
+
+
 class Repl:
     """Basic REPL implementation for the Snowflake CLI."""
 
@@ -45,7 +62,6 @@ class Repl:
         `retain_comments` how to handle comments in queries
         """
         super().__init__()
-        setattr(get_cli_context_manager(), "is_repl", True)
         self._data = data or {}
         self._retain_comments = retain_comments
         self._template_syntax_config = template_syntax_config
@@ -56,6 +72,7 @@ class Repl:
         self._yes_no_keybindings = self._setup_yn_key_bindings()
         self._sql_manager = sql_manager
         self.session = PromptSession(history=self._history)
+        self._next_input: str | None = None
 
     def _setup_key_bindings(self) -> KeyBindings:
         """Key bindings for repl. Helps detecting ; at end of buffer."""
@@ -65,22 +82,52 @@ class Repl:
         def not_searching():
             return not is_searching()
 
+        @kb.add(Keys.BracketedPaste)
+        def _(event):
+            """Handle bracketed paste - normalize line endings and strip trailing whitespace."""
+            pasted_data = event.data
+            # Normalize line endings: \r\n -> \n, \r -> \n
+            normalized_data = pasted_data.replace("\r\n", "\n").replace("\r", "\n")
+            # Strip trailing whitespace
+            cleaned_data = normalized_data.rstrip()
+            buffer = event.app.current_buffer
+            buffer.insert_text(cleaned_data)
+            log.debug(
+                "handled paste operation, normalized line endings and stripped trailing whitespace"
+            )
+
         @kb.add(Keys.Enter, filter=not_searching)
         def _(event):
-            """Handle Enter key press."""
+            """Handle Enter key press with intelligent execution logic.
+
+            Execution priority:
+            1. Exit keywords (exit, quit) - execute immediately
+            2. REPL commands (starting with !) - execute immediately
+            3. SQL with trailing semicolon - execute immediately
+            4. All other input - add new line for multi-line editing
+            """
             buffer = event.app.current_buffer
-            stripped_buffer = buffer.text.strip()
+            buffer_text = buffer.text
+            stripped_text = buffer_text.strip()
 
-            if stripped_buffer:
+            if stripped_text:
                 log.debug("evaluating repl input")
                 cursor_position = buffer.cursor_position
-                ends_with_semicolon = buffer.text.endswith(";")
+                ends_with_semicolon = stripped_text.endswith(";")
+                is_command = detect_command(stripped_text) is not None
 
-                if stripped_buffer.lower() in EXIT_KEYWORDS:
-                    log.debug("exit keyword detected %r", stripped_buffer)
+                meaningful_content_end = len(buffer_text.rstrip())
+                cursor_at_meaningful_end = cursor_position >= meaningful_content_end
+
+                if stripped_text.lower() in EXIT_KEYWORDS:
+                    log.debug("exit keyword detected %r", stripped_text)
+                    buffer.validate_and_handle()
+
+                elif is_command:
+                    log.debug("command detected, submitting input")
                     buffer.validate_and_handle()
 
-                elif ends_with_semicolon and cursor_position >= len(stripped_buffer):
+                elif ends_with_semicolon and cursor_at_meaningful_end:
                     log.debug("semicolon detected, submitting input")
                     buffer.validate_and_handle()
 
@@ -118,16 +165,27 @@ class Repl:
 
         return kb
 
-    def repl_propmpt(self, msg: str = " > ") -> str:
-        """Regular repl prompt."""
-        return self.session.prompt(
-            msg,
-            lexer=self._lexer,
-            completer=self._completer,
-            multiline=True,
-            wrap_lines=True,
-            key_bindings=self._repl_key_bindings,
-        )
+    def repl_prompt(self, msg: str = " > ") -> str:
+        """Regular repl prompt with support for pre-filled input.
+
+        Checks for queued input from commands like !edit and uses it as
+        default text in the prompt. The queued input is cleared after use.
+        """
+        default_text = self._next_input
+
+        try:
+            return self.session.prompt(
+                msg,
+                lexer=self._lexer,
+                completer=self._completer,
+                multiline=True,
+                wrap_lines=True,
+                key_bindings=self._repl_key_bindings,
+                default=default_text or "",
+            )
+        finally:
+            if self._next_input == default_text:
+                self._next_input = None
 
     def yn_prompt(self, msg: str) -> str:
         """Yes/No prompt."""
@@ -142,7 +200,7 @@ class Repl:
 
     @property
     def _welcome_banner(self) -> str:
-        return f"Welcome to Snowflake-CLI REPL\nType 'exit' or 'quit' to leave"
+        return "Welcome to Snowflake-CLI REPL\nType 'exit' or 'quit' to leave"
 
     def _initialize_connection(self):
         """Early connection for possible fast fail."""
@@ -163,12 +221,13 @@ class Repl:
         return cursors
 
     def run(self):
-        try:
-            cli_console.panel(self._welcome_banner)
-            self._initialize_connection()
-            self._repl_loop()
-        except (KeyboardInterrupt, EOFError):
-            cli_console.message("\n[bold orange_red1]Leaving REPL, bye ...")
+        with repl_context(self):
+            try:
+                cli_console.panel(self._welcome_banner)
+                self._initialize_connection()
+                self._repl_loop()
+            except (KeyboardInterrupt, EOFError):
+                cli_console.message("\n[bold orange_red1]Leaving REPL, bye ...")
 
     def _repl_loop(self):
         """Main REPL loop. Handles input and query execution.
@@ -178,7 +237,7 @@ class Repl:
         """
         while True:
             try:
-                user_input = self.repl_propmpt().strip()
+                user_input = self.repl_prompt().strip()
 
                 if not user_input:
                     continue
@@ -210,6 +269,21 @@ class Repl:
             except Exception as e:
                 cli_console.warning(f"\nError occurred: {e}")
 
+    def set_next_input(self, text: str) -> None:
+        """Set the text that will be used as the next REPL input."""
+        self._next_input = text
+        log.debug("Next input has been set")
+
+    @property
+    def next_input(self) -> str | None:
+        """Get the next input text that will be used in the prompt."""
+        return self._next_input
+
+    @property
+    def history(self) -> FileHistory:
+        """Get the FileHistory instance used by the REPL."""
+        return self._history
+
     def ask_yn(self, question: str) -> bool:
         """Asks user a Yes/No question."""
         try: