snowflake-ml-python 1.17.0__py3-none-any.whl → 1.18.0__py3-none-any.whl

snowflake/ml/feature_store/feature_store.py

@@ -1199,10 +1199,10 @@ class FeatureStore:
         """Get refresh history for online feature table."""
         online_table_name = FeatureView._get_online_table_name(feature_view.name, feature_view.version)
         select_cols = "*" if verbose else "name, state, refresh_start_time, refresh_end_time, refresh_action"
-        prefix = (
-            f"{self._config.database.resolved()}."
-            f"{self._config.schema.resolved()}."
-            f"{online_table_name.resolved()}"
+        name = (
+            f"{self._config.database.identifier()}."
+            f"{self._config.schema.identifier()}."
+            f"{online_table_name.identifier()}"
         )
         return self._session.sql(
             f"""
@@ -1210,9 +1210,8 @@ class FeatureStore:
                 {select_cols}
             FROM TABLE (
                 {self._config.database}.INFORMATION_SCHEMA.ONLINE_FEATURE_TABLE_REFRESH_HISTORY (
-                    NAME_PREFIX => '{prefix}'
+                    NAME => '{name}'
                 )
-
             )
             """
         )
@@ -1591,6 +1590,7 @@ class FeatureStore:
         spine_timestamp_col: Optional[str] = None,
         exclude_columns: Optional[list[str]] = None,
         include_feature_view_timestamp_col: bool = False,
+        join_method: Literal["sequential", "cte"] = "sequential",
     ) -> DataFrame:
         """
         Enrich spine dataframe with feature values. Mainly used to generate inference data input.
@@ -1604,6 +1604,8 @@ class FeatureStore:
             exclude_columns: Column names to exclude from the result dataframe.
             include_feature_view_timestamp_col: Generated dataset will include timestamp column of feature view
                 (if feature view has timestamp column) if set true. Default to false.
+            join_method: Method for feature joins. "sequential" for layer-by-layer joins (default),
+                "cte" for CTE method. (Internal use only - subject to change)
 
         Returns:
             Snowpark DataFrame containing the joined results.
@@ -1641,6 +1643,7 @@ class FeatureStore:
             cast(list[Union[FeatureView, FeatureViewSlice]], features),
             spine_timestamp_col,
             include_feature_view_timestamp_col,
+            join_method,
         )
 
         if exclude_columns is not None:
@@ -1659,6 +1662,7 @@ class FeatureStore:
         spine_label_cols: Optional[list[str]] = None,
         exclude_columns: Optional[list[str]] = None,
         include_feature_view_timestamp_col: bool = False,
+        join_method: Literal["sequential", "cte"] = "sequential",
     ) -> DataFrame:
         """
         Generate a training set from the specified Spine DataFrame and Feature Views. Result is
@@ -1676,6 +1680,8 @@ class FeatureStore:
             exclude_columns: Name of column(s) to exclude from the resulting training set.
             include_feature_view_timestamp_col: Generated dataset will include timestamp column of feature view
                 (if feature view has timestamp column) if set true. Default to false.
+            join_method: Method for feature joins. "sequential" for layer-by-layer joins (default),
+                "cte" for CTE method. (Internal use only - subject to change)
 
         Returns:
             Returns a Snowpark DataFrame representing the training set.
@@ -1709,7 +1715,7 @@ class FeatureStore:
             spine_label_cols = to_sql_identifiers(spine_label_cols)  # type: ignore[assignment]
 
         result_df, join_keys = self._join_features(
-            spine_df, features, spine_timestamp_col, include_feature_view_timestamp_col
+            spine_df, features, spine_timestamp_col, include_feature_view_timestamp_col, join_method
         )
 
         if exclude_columns is not None:
@@ -1757,6 +1763,7 @@ class FeatureStore:
         include_feature_view_timestamp_col: bool = False,
         desc: str = "",
         output_type: Literal["dataset"] = "dataset",
+        join_method: Literal["sequential", "cte"] = "sequential",
     ) -> dataset.Dataset:
         ...
 
@@ -1774,6 +1781,7 @@ class FeatureStore:
         exclude_columns: Optional[list[str]] = None,
         include_feature_view_timestamp_col: bool = False,
         desc: str = "",
+        join_method: Literal["sequential", "cte"] = "sequential",
     ) -> DataFrame:
         ...
 
@@ -1791,6 +1799,7 @@ class FeatureStore:
         include_feature_view_timestamp_col: bool = False,
         desc: str = "",
         output_type: Literal["dataset", "table"] = "dataset",
+        join_method: Literal["sequential", "cte"] = "sequential",
     ) -> Union[dataset.Dataset, DataFrame]:
         """
         Generate dataset by given source table and feature views.
@@ -1811,6 +1820,8 @@ class FeatureStore:
                 (if feature view has timestamp column) if set true. Default to false.
             desc: A description about this dataset.
             output_type: (Deprecated) The type of Snowflake storage to use for the generated training data.
+            join_method: Method for feature joins. "sequential" for layer-by-layer joins (default),
+                "cte" for CTE method. (Internal use only - subject to change)
 
         Returns:
             If output_type is "dataset" (default), returns a Dataset object.
@@ -1874,6 +1885,7 @@ class FeatureStore:
             exclude_columns=exclude_columns,
             include_feature_view_timestamp_col=include_feature_view_timestamp_col,
             save_as=table_name,
+            join_method=join_method,
         )
         if output_type == "table":
             warnings.warn(
@@ -2596,91 +2608,254 @@ class FeatureStore:
         found_rows = self._find_object("TAGS", full_entity_tag_name)
         return len(found_rows) == 1
 
+    def _build_cte_query(
+        self,
+        feature_views: list[FeatureView],
+        feature_columns: list[str],
+        spine_ref: str,
+        spine_timestamp_col: Optional[SqlIdentifier],
+        include_feature_view_timestamp_col: bool = False,
+    ) -> str:
+        """
+        Build a CTE query with the spine query and the feature views.
+
+        This method supports feature views with different join keys by:
+        1. Creating a spine CTE that includes all possible join keys
+        2. Performing ASOF JOINs for each feature view using only its specific join keys when timestamp columns exist
+        3. Performing LEFT JOINs for each feature view when timestamp columns are missing
+        4. Combining results using INNER JOINs on each feature view's specific join keys
+
+        Args:
+            feature_views: A list of feature views to join.
+            feature_columns: A list of feature column strings for each feature view.
+            spine_ref: The spine query.
+            spine_timestamp_col: The timestamp column from spine. Can be None if spine has no timestamp column.
+            include_feature_view_timestamp_col: Whether to include the timestamp column of
+                the feature view in the result. Default to false.
+
+        Note: This method does NOT work when there are duplicate combinations of join keys and timestamp columns
+        in spine.
+
+        Returns:
+            A SQL query string with CTE structure for joining feature views.
+        """
+        if not feature_views:
+            return f"SELECT * FROM ({spine_ref})"
+
+        # Create spine CTE with the spine query for reuse
+        spine_cte = f"""SPINE AS (
+            SELECT * FROM ({spine_ref})
+        )"""
+
+        ctes = [spine_cte]
+        cte_names = []
+        for i, feature_view in enumerate(feature_views):
+            cte_name = f"FV{i:03d}"
+            cte_names.append(cte_name)
+
+            feature_timestamp_col = feature_view.timestamp_col
+
+            # Get the specific join keys for this feature view
+            fv_join_keys = list({k for e in feature_view.entities for k in e.join_keys})
+            join_keys_str = ", ".join(fv_join_keys)
+
+            # Build the JOIN condition using only this feature view's join keys
+            join_conditions = [f'SPINE."{col}" = FEATURE."{col}"' for col in fv_join_keys]
+
+            # Use ASOF JOIN if both spine and feature view have timestamp columns, otherwise use LEFT JOIN
+            if spine_timestamp_col is not None and feature_timestamp_col is not None:
+                if include_feature_view_timestamp_col:
+                    f_ts_col_alias = identifier.concat_names(
+                        [feature_view.name, "_", str(feature_view.version), "_", feature_timestamp_col]
+                    )
+                    f_ts_col_str = f"FEATURE.{feature_timestamp_col} AS {f_ts_col_alias},"
+                else:
+                    f_ts_col_str = ""
+                ctes.append(
+                    f"""{cte_name} AS (
+    SELECT
+        SPINE.*,
+        {f_ts_col_str}
+        FEATURE.* EXCLUDE ({join_keys_str}, {feature_timestamp_col})
+    FROM
+        SPINE
+    ASOF JOIN (
+        SELECT {join_keys_str}, {feature_timestamp_col}, {feature_columns[i]}
+        FROM {feature_view.fully_qualified_name()}
+    ) FEATURE
+    MATCH_CONDITION (SPINE."{spine_timestamp_col}" >= FEATURE."{feature_timestamp_col}")
+    ON {" AND ".join(join_conditions)}
+)"""
+                )
+            else:
+                ctes.append(
+                    f"""{cte_name} AS (
+    SELECT
+        SPINE.*,
+        FEATURE.* EXCLUDE ({join_keys_str})
+    FROM
+        SPINE
+    LEFT JOIN (
+        SELECT {join_keys_str}, {feature_columns[i]}
+        FROM {feature_view.fully_qualified_name()}
+    ) FEATURE
+    ON {" AND ".join(join_conditions)}
+)"""
+                )
+
+        # Build final SELECT with individual joins to each FV CTE
+        select_columns = []
+        join_clauses = []
+
+        for i, cte_name in enumerate(cte_names):
+            feature_view = feature_views[i]
+            fv_join_keys = list({k for e in feature_view.entities for k in e.join_keys})
+            join_conditions = [f'SPINE."{col}" = {cte_name}."{col}"' for col in fv_join_keys]
+            if spine_timestamp_col is not None:
+                join_conditions.append(f'SPINE."{spine_timestamp_col}" = {cte_name}."{spine_timestamp_col}"')
+            if include_feature_view_timestamp_col and feature_view.timestamp_col is not None:
+                f_ts_col_alias = identifier.concat_names(
+                    [feature_view.name, "_", str(feature_view.version), "_", feature_view.timestamp_col]
+                )
+                f_ts_col_str = f"{cte_name}.{f_ts_col_alias} AS {f_ts_col_alias}"
+                select_columns.append(f_ts_col_str)
+            select_columns.append(feature_columns[i])
+            # Create join condition using only this feature view's join keys
+            join_clauses.append(
+                f"""
+    INNER JOIN {cte_name}
+    ON {" AND ".join(join_conditions)}"""
+            )
+
+        query = f"""WITH
+{', '.join(ctes)}
+SELECT
+    SPINE.*,
+    {', '.join(select_columns)}
+FROM SPINE{' '.join(join_clauses)}
+"""
+
+        return query
+
     def _join_features(
         self,
         spine_df: DataFrame,
         features: list[Union[FeatureView, FeatureViewSlice]],
         spine_timestamp_col: Optional[SqlIdentifier],
         include_feature_view_timestamp_col: bool,
+        join_method: Literal["sequential", "cte"] = "sequential",
     ) -> tuple[DataFrame, list[SqlIdentifier]]:
-        for f in features:
-            f = f.feature_view_ref if isinstance(f, FeatureViewSlice) else f
-            if f.status == FeatureViewStatus.DRAFT:
+        # Validate join_method parameter
+        if join_method not in ["sequential", "cte"]:
+            raise ValueError(f"Invalid join_method '{join_method}'. Must be 'sequential' or 'cte'.")
+
+        feature_views: list[FeatureView] = []
+        # Extract column selections for each feature view
+        feature_columns: list[str] = []
+        for feature in features:
+            fv = feature.feature_view_ref if isinstance(feature, FeatureViewSlice) else feature
+            if fv.status == FeatureViewStatus.DRAFT:
                 raise snowml_exceptions.SnowflakeMLException(
                     error_code=error_codes.NOT_FOUND,
-                    original_exception=ValueError(f"FeatureView {f.name} has not been registered."),
+                    original_exception=ValueError(f"FeatureView {fv.name} has not been registered."),
                 )
-            for e in f.entities:
+            for e in fv.entities:
                 for k in e.join_keys:
                     if k not in to_sql_identifiers(spine_df.columns):
                         raise snowml_exceptions.SnowflakeMLException(
                             error_code=error_codes.INVALID_ARGUMENT,
                             original_exception=ValueError(
-                                f"join_key {k} from Entity {e.name} in FeatureView {f.name} is not found in spine_df."
+                                f"join_key {k} from Entity {e.name} in FeatureView {fv.name} "
+                                "is not found in spine_df."
                             ),
                         )
-
+            feature_views.append(fv)
+            if isinstance(feature, FeatureViewSlice):
+                cols = feature.names
+            else:
+                cols = feature.feature_names
+            feature_columns.append(", ".join(col.resolved() for col in cols))
+        # TODO (SNOW-2396184): remove this check and the non-ASOF join path as ASOF join is enabled by default now.
         if self._asof_join_enabled is None:
             self._asof_join_enabled = self._is_asof_join_enabled()
 
         # TODO: leverage Snowpark dataframe for more concise syntax once it supports AsOfJoin
         query = spine_df.queries["queries"][-1]
-        layer = 0
-        for f in features:
-            if isinstance(f, FeatureViewSlice):
-                cols = f.names
-                f = f.feature_view_ref
-            else:
-                cols = f.feature_names
-
-            join_keys = list({k for e in f.entities for k in e.join_keys})
-            join_keys_str = ", ".join(join_keys)
-            assert f.version is not None
-            join_table_name = f.fully_qualified_name()
-
-            if spine_timestamp_col is not None and f.timestamp_col is not None:
-                if self._asof_join_enabled:
-                    if include_feature_view_timestamp_col:
-                        f_ts_col_alias = identifier.concat_names([f.name, "_", f.version, "_", f.timestamp_col])
-                        f_ts_col_str = f"r_{layer}.{f.timestamp_col} AS {f_ts_col_alias},"
+        join_keys: list[SqlIdentifier] = []
+
+        if join_method == "cte":
+
+            logger.info(f"Using the CTE method with {len(features)} feature views")
+
+            query = self._build_cte_query(
+                feature_views,
+                feature_columns,
+                spine_df.queries["queries"][-1],
+                spine_timestamp_col,
+                include_feature_view_timestamp_col,
+            )
+        else:
+            # Use sequential joins layer by layer
+            logger.info(f"Using the sequential join method with {len(features)} feature views")
+            layer = 0
+            for feature in features:
+                if isinstance(feature, FeatureViewSlice):
+                    cols = feature.names
+                    feature = feature.feature_view_ref
+                else:
+                    cols = feature.feature_names
+
+                join_keys = list({k for e in feature.entities for k in e.join_keys})
+                join_keys_str = ", ".join(join_keys)
+                assert feature.version is not None
+                join_table_name = feature.fully_qualified_name()
+
+                if spine_timestamp_col is not None and feature.timestamp_col is not None:
+                    if self._asof_join_enabled:
+                        if include_feature_view_timestamp_col:
+                            f_ts_col_alias = identifier.concat_names(
+                                [feature.name, "_", feature.version, "_", feature.timestamp_col]
+                            )
+                            f_ts_col_str = f"r_{layer}.{feature.timestamp_col} AS {f_ts_col_alias},"
+                        else:
+                            f_ts_col_str = ""
+                        query = f"""
+                            SELECT
+                                l_{layer}.*,
+                                {f_ts_col_str}
+                                r_{layer}.* EXCLUDE ({join_keys_str}, {feature.timestamp_col})
+                            FROM ({query}) l_{layer}
+                            ASOF JOIN (
+                                SELECT {join_keys_str}, {feature.timestamp_col},
+                                    {', '.join(col.resolved() for col in cols)}
+                                FROM {join_table_name}
+                            ) r_{layer}
+                            MATCH_CONDITION (l_{layer}.{spine_timestamp_col} >= r_{layer}.{feature.timestamp_col})
+                            ON {' AND '.join([f'l_{layer}.{k} = r_{layer}.{k}' for k in join_keys])}
+                        """
                     else:
-                        f_ts_col_str = ""
+                        query = self._composed_union_window_join_query(
+                            layer=layer,
+                            s_query=query,
+                            s_ts_col=spine_timestamp_col,
+                            f_df=feature.feature_df,
+                            f_table_name=join_table_name,
+                            f_ts_col=feature.timestamp_col,
+                            join_keys=join_keys,
+                        )
+                else:
                     query = f"""
                         SELECT
                             l_{layer}.*,
-                            {f_ts_col_str}
-                            r_{layer}.* EXCLUDE ({join_keys_str}, {f.timestamp_col})
+                            r_{layer}.* EXCLUDE ({join_keys_str})
                         FROM ({query}) l_{layer}
-                        ASOF JOIN (
-                            SELECT {join_keys_str}, {f.timestamp_col}, {', '.join(cols)}
+                        LEFT JOIN (
+                            SELECT {join_keys_str}, {', '.join(col.resolved() for col in cols)}
                             FROM {join_table_name}
                         ) r_{layer}
-                        MATCH_CONDITION (l_{layer}.{spine_timestamp_col} >= r_{layer}.{f.timestamp_col})
                         ON {' AND '.join([f'l_{layer}.{k} = r_{layer}.{k}' for k in join_keys])}
                     """
-                else:
-                    query = self._composed_union_window_join_query(
-                        layer=layer,
-                        s_query=query,
-                        s_ts_col=spine_timestamp_col,
-                        f_df=f.feature_df,
-                        f_table_name=join_table_name,
-                        f_ts_col=f.timestamp_col,
-                        join_keys=join_keys,
-                    )
-            else:
-                query = f"""
-                    SELECT
-                        l_{layer}.*,
-                        r_{layer}.* EXCLUDE ({join_keys_str})
-                    FROM ({query}) l_{layer}
-                    LEFT JOIN (
-                        SELECT {join_keys_str}, {', '.join(cols)}
-                        FROM {join_table_name}
-                    ) r_{layer}
-                    ON {' AND '.join([f'l_{layer}.{k} = r_{layer}.{k}' for k in join_keys])}
-                """
-            layer += 1
+                layer += 1
 
         # TODO: construct result dataframe with datframe APIs once ASOF join is supported natively.
         # Below code manually construct result dataframe from private members of spine dataframe, which

snowflake/ml/jobs/_utils/constants.py

@@ -56,8 +56,9 @@ ENABLE_HEALTH_CHECKS_ENV_VAR = "ENABLE_HEALTH_CHECKS"
 ENABLE_HEALTH_CHECKS = "false"
 
 # Job status polling constants
-JOB_POLL_INITIAL_DELAY_SECONDS = 0.1
+JOB_POLL_INITIAL_DELAY_SECONDS = 5
 JOB_POLL_MAX_DELAY_SECONDS = 30
+JOB_SPCS_TIMEOUT_SECONDS = 30
 
 # Log start and end messages
 LOG_START_MSG = "--------------------------------\nML job started\n--------------------------------"
@@ -73,6 +74,7 @@ COMMON_INSTANCE_FAMILIES = {
     "CPU_X64_XS": ComputeResources(cpu=1, memory=6),
     "CPU_X64_S": ComputeResources(cpu=3, memory=13),
     "CPU_X64_M": ComputeResources(cpu=6, memory=28),
+    "CPU_X64_SL": ComputeResources(cpu=14, memory=54),
     "CPU_X64_L": ComputeResources(cpu=28, memory=116),
     "HIGHMEM_X64_S": ComputeResources(cpu=6, memory=58),
 }
@@ -85,6 +87,7 @@ AWS_INSTANCE_FAMILIES = {
 }
 AZURE_INSTANCE_FAMILIES = {
     "HIGHMEM_X64_M": ComputeResources(cpu=28, memory=244),
+    "HIGHMEM_X64_SL": ComputeResources(cpu=92, memory=654),
     "HIGHMEM_X64_L": ComputeResources(cpu=92, memory=654),
     "GPU_NV_XS": ComputeResources(cpu=3, memory=26, gpu=1, gpu_type="T4"),
     "GPU_NV_SM": ComputeResources(cpu=32, memory=424, gpu=1, gpu_type="A10"),
@@ -92,7 +95,15 @@ AZURE_INSTANCE_FAMILIES = {
     "GPU_NV_3M": ComputeResources(cpu=44, memory=424, gpu=2, gpu_type="A100"),
     "GPU_NV_SL": ComputeResources(cpu=92, memory=858, gpu=4, gpu_type="A100"),
 }
+GCP_INSTANCE_FAMILIES = {
+    "HIGHMEM_X64_M": ComputeResources(cpu=28, memory=244),
+    "HIGHMEM_X64_SL": ComputeResources(cpu=92, memory=654),
+    "GPU_GCP_NV_L4_1_24G": ComputeResources(cpu=6, memory=28, gpu=1, gpu_type="L4"),
+    "GPU_GCP_NV_L4_4_24G": ComputeResources(cpu=44, memory=178, gpu=4, gpu_type="L4"),
+    "GPU_GCP_NV_A100_8_40G": ComputeResources(cpu=92, memory=654, gpu=8, gpu_type="A100"),
+}
 CLOUD_INSTANCE_FAMILIES = {
     SnowflakeCloudType.AWS: AWS_INSTANCE_FAMILIES,
     SnowflakeCloudType.AZURE: AZURE_INSTANCE_FAMILIES,
+    SnowflakeCloudType.GCP: GCP_INSTANCE_FAMILIES,
 }

snowflake/ml/jobs/_utils/payload_utils.py

@@ -488,10 +488,13 @@ class JobPayload:
                 " comment = 'Created by snowflake.ml.jobs Python API'",
                 params=[stage_name],
             )
-
+        payload_name = None
         # Upload payload to stage - organize into app/ subdirectory
         app_stage_path = stage_path.joinpath(constants.APP_STAGE_SUBPATH)
         if not isinstance(source, types.PayloadPath):
+            if isinstance(source, function_payload_utils.FunctionPayload):
+                payload_name = source.function.__name__
+
             source_code = generate_python_code(source, source_code_display=True)
             _ = session.file.put_stream(
                 io.BytesIO(source_code.encode()),
@@ -502,12 +505,14 @@ class JobPayload:
             source = Path(entrypoint.file_path.parent)
 
         elif isinstance(source, stage_utils.StagePath):
+            payload_name = entrypoint.file_path.stem
             # copy payload to stage
             if source == entrypoint.file_path:
                 source = source.parent
             upload_payloads(session, app_stage_path, types.PayloadSpec(source, None))
 
         elif isinstance(source, Path):
+            payload_name = entrypoint.file_path.stem
             upload_payloads(session, app_stage_path, types.PayloadSpec(source, None))
             if source.is_file():
                 source = source.parent
@@ -562,6 +567,7 @@ class JobPayload:
                 *python_entrypoint,
             ],
             env_vars=env_vars,
+            payload_name=payload_name,
         )
 
 

snowflake/ml/jobs/_utils/stage_utils.py

@@ -32,6 +32,10 @@ class StagePath:
         self._root = self._raw_path[0:start].rstrip("/") if relpath else self._raw_path.rstrip("/")
         self._path = Path(relpath or "")
 
+    @property
+    def stem(self) -> str:
+        return self._path.stem
+
     @property
     def parts(self) -> tuple[str, ...]:
         return self._path.parts

snowflake/ml/jobs/_utils/types.py

@@ -23,6 +23,10 @@ class PayloadPath(Protocol):
     def name(self) -> str:
         ...
 
+    @property
+    def stem(self) -> str:
+        ...
+
     @property
     def suffix(self) -> str:
         ...
@@ -92,6 +96,7 @@ class UploadedPayload:
     stage_path: PurePath
     entrypoint: list[Union[str, PurePath]]
     env_vars: dict[str, str] = field(default_factory=dict)
+    payload_name: Optional[str] = None
 
 
 @dataclass(frozen=True)

snowflake/ml/jobs/job.py

@@ -120,7 +120,7 @@ class MLJob(Generic[T], SerializableSessionMixin):
         """Get the job's result file location."""
         result_path_str = self._container_spec["env"].get(constants.RESULT_PATH_ENV_VAR)
         if result_path_str is None:
-            raise RuntimeError(f"Job {self.name} doesn't have a result path configured")
+            raise NotImplementedError(f"Job {self.name} doesn't have a result path configured")
 
         return self._transform_path(result_path_str)
 
@@ -229,8 +229,22 @@ class MLJob(Generic[T], SerializableSessionMixin):
         Raises:
             TimeoutError: If the job does not complete within the specified timeout.
         """
-        delay = constants.JOB_POLL_INITIAL_DELAY_SECONDS  # Start with 100ms delay
         start_time = time.monotonic()
+        try:
+            # spcs_wait_for() is a synchronous query, it’s more effective to do polling with exponential
+            # backoff. If the job is running for a long time. We want a hybrid option: use spcs_wait_for()
+            # for the first 30 seconds, then switch to polling for long running jobs
+            min_timeout = (
+                int(min(timeout, constants.JOB_SPCS_TIMEOUT_SECONDS))
+                if timeout >= 0
+                else constants.JOB_SPCS_TIMEOUT_SECONDS
+            )
+            query_helper.run_query(self._session, f"call {self.id}!spcs_wait_for('DONE', {min_timeout})")
+            return self.status
+        except SnowparkSQLException:
+            # if the function does not support for this environment
+            pass
+        delay: float = float(constants.JOB_POLL_INITIAL_DELAY_SECONDS)  # Start with 5s delay
         warning_shown = False
         while (status := self.status) not in TERMINAL_JOB_STATUSES:
             elapsed = time.monotonic() - start_time

snowflake/ml/jobs/manager.py

@@ -697,10 +697,21 @@ def _do_submit_job_v2(
         "MIN_INSTANCES": min_instances,
         "ASYNC": use_async,
     }
+    if payload.payload_name:
+        job_options["GENERATE_SUFFIX"] = True
     job_options = {k: v for k, v in job_options.items() if v is not None}
 
     query_template = "CALL SYSTEM$EXECUTE_ML_JOB(?, ?, ?, ?)"
-    params = [job_id, compute_pool, json.dumps(spec_options), json.dumps(job_options)]
+    if job_id:
+        database, schema, _ = identifier.parse_schema_level_object_identifier(job_id)
+    params = [
+        job_id
+        if payload.payload_name is None
+        else identifier.get_schema_level_object_identifier(database, schema, payload.payload_name) + "_",
+        compute_pool,
+        json.dumps(spec_options),
+        json.dumps(job_options),
+    ]
     actual_job_id = query_helper.run_query(session, query_template, params=params)[0][0]
 
     return get_job(actual_job_id, session=session)

snowflake/ml/model/__init__.py

@@ -1,3 +1,6 @@
+import sys
+import warnings
+
 from snowflake.ml.model._client.model.batch_inference_specs import (
     JobSpec,
     OutputSpec,
@@ -18,3 +21,19 @@ __all__ = [
     "SaveMode",
     "Volatility",
 ]
+
+_deprecation_warning_msg_for_3_9 = (
+    "Python 3.9 is deprecated in snowflake-ml-python. " "Please upgrade to Python 3.10 or greater."
+)
+
+warnings.filterwarnings(
+    "once",
+    message=_deprecation_warning_msg_for_3_9,
+)
+
+if sys.version_info.major == 3 and sys.version_info.minor == 9:
+    warnings.warn(
+        _deprecation_warning_msg_for_3_9,
+        category=DeprecationWarning,
+        stacklevel=2,
+    )