snowflake-cli 3.11.0__py3-none-any.whl → 3.13.0__py3-none-any.whl

snowflake/cli/_plugins/sql/statement_reader.py

@@ -7,9 +7,10 @@ from typing import Any, Callable, Generator, List, Literal, Sequence, Tuple
 from urllib.request import urlopen
 
 from jinja2 import UndefinedError
-from snowflake.cli._plugins.sql.snowsql_commands import (
-    SnowSQLCommand,
-    compile_snowsql_command,
+from snowflake.cli._plugins.sql.repl_commands import (
+    ReplCommand,
+    UnknownCommandError,
+    compile_repl_command,
 )
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 from snowflake.connector.util_text import split_statements
@@ -38,7 +39,7 @@ class StatementType(enum.Enum):
     QUERY = "query"
     UNKNOWN = "unknown"
     URL = "url"
-    SNOWSQL_COMMAND = "snowsql_command"
+    REPL_COMMAND = "repl_command"
 
 
 class ParsedStatement:
@@ -88,12 +89,21 @@ class ParsedStatement:
     def __repr__(self):
         return f"{self.__class__.__name__}(statement_type={self.statement_type}, source_path={self.source_path}, error={self.error})"
 
+    @staticmethod
+    def drop_comments_from_path_parts(path_part: str) -> str:
+        """Clean up path_part from trailing comments."""
+        uncommented, _ = next(
+            split_statements(io.StringIO(path_part), remove_comments=True)
+        )
+        return uncommented
+
     @classmethod
     def from_url(cls, path_part: str, raw_source: str) -> "ParsedStatement":
         """Constructor for loading from URL."""
+        stripped_comments_path_part = cls.drop_comments_from_path_parts(path_part)
         try:
-            payload = urlopen(path_part, timeout=10.0).read().decode()
-            return cls(payload, StatementType.URL, path_part)
+            payload = urlopen(stripped_comments_path_part, timeout=10.0).read().decode()
+            return cls(payload, StatementType.URL, stripped_comments_path_part)
 
         except urllib.error.HTTPError as err:
             error = f"Could not fetch {path_part}: {err}"
@@ -102,14 +112,20 @@ class ParsedStatement:
     @classmethod
     def from_file(cls, path_part: str, raw_source: str) -> "ParsedStatement":
         """Constructor for loading from file."""
-        path = SecurePath(path_part)
+        stripped_comments_path_part = cls.drop_comments_from_path_parts(path_part)
+        path = SecurePath(stripped_comments_path_part)
 
         if path.is_file():
             payload = path.read_text(file_size_limit_mb=UNLIMITED)
             return cls(payload, StatementType.FILE, path.as_posix())
 
         error_msg = f"Could not read: {path_part}"
-        return cls(path_part, StatementType.FILE, raw_source, error_msg)
+        return cls(
+            path_part,
+            StatementType.FILE,
+            raw_source,
+            error_msg,
+        )
 
 
 RecursiveStatementReader = Generator[ParsedStatement, Any, Any]
@@ -154,7 +170,10 @@ def parse_statement(source: str, operators: OperatorFunctions) -> ParsedStatemen
             )
 
         case "queries" | "result" | "abort", (str(),):
-            return ParsedStatement(statement, StatementType.SNOWSQL_COMMAND, None)
+            return ParsedStatement(statement, StatementType.REPL_COMMAND, None)
+
+        case "edit", (str(),):
+            return ParsedStatement(statement, StatementType.REPL_COMMAND, command_args)
 
         case _:
             error_msg = f"Unknown command: {command}"
@@ -240,7 +259,7 @@ def query_reader(
 class CompiledStatement:
     statement: str | None = None
     execute_async: bool = False
-    command: SnowSQLCommand | None = None
+    command: ReplCommand | None = None
 
 
 def _is_empty_statement(statement: str) -> bool:
@@ -274,21 +293,26 @@ def compile_statements(
                 if not is_async:
                     expected_results_cnt += 1
 
-        if stmt.statement_type == StatementType.SNOWSQL_COMMAND:
+        if stmt.statement_type == StatementType.REPL_COMMAND:
             if not stmt.error:
-                cmd = (
+                command_text = (
                     stmt.statement.read()
                     .removesuffix(ASYNC_SUFFIX)
                     .removesuffix(";")
-                    .split()
-                )
-                parsed_command = compile_snowsql_command(
-                    command=cmd[0], cmd_args=cmd[1:]
+                    .strip()
                 )
-                if parsed_command.error_message:
-                    errors.append(parsed_command.error_message)
-                else:
-                    compiled.append(CompiledStatement(command=parsed_command.command))
+                try:
+                    parsed_command = compile_repl_command(command_text)
+                    if parsed_command.error_message:
+                        errors.append(parsed_command.error_message)
+                    else:
+                        compiled.append(
+                            CompiledStatement(command=parsed_command.command)
+                        )
+                except UnknownCommandError as e:
+                    errors.append(str(e))
+                except Exception as e:
+                    errors.append(f"Error parsing command: {e}")
 
         if stmt.error:
             errors.append(stmt.error)

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -6,7 +6,9 @@ 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.stage.manager import StageManager
+from snowflake.cli._plugins.streamlit.manager import StreamlitManager
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
+    SPCS_RUNTIME_V2_NAME,
     StreamlitEntityModel,
 )
 from snowflake.cli._plugins.workspace.context import ActionContext
@@ -64,6 +66,14 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             self._conn, f"/#/streamlit-apps/{name.url_identifier}"
         )
 
+    def _is_spcs_runtime_v2_mode(self, experimental: bool = False) -> bool:
+        """Check if SPCS runtime v2 mode is enabled."""
+        return (
+            experimental
+            and self.model.runtime_name == SPCS_RUNTIME_V2_NAME
+            and self.model.compute_pool
+        )
+
     def bundle(self, output_dir: Optional[Path] = None) -> BundleMap:
         return build_bundle(
             self.root,
@@ -83,7 +93,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         replace: bool,
         prune: bool = False,
         bundle_map: Optional[BundleMap] = None,
-        experimental: Optional[bool] = False,
+        experimental: bool = False,
         *args,
         **kwargs,
     ):
@@ -129,9 +139,15 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             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)
+                self.get_deploy_sql(
+                    replace=replace,
+                    from_stage_name=stage_root,
+                    experimental=False,
+                )
             )
 
+            StreamlitManager(connection=self._conn).grant_privileges(self.model)
+
         return self.perform(EntityActions.GET_URL, action_context, *args, **kwargs)
 
     def describe(self) -> SnowflakeCursor:
@@ -156,6 +172,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         artifacts_dir: Optional[Path] = None,
         schema: Optional[str] = None,
         database: Optional[str] = None,
+        experimental: bool = False,
         *args,
         **kwargs,
     ) -> str:
@@ -199,6 +216,12 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         if self.model.secrets:
             query += "\n" + self.model.get_secrets_sql()
 
+        # SPCS runtime fields are only supported for FBE/versioned streamlits (FROM syntax)
+        # Never add these fields for stage-based deployments (ROOT_LOCATION syntax)
+        if not from_stage_name and self._is_spcs_runtime_v2_mode(experimental):
+            query += f"\nRUNTIME_NAME = '{self.model.runtime_name}'"
+            query += f"\nCOMPUTE_POOL = '{self.model.compute_pool}'"
+
         return query + ";"
 
     def get_describe_sql(self) -> str:
@@ -233,6 +256,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             self.get_deploy_sql(
                 if_not_exists=True,
                 replace=replace,
+                experimental=True,
             )
         )
         try:
@@ -256,3 +280,5 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             print_diff=True,
             force_overwrite=True,  # files copied to streamlit vstage need to be overwritten
         )
+
+        StreamlitManager(connection=self._conn).grant_privileges(self.model)

snowflake/cli/_plugins/streamlit/streamlit_entity_model.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 from typing import Literal, Optional
 
-from pydantic import Field
+from pydantic import Field, model_validator
 from snowflake.cli.api.project.schemas.entities.common import (
     Artifacts,
     EntityModelBaseWithArtifacts,
@@ -23,9 +23,10 @@ from snowflake.cli.api.project.schemas.entities.common import (
     GrantBaseModel,
     ImportsBaseModel,
 )
-from snowflake.cli.api.project.schemas.updatable_model import (
-    DiscriminatorField,
-)
+from snowflake.cli.api.project.schemas.updatable_model import DiscriminatorField
+
+# SPCS Runtime v2 constants
+SPCS_RUNTIME_V2_NAME = "SYSTEM$ST_CONTAINER_RUNTIME_PY3_11"
 
 
 class StreamlitEntityModel(
@@ -54,3 +55,22 @@ class StreamlitEntityModel(
         title="List of paths or file source/destination pairs to add to the deploy root",
         default=None,
     )
+    runtime_name: Optional[str] = Field(
+        title="The runtime name to run the streamlit app on", default=None
+    )
+    compute_pool: Optional[str] = Field(
+        title="The compute pool name of the snowservices running the streamlit app",
+        default=None,
+    )
+
+    @model_validator(mode="after")
+    def validate_spcs_runtime_fields(self):
+        """Validate that runtime_name and compute_pool are provided together for SPCS container runtime."""
+        # Only validate for SPCS container runtime, not warehouse runtime
+        if self.compute_pool and not self.runtime_name:
+            raise ValueError("compute_pool is specified without runtime_name")
+        if self.runtime_name == SPCS_RUNTIME_V2_NAME and not self.compute_pool:
+            raise ValueError(
+                f"compute_pool is required when using {SPCS_RUNTIME_V2_NAME}"
+            )
+        return self

snowflake/cli/api/artifacts/bundle_map.py

@@ -11,6 +11,9 @@ from snowflake.cli.api.artifacts.common import (
     SourceNotFoundError,
     TooManyFilesError,
 )
+from snowflake.cli.api.artifacts.regex_resolver import RegexResolver
+from snowflake.cli.api.constants import PatternMatchingType
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.project.schemas.entities.common import PathMapping
 from snowflake.cli.api.utils.path_utils import resolve_without_follow
 
@@ -38,9 +41,16 @@ class BundleMap:
 
     :param project_root: The root directory of the project and base for all relative paths. Must be an absolute path.
     :param deploy_root: The directory where artifacts should be copied to. Must be an absolute path.
+    :param pattern_type: The pattern matching type to use for artifact resolution. Defaults to GLOB.
     """
 
-    def __init__(self, *, project_root: Path, deploy_root: Path):
+    def __init__(
+        self,
+        *,
+        project_root: Path,
+        deploy_root: Path,
+        pattern_type: PatternMatchingType = PatternMatchingType.GLOB,
+    ):
         # If a relative path ends up here, it's a bug in the app and can lead to other
         # subtle bugs as paths would be resolved relative to the current working directory.
         assert (
@@ -52,6 +62,7 @@ class BundleMap:
 
         self._project_root: Path = resolve_without_follow(project_root)
         self._deploy_root: Path = resolve_without_follow(deploy_root)
+        self._pattern_type: PatternMatchingType = pattern_type
         self._artifact_map = _ArtifactPathMap(project_root=self._project_root)
 
     def is_empty(self) -> bool:
@@ -112,7 +123,14 @@ class BundleMap:
         if src_path.is_absolute():
             raise ArtifactError("Source path must be a relative path")
 
-        for resolved_src in self._project_root.glob(src):
+        if self._pattern_type == PatternMatchingType.REGEX:
+            resolved_sources = self._resolve_regex_pattern(src)
+        elif self._pattern_type == PatternMatchingType.GLOB:
+            resolved_sources = self._project_root.glob(src)
+        else:
+            raise CliError(f"Unsupported pattern type: {self._pattern_type}")
+
+        for resolved_src in resolved_sources:
             match_found = True
 
             if dest:
@@ -140,6 +158,18 @@ class BundleMap:
         if not match_found:
             raise SourceNotFoundError(src)
 
+    def _resolve_regex_pattern(self, pattern: str):
+        """
+        Resolve files matching a regex pattern.
+        """
+        resolver = RegexResolver()
+        for path in self._project_root.rglob("*"):
+            if path.is_file():
+                relative_path = str(path.relative_to(self._project_root))
+                relative_path = relative_path.replace("\\", "/")
+                if resolver.does_match(pattern, relative_path):
+                    yield path
+
     def add(self, mapping: PathMapping) -> None:
         """
         Adds an artifact mapping rule to this instance.

snowflake/cli/api/artifacts/regex_resolver.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2025 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field, ValidationError
+from pydantic_core import SchemaError
+from snowflake.cli.api.artifacts.common import ArtifactError
+
+
+class RegexResolver:
+    def __init__(self):
+        self._pattern_classes = {}
+
+    def does_match(self, pattern: str, text: str) -> bool:
+        """
+        Check if text matches pattern.
+        """
+        if len(pattern) > 1000:
+            raise ArtifactError(
+                f"Regex pattern too long ({len(pattern)} chars, max 1000): "
+                "potentially unsafe for performance"
+            )
+        if pattern not in self._pattern_classes:
+            self._pattern_classes[pattern] = self._generate_pattern_class(pattern)
+
+        pattern_class = self._pattern_classes[pattern]
+        try:
+            pattern_class(test_field=text)
+            return True
+        except ValidationError:
+            return False
+
+    @staticmethod
+    def _generate_pattern_class(pattern: str) -> type:
+        try:
+
+            class _RegexTestModel(BaseModel):
+                test_field: str = Field(pattern=pattern)
+
+            return _RegexTestModel
+        except SchemaError as e:
+            raise ArtifactError(f"Invalid regex pattern: {e}") from e

snowflake/cli/api/artifacts/upload.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli.api.artifacts.utils import bundle_artifacts
 from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.constants import PatternMatchingType
 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
@@ -12,8 +13,10 @@ from snowflake.cli.api.secure_path import SecurePath
 def sync_artifacts_with_stage(
     project_paths: ProjectPaths,
     stage_root: str,
+    use_temporary_stage: bool = False,
     prune: bool = False,
     artifacts: Optional[List[PathMapping]] = None,
+    pattern_type: PatternMatchingType = PatternMatchingType.GLOB,
 ):
     if artifacts is None:
         artifacts = []
@@ -21,7 +24,7 @@ def sync_artifacts_with_stage(
     project_paths.remove_up_bundle_root()
     SecurePath(project_paths.bundle_root).mkdir(parents=True, exist_ok=True)
 
-    bundle_map = bundle_artifacts(project_paths, artifacts)
+    bundle_map = bundle_artifacts(project_paths, artifacts, pattern_type=pattern_type)
     stage_path_parts = StageManager().stage_path_parts_from_str(stage_root)
     # We treat the bundle root as deploy root
     sync_deploy_root_with_stage(
@@ -31,6 +34,7 @@ def sync_artifacts_with_stage(
         prune=prune,
         recursive=True,
         stage_path_parts=stage_path_parts,
+        use_temporary_stage=use_temporary_stage,
         print_diff=True,
     )
     project_paths.clean_up_output()

snowflake/cli/api/artifacts/utils.py

@@ -5,6 +5,7 @@ from pathlib import Path
 
 from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.artifacts.common import NotInDeployRootError
+from snowflake.cli.api.constants import PatternMatchingType
 from snowflake.cli.api.project.project_paths import ProjectPaths
 from snowflake.cli.api.project.schemas.entities.common import Artifacts
 from snowflake.cli.api.secure_path import SecurePath
@@ -54,16 +55,26 @@ def symlink_or_copy(src: Path, dst: Path, deploy_root: Path) -> None:
                 )
 
 
-def bundle_artifacts(project_paths: ProjectPaths, artifacts: Artifacts) -> BundleMap:
+def bundle_artifacts(
+    project_paths: ProjectPaths,
+    artifacts: Artifacts,
+    pattern_type: PatternMatchingType = PatternMatchingType.GLOB,
+) -> BundleMap:
     """
     Creates a bundle directory (project_paths.bundle_root) with all artifacts (using symlink_or_copy function above).
     Previous contents of the directory are deleted.
 
     Returns a BundleMap containing the mapping between artifacts and their location in bundle directory.
+
+    Args:
+        project_paths: Project paths configuration
+        artifacts: List of artifacts to bundle
+        pattern_type: The pattern matching type to use for artifact resolution. Defaults to GLOB.
     """
     bundle_map = BundleMap(
         project_root=project_paths.project_root,
         deploy_root=project_paths.bundle_root,
+        pattern_type=pattern_type,
     )
     for artifact in artifacts:
         bundle_map.add(artifact)

snowflake/cli/api/cli_global_context.py

@@ -29,6 +29,7 @@ from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
 from snowflake.connector import SnowflakeConnection
 
 if TYPE_CHECKING:
+    from snowflake.cli._plugins.sql.repl import Repl
     from snowflake.cli.api.project.definition_manager import DefinitionManager
     from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
 
@@ -48,6 +49,7 @@ class _CliGlobalContextManager:
     experimental: bool = False
     enable_tracebacks: bool = True
     is_repl: bool = False
+    repl_instance: Repl | None = None
 
     metrics: CLIMetrics = field(default_factory=CLIMetrics)
 
@@ -209,6 +211,11 @@ class _CliGlobalContextAccess:
     def is_repl(self) -> bool:
         return self._manager.is_repl
 
+    @property
+    def repl(self) -> Repl | None:
+        """Get the current REPL instance if running in REPL mode."""
+        return self._manager.repl_instance
+
 
 _CLI_CONTEXT_MANAGER: ContextVar[_CliGlobalContextManager | None] = ContextVar(
     "cli_context", default=None

snowflake/cli/api/commands/decorators.py

@@ -27,6 +27,7 @@ from snowflake.cli.api.commands.flags import (
     ConnectionOption,
     DatabaseOption,
     DebugOption,
+    DecimalPrecisionOption,
     DiagAllowlistPathOption,
     DiagLogPathOption,
     EnableDiagOption,
@@ -446,6 +447,12 @@ GLOBAL_OPTIONS = [
         annotation=Optional[bool],
         default=EnhancedExitCodesOption,
     ),
+    inspect.Parameter(
+        "decimal_precision",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[int],
+        default=DecimalPrecisionOption,
+    ),
 ]
 
 

snowflake/cli/api/commands/flags.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+from decimal import getcontext
 from pathlib import Path
 from typing import Any, Callable, Optional
 
@@ -27,7 +28,7 @@ from snowflake.cli.api.cli_global_context import (
 from snowflake.cli.api.commands.common import OnErrorType
 from snowflake.cli.api.commands.overrideable_parameter import OverrideableOption
 from snowflake.cli.api.commands.utils import parse_key_value_variables
-from snowflake.cli.api.config import get_all_connections
+from snowflake.cli.api.config import get_all_connections, get_config_value
 from snowflake.cli.api.connections import ConnectionContext
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.identifiers import FQN
@@ -513,6 +514,28 @@ EnhancedExitCodesOption = typer.Option(
     envvar="SNOWFLAKE_ENHANCED_EXIT_CODES",
 )
 
+
+def _decimal_precision_callback(value: int | None):
+    """Callback to set decimal precision globally when provided."""
+    if value is None:
+        try:
+            value = get_config_value(key="decimal_precision", default=None)
+        except Exception:
+            pass
+
+    if value is not None:
+        getcontext().prec = value
+    return value
+
+
+DecimalPrecisionOption = typer.Option(
+    None,
+    "--decimal-precision",
+    help="Number of decimal places to display for decimal values. Uses Python's default precision if not specified. [env var: SNOWFLAKE_DECIMAL_PRECISION]",
+    callback=_decimal_precision_callback,
+    rich_help_panel=_CLI_BEHAVIOUR,
+)
+
 # 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.

snowflake/cli/api/console/abc.py

@@ -29,11 +29,15 @@ from snowflake.cli.api.cli_global_context import (
 class AbstractConsole(ABC):
     """Interface for cli console implementation.
 
-    Each console should have three methods implemented:
+    Each console should have the following methods implemented:
     - `step` - for more detailed information on steps
     - `warning` - for displaying messages in a style that makes it
       visually stand out from other output
-    - `phase` a context manager for organising steps into logical group
+    - `phase` - a context manager for organising steps into logical group
+    - `indented` - a context manager for temporarily indenting messages and warnings
+    - 'message' - displays an informational message to output
+    - 'panel' - displays visually separated messages
+    - 'spinner' - context manager for indicating a long-running operation
     """
 
     _print_fn: Callable[[str], None]
@@ -98,3 +102,10 @@ class AbstractConsole(ABC):
         """Displays message in a panel that makes it visually stand out from other output.
 
         Intended for displaying visually separated messages."""
+
+    @contextmanager
+    @abstractmethod
+    def spinner(self):
+        """
+        A context manager for indicating a long-running operation.
+        """

snowflake/cli/api/console/console.py

@@ -19,6 +19,7 @@ from typing import Optional
 
 from rich import get_console
 from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.style import Style
 from rich.text import Text
 from snowflake.cli.api.console.abc import AbstractConsole
@@ -31,6 +32,7 @@ get_console().soft_wrap = True
 get_console()._markup = False  # noqa: SLF001
 
 PHASE_STYLE: Style = Style(bold=True)
+SPINNER_STYLE: Style = Style(bold=True)
 STEP_STYLE: Style = Style(italic=True)
 INFO_STYLE: Style = Style()
 PANEL_STYLE: Style = Style()
@@ -98,6 +100,24 @@ class CliConsole(AbstractConsole):
         finally:
             self._extra_indent -= 1
 
+    @contextmanager
+    def spinner(self):
+        """
+        A context manager for displaying a spinner while executing a long-running operation.
+
+        Usage:
+            with cli_console.spinner("Processing data") as spinner:
+                spinner.add_task(description="Long operation", total=None)
+                # Long running operation here
+                result = some_operation()
+        """
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}", style=SPINNER_STYLE),
+            transient=True,
+        ) as progress:
+            yield progress
+
     def step(self, message: str):
         """Displays a message to output.
 

snowflake/cli/api/constants.py

@@ -75,6 +75,15 @@ class ObjectType(Enum):
         return self.value.cli_name
 
 
+class PatternMatchingType(Enum):
+    """
+    Enum for different pattern matching types used in artifact resolution.
+    """
+
+    GLOB = "glob"
+    REGEX = "regex"
+
+
 OBJECT_TO_NAMES = {o.value.cli_name: o.value for o in ObjectType}
 UNSUPPORTED_OBJECTS = {
     ObjectType.APPLICATION.value.cli_name,