snowflake-ml-python 1.10.0__tar.gz → 1.11.0__tar.gz

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/CHANGELOG.md

@@ -1,11 +1,31 @@
 # Release History
 
-## 1.10.0
+## 1.11.0
 
 ### Bug Fixes
 
+* ML Job: Fix `Error: Unable to retrieve head IP address` if not all instances start within the timeout.
+* ML Job: Fix `TypeError: SnowflakeCursor.execute() got an unexpected keyword argument '_force_qmark_paramstyle'`
+  when running inside Stored Procedures.
+
+### Behavior Changes
+
+### New Features
+
+* `ModelVersion.create_service()`: Made `image_repo` argument optional. By
+  default it will use a default image repo, which is
+  being rolled out in server version 9.22+.
+* Experiment Tracking (PrPr): Automatically log the model, metrics, and parameters while training Keras models with
+  `snowflake.ml.experiment.callback.keras.SnowflakeKerasCallback`.
+
+## 1.10.0
+
 ### Behavior Changes
 
+* Experiment Tracking (PrPr): The import paths for the auto-logging callbacks have changed to
+  `snowflake.ml.experiment.callback.xgboost.SnowflakeXgboostCallback` and
+  `snowflake.ml.experiment.callback.lightgbm.SnowflakeLightgbmCallback`.
+
 ### New Features
 
 * Registry: add progress bars for `ModelVersion.create_service` and `ModelVersion.log_model`.
@@ -26,13 +46,13 @@
 
 ```python
 from snowflake.ml.experiment import ExperimentTracking
+from snowflake.ml.experiment.callback import SnowflakeXgboostCallback, SnowflakeLightgbmCallback
 
 exp = ExperimentTracking(session=sp_session, database_name="ML", schema_name="PUBLIC")
 
 exp.set_experiment("MY_EXPERIMENT")
 
 # XGBoost
-from snowflake.ml.experiment.callback.xgboost import SnowflakeXgboostCallback
 callback = SnowflakeXgboostCallback(
   exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
 )
@@ -41,7 +61,6 @@ with exp.start_run():
   model.fit(X, y, eval_set=[(X_test, y_test)])
 
 # LightGBM
-from snowflake.ml.experiment.callback.lightgbm import SnowflakeLightgbmCallback
 callback = SnowflakeLightgbmCallback(
   exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
 )

{snowflake_ml_python-1.10.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.10.0
+Version: 1.11.0
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -410,12 +410,32 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.10.0
+## 1.11.0
 
 ### Bug Fixes
 
+* ML Job: Fix `Error: Unable to retrieve head IP address` if not all instances start within the timeout.
+* ML Job: Fix `TypeError: SnowflakeCursor.execute() got an unexpected keyword argument '_force_qmark_paramstyle'`
+  when running inside Stored Procedures.
+
+### Behavior Changes
+
+### New Features
+
+* `ModelVersion.create_service()`: Made `image_repo` argument optional. By
+  default it will use a default image repo, which is
+  being rolled out in server version 9.22+.
+* Experiment Tracking (PrPr): Automatically log the model, metrics, and parameters while training Keras models with
+  `snowflake.ml.experiment.callback.keras.SnowflakeKerasCallback`.
+
+## 1.10.0
+
 ### Behavior Changes
 
+* Experiment Tracking (PrPr): The import paths for the auto-logging callbacks have changed to
+  `snowflake.ml.experiment.callback.xgboost.SnowflakeXgboostCallback` and
+  `snowflake.ml.experiment.callback.lightgbm.SnowflakeLightgbmCallback`.
+
 ### New Features
 
 * Registry: add progress bars for `ModelVersion.create_service` and `ModelVersion.log_model`.
@@ -436,13 +456,13 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ```python
 from snowflake.ml.experiment import ExperimentTracking
+from snowflake.ml.experiment.callback import SnowflakeXgboostCallback, SnowflakeLightgbmCallback
 
 exp = ExperimentTracking(session=sp_session, database_name="ML", schema_name="PUBLIC")
 
 exp.set_experiment("MY_EXPERIMENT")
 
 # XGBoost
-from snowflake.ml.experiment.callback.xgboost import SnowflakeXgboostCallback
 callback = SnowflakeXgboostCallback(
   exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
 )
@@ -451,7 +471,6 @@ with exp.start_run():
   model.fit(X, y, eval_set=[(X_test, y_test)])
 
 # LightGBM
-from snowflake.ml.experiment.callback.lightgbm import SnowflakeLightgbmCallback
 callback = SnowflakeLightgbmCallback(
   exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
 )

snowflake_ml_python-1.11.0/snowflake/ml/experiment/callback/keras.py

@@ -0,0 +1,63 @@
+import json
+from typing import TYPE_CHECKING, Any, Optional
+from warnings import warn
+
+import keras
+
+from snowflake.ml.experiment import utils
+
+if TYPE_CHECKING:
+    from snowflake.ml.experiment.experiment_tracking import ExperimentTracking
+    from snowflake.ml.model.model_signature import ModelSignature
+
+
+class SnowflakeKerasCallback(keras.callbacks.Callback):
+    def __init__(
+        self,
+        experiment_tracking: "ExperimentTracking",
+        log_model: bool = True,
+        log_metrics: bool = True,
+        log_params: bool = True,
+        log_every_n_epochs: int = 1,
+        model_name: Optional[str] = None,
+        model_signature: Optional["ModelSignature"] = None,
+    ) -> None:
+        self._experiment_tracking = experiment_tracking
+        self.log_model = log_model
+        self.log_metrics = log_metrics
+        self.log_params = log_params
+        if log_every_n_epochs < 1:
+            raise ValueError("`log_every_n_epochs` must be positive.")
+        self.log_every_n_epochs = log_every_n_epochs
+        self.model_name = model_name
+        self.model_signature = model_signature
+
+    def on_train_begin(self, logs: Optional[dict[str, Any]] = None) -> None:
+        if self.log_params:
+            params = json.loads(self.model.to_json())
+            self._experiment_tracking.log_params(utils.flatten_nested_params(params))
+
+    def on_epoch_end(self, epoch: int, logs: Optional[dict[str, Any]] = None) -> None:
+        if self.log_metrics and logs and epoch % self.log_every_n_epochs == 0:
+            for key, value in logs.items():
+                try:
+                    value = float(value)
+                except Exception:
+                    pass
+                else:
+                    self._experiment_tracking.log_metric(key=key, value=value, step=epoch)
+
+    def on_train_end(self, logs: Optional[dict[str, Any]] = None) -> None:
+        if self.log_model:
+            if not self.model_signature:
+                warn(
+                    "Model will not be logged because model signature is missing. "
+                    "To autolog the model, please specify `model_signature` when constructing SnowflakeKerasCallback."
+                )
+                return
+            model_name = self.model_name or self._experiment_tracking._get_or_set_experiment().name + "_model"
+            self._experiment_tracking.log_model(  # type: ignore[call-arg]
+                model=self.model,
+                model_name=model_name,
+                signatures={"predict": self.model_signature},
+            )

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/experiment/callback/lightgbm.py

@@ -15,6 +15,7 @@ class SnowflakeLightgbmCallback(lgb.callback._RecordEvaluationCallback):
         log_model: bool = True,
         log_metrics: bool = True,
         log_params: bool = True,
+        log_every_n_epochs: int = 1,
         model_name: Optional[str] = None,
         model_signature: Optional["ModelSignature"] = None,
     ) -> None:
@@ -22,6 +23,9 @@ class SnowflakeLightgbmCallback(lgb.callback._RecordEvaluationCallback):
         self.log_model = log_model
         self.log_metrics = log_metrics
         self.log_params = log_params
+        if log_every_n_epochs < 1:
+            raise ValueError("`log_every_n_epochs` must be positive.")
+        self.log_every_n_epochs = log_every_n_epochs
         self.model_name = model_name
         self.model_signature = model_signature
 
@@ -32,7 +36,7 @@ class SnowflakeLightgbmCallback(lgb.callback._RecordEvaluationCallback):
             if env.iteration == env.begin_iteration:  # Log params only at the first iteration
                 self._experiment_tracking.log_params(env.params)
 
-        if self.log_metrics:
+        if self.log_metrics and env.iteration % self.log_every_n_epochs == 0:
             super().__call__(env)
             for dataset_name, metrics in self.eval_result.items():
                 for metric_name, log in metrics.items():

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/experiment/callback/xgboost.py

@@ -18,6 +18,7 @@ class SnowflakeXgboostCallback(xgb.callback.TrainingCallback):
         log_model: bool = True,
         log_metrics: bool = True,
         log_params: bool = True,
+        log_every_n_epochs: int = 1,
         model_name: Optional[str] = None,
         model_signature: Optional["ModelSignature"] = None,
     ) -> None:
@@ -25,6 +26,9 @@ class SnowflakeXgboostCallback(xgb.callback.TrainingCallback):
         self.log_model = log_model
         self.log_metrics = log_metrics
         self.log_params = log_params
+        if log_every_n_epochs < 1:
+            raise ValueError("`log_every_n_epochs` must be positive.")
+        self.log_every_n_epochs = log_every_n_epochs
         self.model_name = model_name
         self.model_signature = model_signature
 
@@ -36,7 +40,7 @@ class SnowflakeXgboostCallback(xgb.callback.TrainingCallback):
         return model
 
     def after_iteration(self, model: Any, epoch: int, evals_log: dict[str, dict[str, Any]]) -> bool:
-        if self.log_metrics:
+        if self.log_metrics and epoch % self.log_every_n_epochs == 0:
             for dataset_name, metrics in evals_log.items():
                 for metric_name, log in metrics.items():
                     metric_key = dataset_name + ":" + metric_name

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/constants.py

@@ -28,7 +28,7 @@ OUTPUT_MOUNT_PATH = f"{STAGE_VOLUME_MOUNT_PATH}/{OUTPUT_STAGE_SUBPATH}"
 DEFAULT_IMAGE_REPO = "/snowflake/images/snowflake_images"
 DEFAULT_IMAGE_CPU = "st_plat/runtime/x86/runtime_image/snowbooks"
 DEFAULT_IMAGE_GPU = "st_plat/runtime/x86/generic_gpu/runtime_image/snowbooks"
-DEFAULT_IMAGE_TAG = "1.5.0"
+DEFAULT_IMAGE_TAG = "1.6.2"
 DEFAULT_ENTRYPOINT_PATH = "func.py"
 
 # Percent of container memory to allocate for /dev/shm volume
@@ -98,3 +98,6 @@ CLOUD_INSTANCE_FAMILIES = {
     SnowflakeCloudType.AWS: AWS_INSTANCE_FAMILIES,
     SnowflakeCloudType.AZURE: AZURE_INSTANCE_FAMILIES,
 }
+
+# runtime version environment variable
+ENABLE_IMAGE_VERSION_ENV_VAR = "MLRS_ENABLE_RUNTIME_VERSIONS"

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/payload_utils.py

@@ -1,4 +1,5 @@
 import functools
+import importlib
 import inspect
 import io
 import itertools
@@ -7,6 +8,7 @@ import logging
 import pickle
 import sys
 import textwrap
+from importlib.abc import Traversable
 from pathlib import Path, PurePath
 from typing import Any, Callable, Optional, Union, cast, get_args, get_origin
 
@@ -262,11 +264,24 @@ def upload_payloads(session: snowpark.Session, stage_path: PurePath, *payload_sp
                 # Manually traverse the directory and upload each file, since Snowflake PUT
                 # can't handle directories. Reduce the number of PUT operations by using
                 # wildcard patterns to batch upload files with the same extension.
-                for path in {
-                    p.parent.joinpath(f"*{p.suffix}") if p.suffix else p
-                    for p in source_path.resolve().rglob("*")
-                    if p.is_file()
-                }:
+                upload_path_patterns = set()
+                for p in source_path.resolve().rglob("*"):
+                    if p.is_dir():
+                        continue
+                    if p.name.startswith("."):
+                        # Hidden files: use .* pattern for batch upload
+                        if p.suffix:
+                            upload_path_patterns.add(p.parent.joinpath(f".*{p.suffix}"))
+                        else:
+                            upload_path_patterns.add(p.parent.joinpath(".*"))
+                    else:
+                        # Regular files: use * pattern for batch upload
+                        if p.suffix:
+                            upload_path_patterns.add(p.parent.joinpath(f"*{p.suffix}"))
+                        else:
+                            upload_path_patterns.add(p)
+
+                for path in upload_path_patterns:
                     session.file.put(
                         str(path),
                         payload_stage_path.joinpath(path.parent.relative_to(source_path)).as_posix(),
@@ -282,6 +297,27 @@ def upload_payloads(session: snowpark.Session, stage_path: PurePath, *payload_sp
                 )
 
 
+def upload_system_resources(session: snowpark.Session, stage_path: PurePath) -> None:
+    resource_ref = importlib.resources.files(__package__).joinpath("scripts")
+
+    def upload_dir(ref: Traversable, relative_path: str = "") -> None:
+        for item in ref.iterdir():
+            current_path = Path(relative_path) / item.name if relative_path else Path(item.name)
+            if item.is_dir():
+                # Recursively process subdirectories
+                upload_dir(item, str(current_path))
+            elif item.is_file():
+                content = item.read_bytes()
+                session.file.put_stream(
+                    io.BytesIO(content),
+                    stage_path.joinpath(current_path).as_posix(),
+                    auto_compress=False,
+                    overwrite=True,
+                )
+
+    upload_dir(resource_ref)
+
+
 def resolve_source(
     source: Union[types.PayloadPath, Callable[..., Any]]
 ) -> Union[types.PayloadPath, Callable[..., Any]]:
@@ -497,15 +533,7 @@ class JobPayload:
             overwrite=False,  # FIXME
         )
 
-        scripts_dir = Path(__file__).parent.joinpath("scripts")
-        for script_file in scripts_dir.glob("*"):
-            if script_file.is_file():
-                session.file.put(
-                    script_file.as_posix(),
-                    system_stage_path.as_posix(),
-                    overwrite=True,
-                    auto_compress=False,
-                )
+        upload_system_resources(session, system_stage_path)
         python_entrypoint: list[Union[str, PurePath]] = [
             PurePath(f"{constants.SYSTEM_MOUNT_PATH}/mljob_launcher.py"),
             PurePath(f"{constants.APP_MOUNT_PATH}/{entrypoint.file_path.relative_to(source).as_posix()}"),

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/query_helper.py

@@ -4,6 +4,7 @@ from snowflake import snowpark
 from snowflake.snowpark import Row
 from snowflake.snowpark._internal import utils
 from snowflake.snowpark._internal.analyzer import snowflake_plan
+from snowflake.snowpark._internal.utils import is_in_stored_procedure
 
 
 def result_set_to_rows(session: snowpark.Session, result: dict[str, Any]) -> list[Row]:
@@ -14,7 +15,10 @@ def result_set_to_rows(session: snowpark.Session, result: dict[str, Any]) -> lis
 
 @snowflake_plan.SnowflakePlan.Decorator.wrap_exception  # type: ignore[misc]
 def run_query(session: snowpark.Session, query_text: str, params: Optional[Sequence[Any]] = None) -> list[Row]:
-    result = session._conn.run_query(query=query_text, params=params, _force_qmark_paramstyle=True)
+    kwargs: dict[str, Any] = {"query": query_text, "params": params}
+    if not is_in_stored_procedure():  # type: ignore[no-untyped-call]
+        kwargs["_force_qmark_paramstyle"] = True
+    result = session._conn.run_query(**kwargs)
     if not isinstance(result, dict) or "data" not in result:
         raise ValueError(f"Unprocessable result: {result}")
     return result_set_to_rows(session, result)

snowflake_ml_python-1.11.0/snowflake/ml/jobs/_utils/runtime_env_utils.py

@@ -0,0 +1,63 @@
+from typing import Any, Optional, Union
+
+from packaging.version import Version
+from pydantic import BaseModel, Field, RootModel, field_validator
+
+
+class SpcsContainerRuntime(BaseModel):
+    python_version: Version = Field(alias="pythonVersion")
+    hardware_type: str = Field(alias="hardwareType")
+    runtime_container_image: str = Field(alias="runtimeContainerImage")
+
+    @field_validator("python_version", mode="before")
+    @classmethod
+    def validate_python_version(cls, v: Union[str, Version]) -> Version:
+        if isinstance(v, Version):
+            return v
+        try:
+            return Version(v)
+        except Exception:
+            raise ValueError(f"Invalid Python version format: {v}")
+
+    class Config:
+        frozen = True
+        extra = "allow"
+        arbitrary_types_allowed = True
+
+
+class RuntimeEnvironmentEntry(BaseModel):
+    spcs_container_runtime: Optional[SpcsContainerRuntime] = Field(alias="spcsContainerRuntime", default=None)
+
+    class Config:
+        extra = "allow"
+        frozen = True
+
+
+class RuntimeEnvironmentsDict(RootModel[dict[str, RuntimeEnvironmentEntry]]):
+    @field_validator("root", mode="before")
+    @classmethod
+    def _filter_to_dict_entries(cls, data: Any) -> dict[str, dict[str, Any]]:
+        """
+        Pre-validation hook: keep only those items at the root level
+        whose values are dicts. Non-dict values will be dropped.
+
+        Args:
+            data: The input data to filter, expected to be a dictionary.
+
+        Returns:
+            A dictionary containing only the key-value pairs where values are dictionaries.
+
+        Raises:
+            ValueError: If input data is not a dictionary.
+        """
+        # If the entire root is not a dict, raise error immediately
+        if not isinstance(data, dict):
+            raise ValueError(f"Expected dictionary data, but got {type(data).__name__}: {data}")
+
+        # Filter out any key whose value is not a dict
+        return {key: value for key, value in data.items() if isinstance(value, dict)}
+
+    def get_spcs_container_runtimes(self) -> list[SpcsContainerRuntime]:
+        return [
+            entry.spcs_container_runtime for entry in self.root.values() if entry.spcs_container_runtime is not None
+        ]

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/scripts/get_instance_ip.py

@@ -47,8 +47,8 @@ def get_first_instance(service_name: str) -> Optional[tuple[str, str, str]]:
     if not result:
         return None
 
-    # Sort by start_time first, then by instance_id
-    sorted_instances = sorted(result, key=lambda x: (x["start_time"], int(x["instance_id"])))
+    # Sort by start_time first, then by instance_id. If start_time is null/empty, it will be sorted to the end.
+    sorted_instances = sorted(result, key=lambda x: (not bool(x["start_time"]), x["start_time"], int(x["instance_id"])))
     head_instance = sorted_instances[0]
     if not head_instance["instance_id"] or not head_instance["ip_address"]:
         return None

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/scripts/mljob_launcher.py

@@ -173,10 +173,10 @@ def wait_for_instances(
 
     start_time = time.time()
     current_interval = max(min(1, check_interval), 0.1)  # Default 1s, minimum 0.1s
-    logger.debug(
+    logger.info(
         "Waiting for instances to be ready "
-        "(min_instances={}, target_instances={}, timeout={}s, max_check_interval={}s)".format(
-            min_instances, target_instances, timeout, check_interval
+        "(min_instances={}, target_instances={}, min_wait_time={}s, timeout={}s, max_check_interval={}s)".format(
+            min_instances, target_instances, min_wait_time, timeout, check_interval
         )
     )
 

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/spec_utils.py

@@ -1,12 +1,14 @@
 import logging
 import os
+import sys
 from math import ceil
 from pathlib import PurePath
-from typing import Any, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from snowflake import snowpark
 from snowflake.ml._internal.utils import snowflake_env
 from snowflake.ml.jobs._utils import constants, query_helper, types
+from snowflake.ml.jobs._utils.runtime_env_utils import RuntimeEnvironmentsDict
 
 
 def _get_node_resources(session: snowpark.Session, compute_pool: str) -> types.ComputeResources:
@@ -28,22 +30,53 @@ def _get_node_resources(session: snowpark.Session, compute_pool: str) -> types.C
     )
 
 
+def _get_runtime_image(session: snowpark.Session, target_hardware: Literal["CPU", "GPU"]) -> Optional[str]:
+    rows = query_helper.run_query(session, "CALL SYSTEM$NOTEBOOKS_FIND_LABELED_RUNTIMES()")
+    if not rows:
+        return None
+    try:
+        runtime_envs = RuntimeEnvironmentsDict.model_validate_json(rows[0][0])
+        spcs_container_runtimes = runtime_envs.get_spcs_container_runtimes()
+    except Exception as e:
+        logging.warning(f"Failed to parse runtime image name from {rows[0][0]}, error: {e}")
+        return None
+
+    selected_runtime = next(
+        (
+            runtime
+            for runtime in spcs_container_runtimes
+            if (
+                runtime.hardware_type.lower() == target_hardware.lower()
+                and runtime.python_version.major == sys.version_info.major
+                and runtime.python_version.minor == sys.version_info.minor
+            )
+        ),
+        None,
+    )
+    return selected_runtime.runtime_container_image if selected_runtime else None
+
+
 def _get_image_spec(session: snowpark.Session, compute_pool: str) -> types.ImageSpec:
     # Retrieve compute pool node resources
     resources = _get_node_resources(session, compute_pool=compute_pool)
 
     # Use MLRuntime image
-    image_repo = constants.DEFAULT_IMAGE_REPO
-    image_name = constants.DEFAULT_IMAGE_GPU if resources.gpu > 0 else constants.DEFAULT_IMAGE_CPU
-    image_tag = _get_runtime_image_tag()
+    hardware = "GPU" if resources.gpu > 0 else "CPU"
+    container_image = None
+    if os.environ.get(constants.ENABLE_IMAGE_VERSION_ENV_VAR, "").lower() == "true":
+        container_image = _get_runtime_image(session, hardware)  # type: ignore[arg-type]
+
+    if not container_image:
+        image_repo = constants.DEFAULT_IMAGE_REPO
+        image_name = constants.DEFAULT_IMAGE_GPU if resources.gpu > 0 else constants.DEFAULT_IMAGE_CPU
+        image_tag = _get_runtime_image_tag()
+        container_image = f"{image_repo}/{image_name}:{image_tag}"
 
     # TODO: Should each instance consume the entire pod?
     return types.ImageSpec(
-        repo=image_repo,
-        image_name=image_name,
-        image_tag=image_tag,
         resource_requests=resources,
         resource_limits=resources,
+        container_image=container_image,
     )
 
 
@@ -220,7 +253,7 @@ def generate_service_spec(
         "containers": [
             {
                 "name": constants.DEFAULT_CONTAINER_NAME,
-                "image": image_spec.full_name,
+                "image": image_spec.container_image,
                 "command": ["/usr/local/bin/_entrypoint.sh"],
                 "args": [
                     (stage_mount.joinpath(v).as_posix() if isinstance(v, PurePath) else v) for v in payload.entrypoint

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/stage_utils.py

@@ -121,15 +121,28 @@ class StagePath:
         return self._compose_path(self._path)
 
     def joinpath(self, *args: Union[str, PathLike[str]]) -> "StagePath":
+        """
+        Joins the given path arguments to the current path,
+        mimicking the behavior of pathlib.Path.joinpath.
+        If the argument is a stage path (i.e., an absolute path),
+        it overrides the current path and is returned as the final path.
+        If the argument is a normal path, it is joined with the current relative path
+        using self._path.joinpath(arg).
+
+        Args:
+            *args: Path components to join.
+
+        Returns:
+            A new StagePath with the joined path.
+
+        Raises:
+            NotImplementedError: the argument is a stage path.
+        """
         path = self
         for arg in args:
-            path = path._make_child(arg)
+            if isinstance(arg, StagePath):
+                raise NotImplementedError
+            else:
+                # the arg might be an absolute path, so we need to remove the leading '/'
+                path = StagePath(f"{path.root}/{path._path.joinpath(arg).as_posix().lstrip('/')}")
         return path
-
-    def _make_child(self, path: Union[str, PathLike[str]]) -> "StagePath":
-        stage_path = path if isinstance(path, StagePath) else StagePath(os.fspath(path))
-        if self.root == stage_path.root:
-            child_path = self._path.joinpath(stage_path._path)
-            return StagePath(self._compose_path(child_path))
-        else:
-            return stage_path

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/_utils/types.py

@@ -30,6 +30,10 @@ class PayloadPath(Protocol):
     def parent(self) -> "PayloadPath":
         ...
 
+    @property
+    def root(self) -> str:
+        ...
+
     def exists(self) -> bool:
         ...
 
@@ -98,12 +102,6 @@ class ComputeResources:
 
 @dataclass(frozen=True)
 class ImageSpec:
-    repo: str
-    image_name: str
-    image_tag: str
     resource_requests: ComputeResources
     resource_limits: ComputeResources
-
-    @property
-    def full_name(self) -> str:
-        return f"{self.repo}/{self.image_name}:{self.image_tag}"
+    container_image: str

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/job.py

@@ -199,7 +199,7 @@ class MLJob(Generic[T], SerializableSessionMixin):
             elapsed = time.monotonic() - start_time
             if elapsed >= timeout >= 0:
                 raise TimeoutError(f"Job {self.name} did not complete within {timeout} seconds")
-            elif status == "PENDING" and not warning_shown and elapsed >= 2:  # Only show warning after 2s
+            elif status == "PENDING" and not warning_shown and elapsed >= 5:  # Only show warning after 5s
                 pool_info = _get_compute_pool_info(self._session, self._compute_pool)
                 if (pool_info.max_nodes - pool_info.active_nodes) < self.min_instances:
                     logger.warning(

{snowflake_ml_python-1.10.0 → snowflake_ml_python-1.11.0}/snowflake/ml/jobs/manager.py

@@ -426,7 +426,6 @@ def _submit_job(
 
     Raises:
         ValueError: If database or schema value(s) are invalid
-        SnowparkSQLException: If there is an error submitting the job.
     """
     session = session or get_active_session()
 
@@ -504,18 +503,7 @@ def _submit_job(
     query_text, params = _generate_submission_query(
         spec, external_access_integrations, query_warehouse, target_instances, session, compute_pool, job_id
     )
-    try:
-        _ = query_helper.run_query(session, query_text, params=params)
-    except SnowparkSQLException as e:
-        if "Invalid spec: unknown option 'resourceManagement' for 'spec'." in e.message:
-            logger.warning("Dropping 'resourceManagement' from spec because control policy is not enabled.")
-            spec["spec"].pop("resourceManagement", None)
-            query_text, params = _generate_submission_query(
-                spec, external_access_integrations, query_warehouse, target_instances, session, compute_pool, job_id
-            )
-            _ = query_helper.run_query(session, query_text, params=params)
-        else:
-            raise
+    _ = query_helper.run_query(session, query_text, params=params)
     return get_job(job_id, session=session)