snowflake-cli 3.10.1__py3-none-any.whl → 3.12.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/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

@@ -57,6 +57,7 @@ from snowflake.cli.api.commands.flags import (
     UserOption,
     VerboseOption,
     WarehouseOption,
+    WorkloadIdentityProviderOption,
     experimental_option,
     project_definition_option,
     project_env_overrides_option,
@@ -262,6 +263,12 @@ GLOBAL_CONNECTION_OPTIONS = [
         annotation=Optional[str],
         default=AuthenticatorOption,
     ),
+    inspect.Parameter(
+        "workload_identity_provider",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=WorkloadIdentityProviderOption,
+    ),
     inspect.Parameter(
         "private_key_file",
         inspect.Parameter.KEYWORD_ONLY,

snowflake/cli/api/commands/flags.py

@@ -34,6 +34,7 @@ from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.secret import SecretType
 from snowflake.cli.api.stage_path import StagePath
+from snowflake.connector.auth.workload_identity import ApiFederatedAuthenticationType
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
 
@@ -150,6 +151,21 @@ def _password_callback(value: str):
     return _connection_callback("password")(value)
 
 
+def _workload_identity_provider_callback(value: str):
+    if value is not None:
+        try:
+            # Validate that the value is one of the enum values
+            ApiFederatedAuthenticationType(value)
+        except ValueError:
+            valid_values = [e.value for e in ApiFederatedAuthenticationType]
+            raise ClickException(
+                f"Invalid workload identity provider '{value}'. "
+                f"Valid values are: {', '.join(valid_values)}"
+            )
+
+    return _connection_callback("workload_identity_provider")(value)
+
+
 PasswordOption = typer.Option(
     None,
     "--password",
@@ -170,6 +186,16 @@ AuthenticatorOption = typer.Option(
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+WorkloadIdentityProviderOption = typer.Option(
+    None,
+    "--workload-identity-provider",
+    help="Workload identity provider (AWS, AZURE, GCP, OIDC). Overrides the value specified for the connection",
+    hide_input=True,
+    callback=_workload_identity_provider_callback,
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
 PrivateKeyPathOption = typer.Option(
     None,
     "--private-key-file",

snowflake/cli/api/config.py

@@ -34,6 +34,7 @@ from snowflake.cli.api.secure_utils import (
     file_permissions_are_strict,
     windows_get_not_whitelisted_users_with_access,
 )
+from snowflake.cli.api.utils.dict_utils import remove_key_from_nested_dict_if_exists
 from snowflake.cli.api.utils.types import try_cast_to_bool
 from snowflake.connector.compat import IS_WINDOWS
 from snowflake.connector.config_manager import CONFIG_MANAGER
@@ -82,6 +83,7 @@ class ConnectionConfig:
     warehouse: Optional[str] = None
     role: Optional[str] = None
     authenticator: Optional[str] = None
+    workload_identity_provider: Optional[str] = None
     private_key_file: Optional[str] = None
     token_file_path: Optional[str] = None
     oauth_client_id: Optional[str] = None
@@ -158,6 +160,19 @@ def add_connection_to_proper_file(name: str, connection_config: ConnectionConfig
         return CONFIG_MANAGER.file_path
 
 
+def remove_connection_from_proper_file(name: str):
+    if CONNECTIONS_FILE.exists():
+        existing_connections = _read_connections_toml()
+        if name not in existing_connections:
+            raise MissingConfigurationError(f"Connection {name} is not configured")
+        del existing_connections[name]
+        _update_connections_toml(existing_connections)
+        return CONNECTIONS_FILE
+    else:
+        unset_config_value(path=[CONNECTIONS_SECTION, name])
+        return CONFIG_MANAGER.file_path
+
+
 _DEFAULT_LOGS_CONFIG = {
     "save_logs": True,
     "path": str(CONFIG_MANAGER.file_path.parent / "logs"),
@@ -228,6 +243,15 @@ def set_config_value(path: List[str], value: Any) -> None:
         current_config_dict[path[-1]] = value
 
 
+def unset_config_value(path: List[str]) -> None:
+    """Unsets value in config.
+    For example to unset value for key "key" in section [a.b.c], call
+    unset_config_value(["a", "b", "c", "key"]).
+    """
+    with _config_file() as conf_file_cache:
+        remove_key_from_nested_dict_if_exists(conf_file_cache, path)
+
+
 def get_logs_config() -> dict:
     logs_config = _DEFAULT_LOGS_CONFIG.copy()
     if config_section_exists(*LOGS_SECTION_PATH):

snowflake/cli/api/connections.py

@@ -45,6 +45,7 @@ class ConnectionContext:
     user: Optional[str] = None
     password: Optional[str] = field(default=None, repr=False)
     authenticator: Optional[str] = None
+    workload_identity_provider: Optional[str] = None
     private_key_file: Optional[str] = None
     warehouse: Optional[str] = None
     mfa_passcode: Optional[str] = None

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,

snowflake/cli/api/entities/utils.py

@@ -87,6 +87,7 @@ def sync_deploy_root_with_stage(
     prune: bool,
     recursive: bool,
     stage_path_parts: StagePathParts,
+    use_temporary_stage: bool = False,
     role: str | None = None,
     package_name: str | None = None,
     local_paths_to_sync: List[Path] | None = None,
@@ -103,6 +104,7 @@ def sync_deploy_root_with_stage(
         prune (bool): Whether to prune artifacts from the stage that don't exist locally.
         recursive (bool): Whether to traverse directories recursively.
         stage_path_parts (StagePathParts): stage path parts object.
+        use_temporary_stage (bool): specifies if new stage should be temporary.
 
         package_name (str): supported for Native App compatibility. Should be None out of Native App context.
 
@@ -120,8 +122,11 @@ def sync_deploy_root_with_stage(
     elif not package_name:
         # ensure stage exists
         stage_fqn = FQN.from_stage(stage_path_parts.stage)
-        console.step(f"Creating stage {stage_fqn} if not exists.")
-        StageManager().create(fqn=stage_fqn)
+        if use_temporary_stage:
+            console.step(f"Creating temporary stage {stage_fqn}.")
+        else:
+            console.step(f"Creating stage {stage_fqn} if not exists.")
+        StageManager().create(fqn=stage_fqn, temporary=use_temporary_stage)
     else:
         # ensure stage exists - nativeapp behavior
         sql_facade = get_snowflake_facade()
@@ -134,10 +139,10 @@ def sync_deploy_root_with_stage(
         )
         if not sql_facade.stage_exists(stage_fqn):
             sql_facade.create_schema(schema, database=package_name)
-            sql_facade.create_stage(stage_fqn)
+            sql_facade.create_stage(stage_fqn, temporary=use_temporary_stage)
 
     # Perform a diff operation and display results to the user for informational purposes
-    if print_diff:
+    if print_diff and not use_temporary_stage:
         console.step(
             f"Performing a diff between the Snowflake stage: {stage_path_parts.path} and your local deploy_root: {deploy_root.resolve()}."
         )
@@ -199,8 +204,7 @@ def sync_deploy_root_with_stage(
     # Upload diff-ed files to the stage
     if diff.has_changes():
         console.step(
-            "Updating the Snowflake stage from your local %s directory."
-            % deploy_root.resolve(),
+            f"Uploading files from local {deploy_root.resolve()} directory to{' temporary' if use_temporary_stage else ''} stage."
         )
         sync_local_diff_with_stage(
             role=role,

snowflake/cli/api/feature_flags.py

@@ -65,6 +65,7 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_SNOWPARK_GLOB_SUPPORT = BooleanFlag("ENABLE_SNOWPARK_GLOB_SUPPORT", False)
     ENABLE_SPCS_SERVICE_EVENTS = BooleanFlag("ENABLE_SPCS_SERVICE_EVENTS", False)
     ENABLE_DBT = BooleanFlag("ENABLE_DBT", False)
+    ENABLE_DBT_GA_FEATURES = BooleanFlag("ENABLE_DBT_GA_FEATURES", False)
     ENABLE_AUTH_KEYPAIR = BooleanFlag("ENABLE_AUTH_KEYPAIR", False)
     ENABLE_NATIVE_APP_PYTHON_SETUP = BooleanFlag(
         "ENABLE_NATIVE_APP_PYTHON_SETUP", False

snowflake/cli/api/identifiers.py

@@ -15,14 +15,20 @@
 from __future__ import annotations
 
 import re
+import time
 from pathlib import Path
 
 from click import ClickException
+from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import FQNInconsistencyError, FQNNameError
 from snowflake.cli.api.project.schemas.v1.identifier_model import (
     ObjectIdentifierBaseModel,
 )
-from snowflake.cli.api.project.util import VALID_IDENTIFIER_REGEX, identifier_for_url
+from snowflake.cli.api.project.util import (
+    VALID_IDENTIFIER_REGEX,
+    identifier_for_url,
+    unquote_identifier,
+)
 
 
 class FQN:
@@ -167,6 +173,17 @@ class FQN:
 
         return fqn.set_database(model.database).set_schema(model.schema_)
 
+    @classmethod
+    def from_resource(
+        cls, resource_type: ObjectType, resource_fqn: FQN, purpose: str
+    ) -> "FQN":
+        """Create an instance related to another Snowflake resource."""
+        unquoted_name = unquote_identifier(resource_fqn.name)
+        safe_cli_name = resource_type.value.cli_name.upper().replace("-", "_")
+        return cls.from_string(
+            f"{safe_cli_name}_{unquoted_name}_{int(time.time())}_{purpose.upper()}"
+        ).using_context()
+
     def set_database(self, database: str | None) -> "FQN":
         if database:
             self._database = database