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

snowflake/cli/_plugins/dcm/manager.py

@@ -11,21 +11,75 @@
 # 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 contextlib import contextmanager, nullcontext
+from pathlib import Path
+from typing import Generator, List
 
-from typing import List
-
-from snowflake.cli._plugins.dcm.dcm_project_entity_model import DCMProjectEntityModel
+import yaml
 from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
 from snowflake.cli.api.commands.utils import parse_key_value_variables
+from snowflake.cli.api.console.console import cli_console
+from snowflake.cli.api.constants import (
+    DEFAULT_SIZE_LIMIT_MB,
+    ObjectType,
+    PatternMatchingType,
+)
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
+from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
+from snowflake.cli.api.utils.path_utils import is_stage_path
+
+MANIFEST_FILE_NAME = "manifest.yml"
+DCM_PROJECT_TYPE = "dcm_project"
 
 
 class DCMProjectManager(SqlExecutionMixin):
+    @contextmanager
+    def _collect_output(
+        self, project_identifier: FQN, output_path: str
+    ) -> Generator[str, None, None]:
+        """
+        Context manager for handling output path - creates temporary stage for local paths,
+        downloads files after execution, and ensures proper cleanup.
+
+        Args:
+            project_identifier: The DCM project identifier
+            output_path: Either a stage path (@stage/path) or local directory path
+
+        Yields:
+            str: The effective output path to use in the DCM command
+        """
+        temp_stage_for_local_output = None
+        stage_manager = StageManager()
+
+        if should_download_files := not is_stage_path(output_path):
+            temp_stage_fqn = FQN.from_resource(
+                ObjectType.DCM_PROJECT, project_identifier, "OUTPUT_TMP_STAGE"
+            )
+            stage_manager.create(temp_stage_fqn, temporary=True)
+            effective_output_path = StagePath.from_stage_str(temp_stage_fqn.identifier)
+            temp_stage_for_local_output = (temp_stage_fqn.identifier, Path(output_path))
+        else:
+            effective_output_path = StagePath.from_stage_str(output_path)
+
+        yield effective_output_path.absolute_path()
+
+        if should_download_files:
+            assert temp_stage_for_local_output is not None
+            stage_path, local_path = temp_stage_for_local_output
+            stage_manager.get_recursive(stage_path=stage_path, dest_path=local_path)
+            cli_console.step(f"Plan output saved to: {local_path.resolve()}")
+        else:
+            cli_console.step(f"Plan output saved to: {output_path}")
+
     def execute(
         self,
-        project_name: FQN,
+        project_identifier: FQN,
         from_stage: str,
         configuration: str | None = None,
         variables: List[str] | None = None,
@@ -33,64 +87,97 @@ class DCMProjectManager(SqlExecutionMixin):
         alias: str | None = None,
         output_path: str | None = None,
     ):
+        with self._collect_output(project_identifier, output_path) if (
+            output_path and dry_run
+        ) else nullcontext() as output_stage:
+            query = f"EXECUTE DCM PROJECT {project_identifier.sql_identifier}"
+            if dry_run:
+                query += " PLAN"
+            else:
+                query += " DEPLOY"
+                if alias:
+                    query += f' AS "{alias}"'
+            if configuration or variables:
+                query += f" USING"
+            if configuration:
+                query += f" CONFIGURATION {configuration}"
+            if variables:
+                query += StageManager.parse_execute_variables(
+                    parse_key_value_variables(variables)
+                ).removeprefix(" using")
+            stage_path = StagePath.from_stage_str(from_stage)
+            query += f" FROM {stage_path.absolute_path()}"
+            if output_stage is not None:
+                query += f" OUTPUT_PATH {output_stage}"
+            result = self.execute_query(query=query)
 
-        query = f"EXECUTE DCM PROJECT {project_name.sql_identifier}"
-        if dry_run:
-            query += " PLAN"
-        else:
-            query += " DEPLOY"
-            if alias:
-                query += f" AS {alias}"
-        if configuration or variables:
-            query += f" USING"
-        if configuration:
-            query += f" CONFIGURATION {configuration}"
-        if variables:
-            query += StageManager.parse_execute_variables(
-                parse_key_value_variables(variables)
-            ).removeprefix(" using")
-        stage_path = StagePath.from_stage_str(from_stage)
-        query += f" FROM {stage_path.absolute_path()}"
-        if output_path:
-            output_stage_path = StagePath.from_stage_str(output_path)
-            query += f" OUTPUT_PATH {output_stage_path.absolute_path()}"
-        return self.execute_query(query=query)
+        return result
 
-    def create(self, project: DCMProjectEntityModel) -> None:
-        query = f"CREATE DCM PROJECT {project.fqn.sql_identifier}"
+    def create(self, project_identifier: FQN) -> None:
+        query = f"CREATE DCM PROJECT {project_identifier.sql_identifier}"
         self.execute_query(query)
 
-    def _create_version(
-        self,
-        project_name: FQN,
-        from_stage: str,
-        alias: str | None = None,
-        comment: str | None = None,
-    ):
-        stage_path = StagePath.from_stage_str(from_stage)
-        query = f"ALTER DCM PROJECT {project_name.identifier} ADD VERSION"
-        if alias:
-            query += f" IF NOT EXISTS {alias}"
-        query += f" FROM {stage_path.absolute_path(at_prefix=True)}"
-        if comment:
-            query += f" COMMENT = '{comment}'"
-        return self.execute_query(query=query)
-
-    def list_versions(self, project_name: FQN):
-        query = f"SHOW VERSIONS IN DCM PROJECT {project_name.identifier}"
+    def list_deployments(self, project_identifier: FQN):
+        query = f"SHOW DEPLOYMENTS IN DCM PROJECT {project_identifier.identifier}"
         return self.execute_query(query=query)
 
     def drop_deployment(
         self,
-        project_name: FQN,
-        version_name: str,
+        project_identifier: FQN,
+        deployment_name: str,
         if_exists: bool = False,
     ):
         """
-        Drops a version from the DCM Project.
+        Drops a deployment from the DCM Project.
         """
-        query = f"ALTER DCM PROJECT {project_name.identifier} DROP VERSION"
+        query = f"ALTER DCM PROJECT {project_identifier.identifier} DROP DEPLOYMENT"
         if if_exists:
             query += " IF EXISTS"
-        query += f" {version_name}"
+        query += f' "{deployment_name}"'
         return self.execute_query(query=query)
+
+    @staticmethod
+    def sync_local_files(
+        project_identifier: FQN, source_directory: str | None = None
+    ) -> str:
+        source_path = (
+            SecurePath(source_directory).resolve()
+            if source_directory
+            else SecurePath.cwd()
+        )
+
+        dcm_manifest_file = source_path / MANIFEST_FILE_NAME
+        if not dcm_manifest_file.exists():
+            raise CliError(
+                f"{MANIFEST_FILE_NAME} was not found in directory {source_path.path}"
+            )
+
+        with dcm_manifest_file.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
+            dcm_manifest = yaml.safe_load(fd)
+            object_type = dcm_manifest.get("type") if dcm_manifest else None
+            if object_type is None:
+                raise CliError(
+                    f"Manifest file type is undefined. Expected {DCM_PROJECT_TYPE}"
+                )
+            if object_type.lower() != DCM_PROJECT_TYPE:
+                raise CliError(
+                    f"Manifest file is defined for type {object_type}. Expected {DCM_PROJECT_TYPE}"
+                )
+
+            definitions = list(dcm_manifest.get("include_definitions", list()))
+            if MANIFEST_FILE_NAME not in definitions:
+                definitions.append(MANIFEST_FILE_NAME)
+
+        with cli_console.phase(f"Uploading definition files"):
+            stage_fqn = FQN.from_resource(
+                ObjectType.DCM_PROJECT, project_identifier, "TMP_STAGE"
+            )
+            sync_artifacts_with_stage(
+                project_paths=ProjectPaths(project_root=source_path.path),
+                stage_root=stage_fqn.identifier,
+                use_temporary_stage=True,
+                artifacts=[PathMapping(src=definition) for definition in definitions],
+                pattern_type=PatternMatchingType.REGEX,
+            )
+
+        return stage_fqn.identifier

snowflake/cli/_plugins/logs/commands.py

@@ -48,6 +48,11 @@ def get_logs(
         "--log-level",
         help="The log level to filter by. If not provided, INFO will be used",
     ),
+    partial_match: bool = typer.Option(
+        False,
+        "--partial",
+        help="Enable partial, case-insensitive matching for object names",
+    ),
     **options,
 ):
     """
@@ -75,6 +80,7 @@ def get_logs(
             refresh_time=refresh_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
         logs = itertools.chain(
             (MessageResult(log.log_message) for logs in logs_stream for log in logs)
@@ -87,6 +93,7 @@ def get_logs(
             to_time=to_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
         logs = (MessageResult(log.log_message) for log in logs_iterable)  # type: ignore
 

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/entities/application_package.py

@@ -1066,7 +1066,10 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
         for version in free_versions:
             last_updated = last_updated_map[version]
-            if not oldest_version or last_updated < oldest_version_last_updated_on:
+            if not oldest_version or (
+                oldest_version_last_updated_on is not None
+                and last_updated < oldest_version_last_updated_on
+            ):
                 oldest_version = version
                 oldest_version_last_updated_on = last_updated
 

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/object/manager.py

@@ -137,3 +137,4 @@ def _handle_create_error_codes(err: Exception) -> None:
                 raise ClickException(f"{err_code} internal server error.")
             case _:
                 raise err
+    raise err

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/commands.py

@@ -151,6 +151,14 @@ AutoResumeOption = OverrideableOption(
     help=_AUTO_RESUME_HELP,
 )
 
+_AUTO_SUSPEND_SECS_HELP = "Number of seconds of inactivity after which the service will be automatically suspended."
+AutoSuspendSecsOption = OverrideableOption(
+    None,
+    "--auto-suspend-secs",
+    help=_AUTO_SUSPEND_SECS_HELP,
+    min=0,
+)
+
 _COMMENT_HELP = "Comment for the service."
 
 add_object_command_aliases(
@@ -217,7 +225,7 @@ def deploy(
     upgrade: bool = typer.Option(
         False,
         "--upgrade",
-        help="Updates the existing service. Can update min_instances, max_instances, query_warehouse, auto_resume, external_access_integrations and comment.",
+        help="Updates the existing service. Can update min_instances, max_instances, query_warehouse, auto_resume, auto_suspend_secs, external_access_integrations and comment.",
     ),
     **options,
 ) -> CommandResult:
@@ -241,6 +249,7 @@ def deploy(
         min_instances=service.min_instances,
         max_instances=max_instances,
         auto_resume=service.auto_resume,
+        auto_suspend_secs=service.auto_suspend_secs,
         external_access_integrations=service.external_access_integrations,
         query_warehouse=service.query_warehouse,
         tags=service.tags,
@@ -529,6 +538,7 @@ def set_property(
     max_instances: Optional[int] = MaxInstancesOption(show_default=False),
     query_warehouse: Optional[str] = QueryWarehouseOption(show_default=False),
     auto_resume: Optional[bool] = AutoResumeOption(default=None, show_default=False),
+    auto_suspend_secs: Optional[int] = AutoSuspendSecsOption(show_default=False),
     external_access_integrations: Optional[List[str]] = typer.Option(
         None,
         "--eai-name",
@@ -546,6 +556,7 @@ def set_property(
         max_instances=max_instances,
         query_warehouse=query_warehouse,
         auto_resume=auto_resume,
+        auto_suspend_secs=auto_suspend_secs,
         external_access_integrations=external_access_integrations,
         comment=comment,
     )
@@ -576,6 +587,12 @@ def unset_property(
         help=f"Reset the AUTO_RESUME property - {_AUTO_RESUME_HELP}",
         show_default=False,
     ),
+    auto_suspend_secs: bool = AutoSuspendSecsOption(
+        default=False,
+        param_decls=["--auto-suspend-secs"],
+        help=f"Reset the AUTO_SUSPEND_SECS property - {_AUTO_SUSPEND_SECS_HELP}",
+        show_default=False,
+    ),
     comment: bool = CommentOption(
         default=False,
         help=f"Reset the COMMENT property - {_COMMENT_HELP}",
@@ -593,6 +610,7 @@ def unset_property(
         max_instances=max_instances,
         query_warehouse=query_warehouse,
         auto_resume=auto_resume,
+        auto_suspend_secs=auto_suspend_secs,
         comment=comment,
     )
     return SingleQueryResult(cursor)

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

@@ -114,6 +114,7 @@ class ServiceManager(SqlExecutionMixin):
         min_instances: int,
         max_instances: int,
         auto_resume: bool,
+        auto_suspend_secs: Optional[int],
         external_access_integrations: Optional[List[str]],
         query_warehouse: Optional[str],
         tags: Optional[List[Tag]],
@@ -139,6 +140,7 @@ class ServiceManager(SqlExecutionMixin):
                 max_instances=max_instances,
                 query_warehouse=query_warehouse,
                 auto_resume=auto_resume,
+                auto_suspend_secs=auto_suspend_secs,
                 external_access_integrations=external_access_integrations,
                 comment=comment,
             )
@@ -163,6 +165,9 @@ class ServiceManager(SqlExecutionMixin):
             if max_instances:
                 query.append(f"MAX_INSTANCES = {max_instances}")
 
+            if auto_suspend_secs is not None:
+                query.append(f"AUTO_SUSPEND_SECS = {auto_suspend_secs}")
+
             if query_warehouse:
                 query.append(f"QUERY_WAREHOUSE = {query_warehouse}")
 
@@ -313,11 +318,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)
 
@@ -531,6 +537,7 @@ class ServiceManager(SqlExecutionMixin):
         max_instances: Optional[int],
         query_warehouse: Optional[str],
         auto_resume: Optional[bool],
+        auto_suspend_secs: Optional[int],
         external_access_integrations: Optional[List[str]],
         comment: Optional[str],
     ):
@@ -539,6 +546,7 @@ class ServiceManager(SqlExecutionMixin):
             ("max_instances", max_instances),
             ("query_warehouse", query_warehouse),
             ("auto_resume", auto_resume),
+            ("auto_suspend_secs", auto_suspend_secs),
             ("external_access_integrations", external_access_integrations),
             ("comment", comment),
         ]
@@ -562,6 +570,9 @@ class ServiceManager(SqlExecutionMixin):
         if auto_resume is not None:
             query.append(f" auto_resume = {auto_resume}")
 
+        if auto_suspend_secs is not None:
+            query.append(f" auto_suspend_secs = {auto_suspend_secs}")
+
         if external_access_integrations is not None:
             external_access_integration_list = ",".join(
                 f"{e}" for e in external_access_integrations
@@ -582,6 +593,7 @@ class ServiceManager(SqlExecutionMixin):
         max_instances: bool,
         query_warehouse: bool,
         auto_resume: bool,
+        auto_suspend_secs: bool,
         comment: bool,
     ):
         property_pairs = [
@@ -589,6 +601,7 @@ class ServiceManager(SqlExecutionMixin):
             ("max_instances", max_instances),
             ("query_warehouse", query_warehouse),
             ("auto_resume", auto_resume),
+            ("auto_suspend_secs", auto_suspend_secs),
             ("comment", comment),
         ]
 

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

@@ -30,6 +30,11 @@ class ServiceEntityModel(EntityModelBaseWithArtifacts, ExternalAccessBaseModel):
         title="The service will automatically resume when a service function or ingress is called.",
         default=True,
     )
+    auto_suspend_secs: Optional[int] = Field(
+        title="Number of seconds of inactivity after which the service is automatically suspended.",
+        default=None,
+        ge=0,
+    )
     query_warehouse: Optional[str] = Field(
         title="Warehouse to use if a service container connects to Snowflake to execute a query without explicitly specifying a warehouse to use",
         default=None,

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

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