snowflake-cli 3.11.0__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/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

snowflake/cli/api/project/schemas/entities/entities.py

@@ -16,10 +16,6 @@ from __future__ import annotations
 
 from typing import Dict, List, Union, get_args
 
-from snowflake.cli._plugins.dcm.dcm_project_entity_model import (
-    DCMProjectEntity,
-    DCMProjectEntityModel,
-)
 from snowflake.cli._plugins.nativeapp.entities.application import (
     ApplicationEntity,
     ApplicationEntityModel,
@@ -62,7 +58,6 @@ Entity = Union[
     ApplicationPackageEntity,
     StreamlitEntity,
     ProcedureEntity,
-    DCMProjectEntity,
     FunctionEntity,
     ComputePoolEntity,
     ImageRepositoryEntity,
@@ -79,7 +74,6 @@ EntityModel = Union[
     ImageRepositoryEntityModel,
     ServiceEntityModel,
     NotebookEntityModel,
-    DCMProjectEntityModel,
 ]
 
 ALL_ENTITIES: List[Entity] = [*get_args(Entity)]

snowflake/cli/api/rendering/sql_templates.py

@@ -35,6 +35,7 @@ _SQL_TEMPLATE_START = "<%"
 _SQL_TEMPLATE_END = "%>"
 _OLD_SQL_TEMPLATE_START = "&{"
 _OLD_SQL_TEMPLATE_END = "}"
+_JINJA_TEMPLATE_START, _JINJA_TEMPLATE_END = "{{", "}}"
 RESERVED_KEYS = [CONTEXT_KEY, FUNCTION_KEY]
 
 
@@ -62,6 +63,7 @@ def has_sql_templates(template_content: str) -> bool:
     return (
         _OLD_SQL_TEMPLATE_START in template_content
         or _SQL_TEMPLATE_START in template_content
+        or _JINJA_TEMPLATE_START in template_content
     )
 
 

{snowflake_cli-3.11.0.dist-info → snowflake_cli-3.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-cli
-Version: 3.11.0
+Version: 3.12.0
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues
@@ -231,14 +231,14 @@ Requires-Dist: requests==2.32.4
 Requires-Dist: requirements-parser==0.13.0
 Requires-Dist: rich==14.0.0
 Requires-Dist: setuptools==80.8.0
-Requires-Dist: snowflake-connector-python[secure-local-storage]==3.17.2
-Requires-Dist: snowflake-core==1.6.0
+Requires-Dist: snowflake-connector-python[secure-local-storage]==3.17.3
+Requires-Dist: snowflake-core==1.7.0
 Requires-Dist: snowflake-snowpark-python==1.33.0; python_version < '3.12'
 Requires-Dist: tomlkit==0.13.3
-Requires-Dist: typer==0.16.0
+Requires-Dist: typer==0.17.3
 Requires-Dist: urllib3<2.6,>=1.24.3
 Provides-Extra: development
-Requires-Dist: coverage==7.8.0; extra == 'development'
+Requires-Dist: coverage==7.10.4; extra == 'development'
 Requires-Dist: factory-boy==3.3.3; extra == 'development'
 Requires-Dist: faker==37.4.0; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'