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

snowflake/ml/jobs/job.py

@@ -12,12 +12,19 @@ from snowflake import snowpark
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import identifier
 from snowflake.ml._internal.utils.mixins import SerializableSessionMixin
-from snowflake.ml.jobs._utils import constants, interop_utils, query_helper, types
+from snowflake.ml.jobs._interop import results as interop_result, utils as interop_utils
+from snowflake.ml.jobs._utils import (
+    constants,
+    payload_utils,
+    query_helper,
+    stage_utils,
+    types,
+)
 from snowflake.snowpark import Row, context as sp_context
 from snowflake.snowpark.exceptions import SnowparkSQLException
 
 _PROJECT = "MLJob"
-TERMINAL_JOB_STATUSES = {"FAILED", "DONE", "CANCELLED", "INTERNAL_ERROR"}
+TERMINAL_JOB_STATUSES = {"FAILED", "DONE", "CANCELLED", "INTERNAL_ERROR", "DELETED"}
 
 T = TypeVar("T")
 
@@ -36,7 +43,12 @@ class MLJob(Generic[T], SerializableSessionMixin):
         self._session = session or sp_context.get_active_session()
 
         self._status: types.JOB_STATUS = "PENDING"
-        self._result: Optional[interop_utils.ExecutionResult] = None
+        self._result: Optional[interop_result.ExecutionResult] = None
+
+    @cached_property
+    def _service_info(self) -> types.ServiceInfo:
+        """Get the job's service info."""
+        return _resolve_service_info(self.id, self._session)
 
     @cached_property
     def name(self) -> str:
@@ -44,7 +56,7 @@ class MLJob(Generic[T], SerializableSessionMixin):
 
     @cached_property
     def target_instances(self) -> int:
-        return _get_target_instances(self._session, self.id)
+        return self._service_info.target_instances
 
     @cached_property
     def min_instances(self) -> int:
@@ -69,8 +81,7 @@ class MLJob(Generic[T], SerializableSessionMixin):
     @cached_property
     def _compute_pool(self) -> str:
         """Get the job's compute pool name."""
-        row = _get_service_info(self._session, self.id)
-        return cast(str, row["compute_pool"])
+        return self._service_info.compute_pool
 
     @property
     def _service_spec(self) -> dict[str, Any]:
@@ -82,7 +93,13 @@ class MLJob(Generic[T], SerializableSessionMixin):
     @property
     def _container_spec(self) -> dict[str, Any]:
         """Get the job's main container spec."""
-        containers = self._service_spec["spec"]["containers"]
+        try:
+            containers = self._service_spec["spec"]["containers"]
+        except SnowparkSQLException as e:
+            if e.sql_error_code == 2003:
+                # If the job is deleted, the service spec is not available
+                return {}
+            raise
         if len(containers) == 1:
             return cast(dict[str, Any], containers[0])
         try:
@@ -105,22 +122,28 @@ class MLJob(Generic[T], SerializableSessionMixin):
         if result_path_str is None:
             raise RuntimeError(f"Job {self.name} doesn't have a result path configured")
 
-        # If result path is relative, it is relative to the stage mount path
-        result_path = Path(result_path_str)
-        if not result_path.is_absolute():
-            return f"{self._stage_path}/{result_path.as_posix()}"
+        return self._transform_path(result_path_str)
 
-        # If result path is absolute, it is relative to the stage mount path
+    def _transform_path(self, path_str: str) -> str:
+        """Transform a local path within the container to a stage path."""
+        path = payload_utils.resolve_path(path_str)
+        if isinstance(path, stage_utils.StagePath):
+            # Stage paths need no transformation
+            return path.as_posix()
+        if not path.is_absolute():
+            # Assume relative paths are relative to stage mount path
+            return f"{self._stage_path}/{path.as_posix()}"
+
+        # If result path is absolute, rebase it onto the stage mount path
+        # TODO: Rather than matching by name, use the longest mount path which matches
         volume_mounts = self._container_spec["volumeMounts"]
         stage_mount_str = next(v for v in volume_mounts if v.get("name") == constants.STAGE_VOLUME_NAME)["mountPath"]
         stage_mount = Path(stage_mount_str)
         try:
-            relative_path = result_path.relative_to(stage_mount)
+            relative_path = path.relative_to(stage_mount)
             return f"{self._stage_path}/{relative_path.as_posix()}"
         except ValueError:
-            raise ValueError(
-                f"Result path {result_path} is absolute, but should be relative to stage mount {stage_mount}"
-            )
+            raise ValueError(f"Result path {path} is absolute, but should be relative to stage mount {stage_mount}")
 
     @overload
     def get_logs(
@@ -165,7 +188,14 @@ class MLJob(Generic[T], SerializableSessionMixin):
         Returns:
             The job's execution logs.
         """
-        logs = _get_logs(self._session, self.id, limit, instance_id, self._container_spec["name"], verbose)
+        logs = _get_logs(
+            self._session,
+            self.id,
+            limit,
+            instance_id,
+            self._container_spec["name"] if "name" in self._container_spec else constants.DEFAULT_CONTAINER_NAME,
+            verbose,
+        )
         assert isinstance(logs, str)  # mypy
         if as_list:
             return logs.splitlines()
@@ -218,7 +248,6 @@ class MLJob(Generic[T], SerializableSessionMixin):
             delay = min(delay * 1.2, constants.JOB_POLL_MAX_DELAY_SECONDS)  # Exponential backoff
         return self.status
 
-    @snowpark._internal.utils.private_preview(version="1.8.2")
     @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["timeout"])
     def result(self, timeout: float = -1) -> T:
         """
@@ -237,13 +266,13 @@ class MLJob(Generic[T], SerializableSessionMixin):
         if self._result is None:
             self.wait(timeout)
             try:
-                self._result = interop_utils.fetch_result(self._session, self._result_path)
+                self._result = interop_utils.load_result(
+                    self._result_path, session=self._session, path_transform=self._transform_path
+                )
             except Exception as e:
-                raise RuntimeError(f"Failed to retrieve result for job (id={self.name})") from e
+                raise RuntimeError(f"Failed to retrieve result for job, error: {e!r}") from e
 
-        if self._result.success:
-            return cast(T, self._result.result)
-        raise RuntimeError(f"Job execution failed (id={self.name})") from self._result.exception
+        return cast(T, self._result.get_value())
 
     @telemetry.send_api_usage_telemetry(project=_PROJECT)
     def cancel(self) -> None:
@@ -256,22 +285,28 @@ class MLJob(Generic[T], SerializableSessionMixin):
             self._session.sql(f"CALL {self.id}!spcs_cancel_job()").collect()
             logger.debug(f"Cancellation requested for job {self.id}")
         except SnowparkSQLException as e:
-            raise RuntimeError(f"Failed to cancel job {self.id}: {e.message}") from e
+            raise RuntimeError(f"Failed to cancel job, error: {e!r}") from e
 
 
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["job_id", "instance_id"])
 def _get_status(session: snowpark.Session, job_id: str, instance_id: Optional[int] = None) -> types.JOB_STATUS:
     """Retrieve job or job instance execution status."""
-    if instance_id is not None:
-        # Get specific instance status
-        rows = session.sql("SHOW SERVICE INSTANCES IN SERVICE IDENTIFIER(?)", params=(job_id,)).collect()
-        for row in rows:
-            if row["instance_id"] == str(instance_id):
-                return cast(types.JOB_STATUS, row["status"])
-        raise ValueError(f"Instance {instance_id} not found in job {job_id}")
-    else:
-        row = _get_service_info(session, job_id)
-        return cast(types.JOB_STATUS, row["status"])
+    try:
+        if instance_id is not None:
+            # Get specific instance status
+            rows = query_helper.run_query(session, "SHOW SERVICE INSTANCES IN SERVICE IDENTIFIER(?)", params=(job_id,))
+            for row in rows:
+                if row["instance_id"] == str(instance_id):
+                    return cast(types.JOB_STATUS, row["status"])
+            raise ValueError(f"Instance {instance_id} not found in job {job_id}")
+        else:
+            row = _get_service_info(session, job_id)
+            return cast(types.JOB_STATUS, row["status"])
+    except SnowparkSQLException as e:
+        if e.sql_error_code == 2003:
+            row = _get_service_info_spcs(session, job_id)
+            return cast(types.JOB_STATUS, row["STATUS"])
+        raise
 
 
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["job_id"])
@@ -542,8 +577,21 @@ def _get_compute_pool_info(session: snowpark.Session, compute_pool: str) -> Row:
 
 @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["job_id"])
 def _get_target_instances(session: snowpark.Session, job_id: str) -> int:
-    row = _get_service_info(session, job_id)
-    return int(row["target_instances"])
+    try:
+        row = _get_service_info(session, job_id)
+        return int(row["target_instances"])
+    except SnowparkSQLException as e:
+        if e.sql_error_code == 2003:
+            row = _get_service_info_spcs(session, job_id)
+            try:
+                params = json.loads(row["PARAMETERS"])
+                if isinstance(params, dict):
+                    return int(params.get("REPLICAS", 1))
+                else:
+                    return 1
+            except (json.JSONDecodeError, ValueError):
+                return 1
+        raise
 
 
 def _get_logs_spcs(
@@ -581,3 +629,87 @@ def _get_logs_spcs(
         query.append(f" LIMIT {limit};")
     rows = session.sql("\n".join(query)).collect()
     return rows
+
+
+def _get_service_info_spcs(session: snowpark.Session, job_id: str) -> Any:
+    """
+    Retrieve the service info from the SPCS interface.
+
+    Args:
+        session (Session): The Snowpark session to use.
+        job_id (str): The job ID.
+
+    Returns:
+        Any: The service info.
+
+    Raises:
+        SnowparkSQLException: If the job does not exist or is too old to retrieve.
+    """
+    db, schema, name = identifier.parse_schema_level_object_identifier(job_id)
+    db = db or session.get_current_database()
+    schema = schema or session.get_current_schema()
+    rows = query_helper.run_query(
+        session,
+        """
+        select DATABASE_NAME, SCHEMA_NAME, NAME, STATUS, COMPUTE_POOL_NAME, PARAMETERS
+        from table(snowflake.spcs.get_job_history())
+        where database_name = ? and schema_name = ? and name = ?
+        """,
+        params=(db, schema, name),
+    )
+    if rows:
+        return rows[0]
+    else:
+        raise SnowparkSQLException(f"Job {job_id} does not exist or could not be retrieved", sql_error_code=2003)
+
+
+def _resolve_service_info(id: str, session: snowpark.Session) -> types.ServiceInfo:
+    try:
+        row = _get_service_info(session, id)
+    except SnowparkSQLException as e:
+        if e.sql_error_code == 2003:
+            row = _get_service_info_spcs(session, id)
+        else:
+            raise
+    if not row:
+        raise SnowparkSQLException(f"Job {id} does not exist or could not be retrieved", sql_error_code=2003)
+
+    if "compute_pool" in row:
+        compute_pool = row["compute_pool"]
+    elif "COMPUTE_POOL_NAME" in row:
+        compute_pool = row["COMPUTE_POOL_NAME"]
+    else:
+        raise ValueError(f"compute_pool not found in row: {row}")
+
+    if "status" in row:
+        status = row["status"]
+    elif "STATUS" in row:
+        status = row["STATUS"]
+    else:
+        raise ValueError(f"status not found in row: {row}")
+    # Normalize target_instances
+    target_instances: int
+    if "target_instances" in row and row["target_instances"] is not None:
+        try:
+            target_instances = int(row["target_instances"])
+        except (ValueError, TypeError):
+            target_instances = 1
+    elif "PARAMETERS" in row and row["PARAMETERS"]:
+        try:
+            params = json.loads(row["PARAMETERS"])
+            target_instances = int(params.get("REPLICAS", 1)) if isinstance(params, dict) else 1
+        except (json.JSONDecodeError, ValueError, TypeError):
+            target_instances = 1
+    else:
+        target_instances = 1
+
+    database_name = row["database_name"] if "database_name" in row else row["DATABASE_NAME"]
+    schema_name = row["schema_name"] if "schema_name" in row else row["SCHEMA_NAME"]
+
+    return types.ServiceInfo(
+        database_name=database_name,
+        schema_name=schema_name,
+        status=cast(types.JOB_STATUS, status),
+        compute_pool=cast(str, compute_pool),
+        target_instances=target_instances,
+    )

snowflake/ml/jobs/manager.py

@@ -21,6 +21,7 @@ from snowflake.ml.jobs._utils import (
     spec_utils,
     types,
 )
+from snowflake.snowpark._internal import utils as sp_utils
 from snowflake.snowpark.context import get_active_session
 from snowflake.snowpark.exceptions import SnowparkSQLException
 from snowflake.snowpark.functions import coalesce, col, lit, when
@@ -179,8 +180,10 @@ def get_job(job_id: str, session: Optional[snowpark.Session] = None) -> jb.MLJob
         _ = job._service_spec
         return job
     except SnowparkSQLException as e:
-        if "does not exist" in e.message:
-            raise ValueError(f"Job does not exist: {job_id}") from e
+        if e.sql_error_code == 2003:
+            job = jb.MLJob[Any](job_id, session=session)
+            _ = job.status
+            return job
         raise
 
 
@@ -446,7 +449,7 @@ def _submit_job(
     Raises:
         ValueError: If database or schema value(s) are invalid
         RuntimeError: If schema is not specified in session context or job submission
-        snowpark.exceptions.SnowparkSQLException: if failed to upload payload
+        SnowparkSQLException: if failed to upload payload
     """
     session = _ensure_session(session)
 
@@ -512,49 +515,44 @@ def _submit_job(
         uploaded_payload = payload_utils.JobPayload(
             source, entrypoint=entrypoint, pip_requirements=pip_requirements, additional_payloads=imports
         ).upload(session, stage_path)
-    except snowpark.exceptions.SnowparkSQLException as e:
+    except SnowparkSQLException as e:
         if e.sql_error_code == 90106:
             raise RuntimeError(
                 "Please specify a schema, either in the session context or as a parameter in the job submission"
             )
         raise
 
-    # FIXME: Temporary patches, remove this after v1 is deprecated
-    if target_instances > 1:
-        default_spec_overrides = {
-            "spec": {
-                "endpoints": [
-                    {"name": "ray-dashboard-endpoint", "port": 12003, "protocol": "TCP"},
-                ]
-            },
-        }
-        if spec_overrides:
-            spec_overrides = spec_utils.merge_patch(
-                default_spec_overrides, spec_overrides, display_name="spec_overrides"
-            )
-        else:
-            spec_overrides = default_spec_overrides
-
-    if feature_flags.FeatureFlags.USE_SUBMIT_JOB_V2.is_enabled():
+    if feature_flags.FeatureFlags.USE_SUBMIT_JOB_V2.is_enabled(default=True):
         # Add default env vars (extracted from spec_utils.generate_service_spec)
         combined_env_vars = {**uploaded_payload.env_vars, **(env_vars or {})}
 
-        return _do_submit_job_v2(
-            session=session,
-            payload=uploaded_payload,
-            args=args,
-            env_vars=combined_env_vars,
-            spec_overrides=spec_overrides,
-            compute_pool=compute_pool,
-            job_id=job_id,
-            external_access_integrations=external_access_integrations,
-            query_warehouse=query_warehouse,
-            target_instances=target_instances,
-            min_instances=min_instances,
-            enable_metrics=enable_metrics,
-            use_async=True,
-            runtime_environment=runtime_environment,
-        )
+        try:
+            return _do_submit_job_v2(
+                session=session,
+                payload=uploaded_payload,
+                args=args,
+                env_vars=combined_env_vars,
+                spec_overrides=spec_overrides,
+                compute_pool=compute_pool,
+                job_id=job_id,
+                external_access_integrations=external_access_integrations,
+                query_warehouse=query_warehouse,
+                target_instances=target_instances,
+                min_instances=min_instances,
+                enable_metrics=enable_metrics,
+                use_async=True,
+                runtime_environment=runtime_environment,
+            )
+        except SnowparkSQLException as e:
+            if not (e.sql_error_code == 90237 and sp_utils.is_in_stored_procedure()):  # type: ignore[no-untyped-call]
+                raise
+            # SNOW-2390287: SYSTEM$EXECUTE_ML_JOB() is erroneously blocked in owner's rights
+            # stored procedures. This will be fixed in an upcoming release.
+            logger.warning(
+                "Job submission using V2 failed with error {}. Falling back to V1.".format(
+                    str(e).split("\n", 1)[0],
+                )
+            )
 
     # Fall back to v1
     # Generate service spec
@@ -688,7 +686,7 @@ def _do_submit_job_v2(
     # for the image tag or full image URL, we use that directly
     if runtime_environment:
         spec_options["RUNTIME"] = runtime_environment
-    elif feature_flags.FeatureFlags.ENABLE_IMAGE_VERSION_ENV_VAR.is_enabled():
+    elif feature_flags.FeatureFlags.ENABLE_RUNTIME_VERSIONS.is_enabled():
         # when feature flag is enabled, we get the local python version and wrap it in a dict
         # in system function, we can know whether it is python version or image tag or full image URL through the format
         spec_options["RUNTIME"] = json.dumps({"pythonVersion": f"{sys.version_info.major}.{sys.version_info.minor}"})

snowflake/ml/model/_client/model/model_version_impl.py

@@ -19,7 +19,9 @@ from snowflake.ml.model._client.model import (
 from snowflake.ml.model._client.ops import metadata_ops, model_ops, service_ops
 from snowflake.ml.model._model_composer import model_composer
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
+from snowflake.ml.model._model_composer.model_method import utils as model_method_utils
 from snowflake.ml.model._packager.model_handlers import snowmlmodel
+from snowflake.ml.model._packager.model_meta import model_meta_schema
 from snowflake.snowpark import Session, async_job, dataframe
 
 _TELEMETRY_PROJECT = "MLOps"
@@ -41,6 +43,7 @@ class ModelVersion(lineage_node.LineageNode):
     _model_name: sql_identifier.SqlIdentifier
     _version_name: sql_identifier.SqlIdentifier
     _functions: list[model_manifest_schema.ModelFunctionInfo]
+    _model_spec: Optional[model_meta_schema.ModelMetadataDict]
 
     def __init__(self) -> None:
         raise RuntimeError("ModelVersion's initializer is not meant to be used. Use `version` from model instead.")
@@ -150,6 +153,7 @@ class ModelVersion(lineage_node.LineageNode):
         self._model_name = model_name
         self._version_name = version_name
         self._functions = self._get_functions()
+        self._model_spec = None
         super(cls, cls).__init__(
             self,
             session=model_ops._session,
@@ -437,6 +441,26 @@ class ModelVersion(lineage_node.LineageNode):
         """
         return self._functions
 
+    def _get_model_spec(self, statement_params: Optional[dict[str, Any]] = None) -> model_meta_schema.ModelMetadataDict:
+        """Fetch and cache the model spec for this model version.
+
+        Args:
+            statement_params: Optional dictionary of statement parameters to include
+                in the SQL command to fetch the model spec.
+
+        Returns:
+            The model spec as a dictionary for this model version.
+        """
+        if self._model_spec is None:
+            self._model_spec = self._model_ops._fetch_model_spec(
+                database_name=None,
+                schema_name=None,
+                model_name=self._model_name,
+                version_name=self._version_name,
+                statement_params=statement_params,
+            )
+        return self._model_spec
+
     @overload
     def run(
         self,
@@ -531,6 +555,8 @@ class ModelVersion(lineage_node.LineageNode):
                 statement_params=statement_params,
             )
         else:
+            explain_case_sensitive = self._determine_explain_case_sensitivity(target_function_info, statement_params)
+
             return self._model_ops.invoke_method(
                 method_name=sql_identifier.SqlIdentifier(target_function_info["name"]),
                 method_function_type=target_function_info["target_method_function_type"],
@@ -544,8 +570,20 @@ class ModelVersion(lineage_node.LineageNode):
                 partition_column=partition_column,
                 statement_params=statement_params,
                 is_partitioned=target_function_info["is_partitioned"],
+                explain_case_sensitive=explain_case_sensitive,
             )
 
+    def _determine_explain_case_sensitivity(
+        self,
+        target_function_info: model_manifest_schema.ModelFunctionInfo,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> bool:
+        model_spec = self._get_model_spec(statement_params)
+        method_options = model_spec.get("method_options", {})
+        return model_method_utils.determine_explain_case_sensitive_from_method_options(
+            method_options, target_function_info["name"]
+        )
+
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
@@ -803,13 +841,7 @@ class ModelVersion(lineage_node.LineageNode):
             ValueError: If the model is not a HuggingFace text-generation model.
         """
         # Fetch model spec
-        model_spec = self._model_ops._fetch_model_spec(
-            database_name=None,
-            schema_name=None,
-            model_name=self._model_name,
-            version_name=self._version_name,
-            statement_params=statement_params,
-        )
+        model_spec = self._get_model_spec(statement_params)
 
         # Check if model_type is huggingface_pipeline
         model_type = model_spec.get("model_type")

snowflake/ml/model/_client/ops/model_ops.py

@@ -952,6 +952,7 @@ class ModelOperator:
         partition_column: Optional[sql_identifier.SqlIdentifier] = None,
         statement_params: Optional[dict[str, str]] = None,
         is_partitioned: Optional[bool] = None,
+        explain_case_sensitive: bool = False,
     ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
         ...
 
@@ -967,6 +968,7 @@ class ModelOperator:
         service_name: sql_identifier.SqlIdentifier,
         strict_input_validation: bool = False,
         statement_params: Optional[dict[str, str]] = None,
+        explain_case_sensitive: bool = False,
     ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
         ...
 
@@ -986,6 +988,7 @@ class ModelOperator:
         partition_column: Optional[sql_identifier.SqlIdentifier] = None,
         statement_params: Optional[dict[str, str]] = None,
         is_partitioned: Optional[bool] = None,
+        explain_case_sensitive: bool = False,
     ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
         identifier_rule = model_signature.SnowparkIdentifierRule.INFERRED
 
@@ -1068,6 +1071,7 @@ class ModelOperator:
                     version_name=version_name,
                     statement_params=statement_params,
                     is_partitioned=is_partitioned or False,
+                    explain_case_sensitive=explain_case_sensitive,
                 )
 
         if keep_order:

snowflake/ml/model/_client/sql/model_version.py

@@ -438,6 +438,7 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
         partition_column: Optional[sql_identifier.SqlIdentifier],
         statement_params: Optional[dict[str, Any]] = None,
         is_partitioned: bool = True,
+        explain_case_sensitive: bool = False,
     ) -> dataframe.DataFrame:
         with_statements = []
         if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
@@ -505,7 +506,8 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
         cols_to_drop = []
 
         for output_name, output_type, output_col_name in returns:
-            output_identifier = sql_identifier.SqlIdentifier(output_name).identifier()
+            case_sensitive = "explain" in method_name.resolved().lower() and explain_case_sensitive
+            output_identifier = sql_identifier.SqlIdentifier(output_name, case_sensitive=case_sensitive).identifier()
             if output_identifier != output_col_name:
                 cols_to_drop.append(output_identifier)
             output_cols.append(F.col(output_identifier).astype(output_type))

snowflake/ml/model/_model_composer/model_method/model_method.py

@@ -11,6 +11,7 @@ from snowflake.ml.model._model_composer.model_manifest import model_manifest_sch
 from snowflake.ml.model._model_composer.model_method import (
     constants,
     function_generator,
+    utils,
 )
 from snowflake.ml.model._packager.model_meta import model_meta as model_meta_api
 from snowflake.ml.model.volatility import Volatility
@@ -34,9 +35,13 @@ def get_model_method_options_from_options(
     options: type_hints.ModelSaveOption, target_method: str
 ) -> ModelMethodOptions:
     default_function_type = model_manifest_schema.ModelMethodFunctionTypes.FUNCTION.value
+    method_option = options.get("method_options", {}).get(target_method, {})
+    case_sensitive = method_option.get("case_sensitive", False)
     if target_method == "explain":
         default_function_type = model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value
-    method_option = options.get("method_options", {}).get(target_method, {})
+        case_sensitive = utils.determine_explain_case_sensitive_from_method_options(
+            options.get("method_options", {}), target_method
+        )
     global_function_type = options.get("function_type", default_function_type)
     function_type = method_option.get("function_type", global_function_type)
     if function_type not in [function_type.value for function_type in model_manifest_schema.ModelMethodFunctionTypes]:
@@ -48,7 +53,7 @@ def get_model_method_options_from_options(
 
     # Only include volatility if explicitly provided in method options
     result: ModelMethodOptions = ModelMethodOptions(
-        case_sensitive=method_option.get("case_sensitive", False),
+        case_sensitive=case_sensitive,
         function_type=function_type,
     )
     if resolved_volatility:

snowflake/ml/model/_model_composer/model_method/utils.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+
+
+def determine_explain_case_sensitive_from_method_options(
+    method_options: Mapping[str, Optional[Mapping[str, Any]]],
+    target_method: str,
+) -> bool:
+    """Determine explain method case sensitivity from related predict methods.
+
+    Args:
+        method_options: Mapping from method name to its options. Each option may
+            contain ``"case_sensitive"`` to indicate SQL identifier sensitivity.
+        target_method: The target method name being resolved (e.g., an ``explain_*``
+            method).
+
+    Returns:
+        True if the explain method should be treated as case sensitive; otherwise False.
+    """
+    if "explain" not in target_method:
+        return False
+    predict_priority_methods = ["predict_proba", "predict", "predict_log_proba"]
+    for src_method in predict_priority_methods:
+        src_opts = method_options.get(src_method)
+        if src_opts is not None:
+            return bool(src_opts.get("case_sensitive", False))
+    return False

snowflake/ml/model/_packager/model_env/model_env.py

@@ -240,14 +240,31 @@ class ModelEnv:
                 self._conda_dependencies[channel].remove(spec)
 
     def generate_env_for_cuda(self) -> None:
+
+        # Insert py-xgboost-gpu only for XGBoost versions < 3.0.0
         xgboost_spec = env_utils.find_dep_spec(
-            self._conda_dependencies, self._pip_requirements, conda_pkg_name="xgboost", remove_spec=True
+            self._conda_dependencies, self._pip_requirements, conda_pkg_name="xgboost", remove_spec=False
         )
         if xgboost_spec:
-            self.include_if_absent(
-                [ModelDependency(requirement=f"py-xgboost-gpu{xgboost_spec.specifier}", pip_name="xgboost")],
-                check_local_version=False,
-            )
+            # Only handle explicitly pinned versions. Insert GPU variant iff pinned major < 3.
+            pinned_major: Optional[int] = None
+            for spec in xgboost_spec.specifier:
+                if spec.operator in ("==", "===", ">", ">="):
+                    try:
+                        pinned_major = version.parse(spec.version).major
+                    except version.InvalidVersion:
+                        pinned_major = None
+                    break
+
+            if pinned_major is not None and pinned_major < 3:
+                xgboost_spec = env_utils.find_dep_spec(
+                    self._conda_dependencies, self._pip_requirements, conda_pkg_name="xgboost", remove_spec=True
+                )
+                if xgboost_spec:
+                    self.include_if_absent(
+                        [ModelDependency(requirement=f"py-xgboost-gpu{xgboost_spec.specifier}", pip_name="xgboost")],
+                        check_local_version=False,
+                    )
 
         tf_spec = env_utils.find_dep_spec(
             self._conda_dependencies, self._pip_requirements, conda_pkg_name="tensorflow", remove_spec=True