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

snowflake/ml/feature_store/feature_store.py

@@ -474,8 +474,8 @@ class FeatureStore:
             feature_view: FeatureView instance to materialize.
             version: version of the registered FeatureView.
                 NOTE: Version only accepts letters, numbers and underscore. Also version will be capitalized.
-            block: Specify whether the FeatureView backend materialization should be blocking or not. If blocking then
-                the API will wait until the initial FeatureView data is generated. Default to true.
+            block: Deprecated. To make the initial refresh asynchronous, set the `initialize`
+                argument on the `FeatureView` to `"ON_SCHEDULE"`. Default is true.
             overwrite: Overwrite the existing FeatureView with same version. This is the same as dropping the
                 FeatureView first then recreate. NOTE: there will be backfill cost associated if the FeatureView is
                 being continuously maintained.
@@ -521,6 +521,15 @@ class FeatureStore:
         """
         version = FeatureViewVersion(version)
 
+        if block is False:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=ValueError(
+                    'block=False is deprecated. Use FeatureView(..., initialize="ON_SCHEDULE") '
+                    "for async initial refresh."
+                ),
+            )
+
         if feature_view.status != FeatureViewStatus.DRAFT:
             try:
                 return self._get_feature_view_if_exists(feature_view.name, str(version))
@@ -1191,7 +1200,7 @@ class FeatureStore:
                 {self._config.database}.INFORMATION_SCHEMA.DYNAMIC_TABLE_REFRESH_HISTORY (RESULT_LIMIT => 10000)
             )
             WHERE NAME = '{fv_resolved_name}'
-            AND SCHEMA_NAME = '{self._config.schema}'
+            AND SCHEMA_NAME = '{self._config.schema.resolved()}'
             """
         )
 
@@ -2094,26 +2103,48 @@ class FeatureStore:
     def _plan_online_update(
         self, feature_view: FeatureView, online_config: Optional[fv_mod.OnlineConfig]
     ) -> _OnlineUpdateStrategy:
-        """Plan online update operations based on current state and target config."""
+        """Plan online update operations based on current state and target config.
+
+        Handles three cases:
+        - enable is None: Preserve current online state, only update if currently online
+        - enable is True: Enable online storage (create if needed, update if exists)
+        - enable is False: Disable online storage (drop if exists)
+
+        Args:
+            feature_view: The FeatureView object to check current online state.
+            online_config: The OnlineConfig with target enable and lag settings.
+
+        Returns:
+            _OnlineUpdateStrategy containing operations and their rollbacks.
+        """
         if online_config is None:
             return self._OnlineUpdateStrategy([], [], None)
 
         current_online = feature_view.online
         target_online = online_config.enable
 
-        # Enable online (create table)
+        # Case 1: enable is None - preserve current online state, only update if currently online
+        if target_online is None:
+            if current_online and (online_config.target_lag is not None):
+                # Online is currently enabled and user wants to update lag
+                return self._plan_online_update_existing(feature_view, online_config)
+            else:
+                # No online changes needed (either not online, or lag not specified)
+                return self._OnlineUpdateStrategy([], [], None)
+
+        # Case 2: Enable online (create table)
         if target_online and not current_online:
             return self._plan_online_enable(feature_view, online_config)
 
-        # Disable online (drop table)
+        # Case 3: Disable online (drop table)
         elif not target_online and current_online:
             return self._plan_online_disable(feature_view)
 
-        # Update existing online table
+        # Case 4: Update existing online table
         elif target_online and current_online:
             return self._plan_online_update_existing(feature_view, online_config)
 
-        # No change needed
+        # Case 5: No change needed
         else:
             return self._OnlineUpdateStrategy([], [], online_config)
 
@@ -2621,9 +2652,10 @@ class FeatureStore:
 
         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
+        2. For each feature view, creating a deduplicated spine subquery with only that FV's join keys
+        3. Performing ASOF JOINs on the deduplicated spine when timestamp columns exist
+        4. Performing LEFT JOINs on the deduplicated spine when timestamp columns are missing
+        5. Combining results by LEFT JOINing each FV CTE back to the original SPINE
 
         Args:
             feature_views: A list of feature views to join.
@@ -2633,9 +2665,6 @@ class FeatureStore:
             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.
         """
@@ -2659,11 +2688,17 @@ class FeatureStore:
             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:
+                # Build the deduplicated spine columns set (join keys + timestamp)
+                spine_dedup_cols_set = set(fv_join_keys)
+                if spine_timestamp_col not in spine_dedup_cols_set:
+                    spine_dedup_cols_set.add(spine_timestamp_col)
+                spine_dedup_cols_str = ", ".join(f'"{col}"' for col in spine_dedup_cols_set)
+
+                # Build the JOIN condition using only this feature view's join keys
+                join_conditions_dedup = [f'SPINE_DEDUP."{col}" = FEATURE."{col}"' for col in fv_join_keys]
+
                 if include_feature_view_timestamp_col:
                     f_ts_col_alias = identifier.concat_names(
                         [feature_view.name, "_", str(feature_view.version), "_", feature_timestamp_col]
@@ -2674,36 +2709,46 @@ class FeatureStore:
                 ctes.append(
                     f"""{cte_name} AS (
     SELECT
-        SPINE.*,
+        SPINE_DEDUP.*,
         {f_ts_col_str}
         FEATURE.* EXCLUDE ({join_keys_str}, {feature_timestamp_col})
-    FROM
-        SPINE
+    FROM (
+        SELECT DISTINCT {spine_dedup_cols_str}
+        FROM SPINE
+    ) SPINE_DEDUP
     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)}
+    MATCH_CONDITION (SPINE_DEDUP."{spine_timestamp_col}" >= FEATURE."{feature_timestamp_col}")
+    ON {" AND ".join(join_conditions_dedup)}
 )"""
                 )
             else:
+                # Build the deduplicated spine columns list (just join keys, no timestamp)
+                spine_dedup_cols_str = ", ".join(f'"{col}"' for col in fv_join_keys)
+
+                # Build the JOIN condition using only this feature view's join keys
+                join_conditions_dedup = [f'SPINE_DEDUP."{col}" = FEATURE."{col}"' for col in fv_join_keys]
+
                 ctes.append(
                     f"""{cte_name} AS (
     SELECT
-        SPINE.*,
+        SPINE_DEDUP.*,
         FEATURE.* EXCLUDE ({join_keys_str})
-    FROM
-        SPINE
+    FROM (
+        SELECT DISTINCT {spine_dedup_cols_str}
+        FROM SPINE
+    ) SPINE_DEDUP
     LEFT JOIN (
         SELECT {join_keys_str}, {feature_columns[i]}
         FROM {feature_view.fully_qualified_name()}
     ) FEATURE
-    ON {" AND ".join(join_conditions)}
+    ON {" AND ".join(join_conditions_dedup)}
 )"""
                 )
 
-        # Build final SELECT with individual joins to each FV CTE
+        # Build final SELECT with LEFT joins to each FV CTE
         select_columns = []
         join_clauses = []
 
@@ -2711,19 +2756,29 @@ class FeatureStore:
             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:
+            # Only include spine timestamp in join condition if both spine and FV have timestamps
+            if spine_timestamp_col is not None and feature_view.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])
+
+            # Select features from the CTE
+            # feature_columns[i] is already a comma-separated string of column names
+            feature_cols_from_cte = []
+            for col in feature_columns[i].split(", "):
+                col_clean = col.strip()
+                feature_cols_from_cte.append(f"{cte_name}.{col_clean}")
+            select_columns.extend(feature_cols_from_cte)
+
             # Create join condition using only this feature view's join keys
             join_clauses.append(
                 f"""
-    INNER JOIN {cte_name}
+    LEFT JOIN {cte_name}
     ON {" AND ".join(join_conditions)}"""
             )
 
@@ -3388,7 +3443,7 @@ FROM SPINE{' '.join(join_clauses)}
         online_table_name = FeatureView._get_online_table_name(feature_view_name)
 
         fully_qualified_online_name = self._get_fully_qualified_name(online_table_name)
-        source_table_name = feature_view_name
+        source_table_name = self._get_fully_qualified_name(feature_view_name)
 
         # Extract join keys for PRIMARY KEY (preserve order and ensure unique)
         ordered_join_keys: list[str] = []

snowflake/ml/feature_store/feature_view.py

@@ -1,7 +1,7 @@
+"""Feature view module for Snowflake ML Feature Store."""
 from __future__ import annotations
 
 import json
-import logging
 import re
 import warnings
 from collections import OrderedDict
@@ -52,7 +52,7 @@ _RESULT_SCAN_QUERY_PATTERN = re.compile(
 class OnlineConfig:
     """Configuration for online feature storage."""
 
-    enable: bool = False
+    enable: Optional[bool] = None
     target_lag: Optional[str] = None
 
     def __post_init__(self) -> None:
@@ -248,6 +248,7 @@ class FeatureView(lineage_node.LineageNode):
                 - If `timestamp_col` is provided, it is added to the default clustering keys.
             online_config: Optional configuration for online storage. If provided with enable=True,
                 online storage will be enabled. Defaults to None (no online storage).
+                NOTE: this feature is currently in Public Preview.
             _kwargs: reserved kwargs for system generated args. NOTE: DO NOT USE.
 
         Example::
@@ -289,8 +290,6 @@ class FeatureView(lineage_node.LineageNode):
 
         # noqa: DAR401
         """
-        if online_config is not None:
-            logging.warning("'online_config' is in private preview since 1.12.0. Do not use it in production.")
 
         self._name: SqlIdentifier = SqlIdentifier(name)
         self._entities: list[Entity] = entities
@@ -533,8 +532,15 @@ class FeatureView(lineage_node.LineageNode):
         return self._feature_desc
 
     @property
-    def online(self) -> bool:
-        return self._online_config.enable if self._online_config else False
+    def online(self) -> bool:  # noqa: DAR101
+        """Check if online storage is enabled for this feature view.
+
+        Returns:
+            True if online storage is enabled, False otherwise.
+        """
+        if self._online_config and self._online_config.enable is True:
+            return True
+        return False
 
     @property
     def online_config(self) -> Optional[OnlineConfig]:

snowflake/ml/fileset/stage_fs.py

@@ -1,5 +1,6 @@
 import inspect
 import logging
+import re
 import time
 from dataclasses import dataclass
 from typing import Any, Optional, Union, cast
@@ -27,6 +28,8 @@ _PRESIGNED_URL_LIFETIME_SEC = 14400
 # The threshold of when the presigned url should get refreshed before its expiration.
 _PRESIGNED_URL_HEADROOM_SEC = 3600
 
+# Regex pattern to match cloud storage prefixes (s3://, gcs://, azure://) and bucket/container name at start of string
+_CLOUD_PATH_PREFIX_PATTERN = re.compile(r"^(s3|gcs|azure)://[^/]+/", re.IGNORECASE)
 
 _PROJECT = "FileSet"
 
@@ -355,8 +358,16 @@ class SFStageFileSystem(fsspec.AbstractFileSystem):
 
         Returns:
             A string of the relative stage path.
+
+        Raises:
+            ValueError: If the stage path format is invalid.
         """
-        return stage_path[len(self._stage) + 1 :]
+        if stage_path.lower().startswith(self._stage.lower()):
+            return stage_path[len(self._stage) + 1 :]
+        elif match := _CLOUD_PATH_PREFIX_PATTERN.match(stage_path):
+            return stage_path[match.end() :]
+
+        raise ValueError(f"Invalid stage path: {stage_path}")
 
     def _add_file_info_helper(
         self,

snowflake/ml/jobs/_utils/feature_flags.py

@@ -31,6 +31,7 @@ def parse_bool_env_value(value: Optional[str], default: bool = False) -> bool:
 class FeatureFlags(Enum):
     USE_SUBMIT_JOB_V2 = "MLRS_USE_SUBMIT_JOB_V2"
     ENABLE_RUNTIME_VERSIONS = "MLRS_ENABLE_RUNTIME_VERSIONS"
+    ENABLE_STAGE_MOUNT_V2 = "MLRS_ENABLE_STAGE_MOUNT_V2"
 
     def is_enabled(self, default: bool = False) -> bool:
         """Check if the feature flag is enabled.

snowflake/ml/jobs/_utils/payload_utils.py

@@ -620,7 +620,12 @@ def _serialize_callable(func: Callable[..., Any]) -> bytes:
     try:
         func_bytes: bytes = cp.dumps(func)
         return func_bytes
-    except pickle.PicklingError as e:
+    except (pickle.PicklingError, TypeError) as e:
+        if isinstance(e, TypeError) and "_thread.lock" in str(e):
+            raise RuntimeError(
+                "Unable to pickle an object that internally holds a reference to a Session object, "
+                "such as a Snowpark DataFrame."
+            ) from e
         if isinstance(func, functools.partial):
             # Try to find which part of the partial isn't serializable for better debuggability
             objects = [

snowflake/ml/jobs/_utils/spec_utils.py

@@ -197,7 +197,7 @@ def generate_service_spec(
         resource_limits["nvidia.com/gpu"] = image_spec.resource_limits.gpu
 
     # Add local volumes for ephemeral logs and artifacts
-    volumes: list[dict[str, str]] = []
+    volumes: list[dict[str, Any]] = []
     volume_mounts: list[dict[str, str]] = []
     for volume_name, mount_path in [
         ("system-logs", "/var/log/managedservices/system/mlrs"),
@@ -246,7 +246,16 @@ def generate_service_spec(
     volumes.append(
         {
             "name": constants.STAGE_VOLUME_NAME,
-            "source": payload.stage_path.as_posix(),
+            "source": "stage",
+            "stageConfig": {
+                "name": payload.stage_path.as_posix(),
+                "resources": {
+                    "requests": {
+                        "memory": "0Gi",
+                        "cpu": "0",
+                    },
+                },
+            },
         }
     )
 
@@ -286,7 +295,7 @@ def generate_service_spec(
             "storage",
         ]
 
-    spec_dict = {
+    spec_dict: dict[str, Any] = {
         "containers": [
             {
                 "name": constants.DEFAULT_CONTAINER_NAME,

snowflake/ml/jobs/job.py

@@ -109,11 +109,16 @@ class MLJob(Generic[T], SerializableSessionMixin):
         return cast(dict[str, Any], container_spec)
 
     @property
-    def _stage_path(self) -> str:
+    def _stage_path(self) -> Optional[str]:
         """Get the job's artifact storage stage location."""
         volumes = self._service_spec["spec"]["volumes"]
-        stage_path = next(v for v in volumes if v["name"] == constants.STAGE_VOLUME_NAME)["source"]
-        return cast(str, stage_path)
+        stage_volume = next((v for v in volumes if v["name"] == constants.STAGE_VOLUME_NAME), None)
+        if stage_volume is None:
+            return None
+        elif "stageConfig" in stage_volume:
+            return cast(str, stage_volume["stageConfig"]["name"])
+        else:
+            return cast(str, stage_volume["source"])
 
     @property
     def _result_path(self) -> str:

snowflake/ml/jobs/manager.py

@@ -192,12 +192,12 @@ def delete_job(job: Union[str, jb.MLJob[Any]], session: Optional[snowpark.Sessio
     """Delete a job service from the backend. Status and logs will be lost."""
     job = job if isinstance(job, jb.MLJob) else get_job(job, session=session)
     session = job._session
-    try:
-        stage_path = job._stage_path
-        session.sql(f"REMOVE {stage_path}/").collect()
-        logger.info(f"Successfully cleaned up stage files for job {job.id} at {stage_path}")
-    except Exception as e:
-        logger.warning(f"Failed to clean up stage files for job {job.id}: {e}")
+    if job._stage_path:
+        try:
+            session.sql(f"REMOVE {job._stage_path}/").collect()
+            logger.debug(f"Successfully cleaned up stage files for job {job.id} at {job._stage_path}")
+        except Exception as e:
+            logger.warning(f"Failed to clean up stage files for job {job.id}: {e}")
     query_helper.run_query(session, "DROP SERVICE IDENTIFIER(?)", params=(job.id,))
 
 
@@ -520,6 +520,12 @@ def _submit_job(
             raise RuntimeError(
                 "Please specify a schema, either in the session context or as a parameter in the job submission"
             )
+        elif e.sql_error_code == 3001 and "schema" in str(e).lower():
+            raise RuntimeError(
+                "please grant privileges on schema before submitting a job, see",
+                "https://docs.snowflake.com/en/developer-guide/snowflake-ml/ml-jobs/access-control-requirements",
+                " for more details",
+            ) from e
         raise
 
     if feature_flags.FeatureFlags.USE_SUBMIT_JOB_V2.is_enabled(default=True):
@@ -546,6 +552,12 @@ def _submit_job(
         except SnowparkSQLException as e:
             if not (e.sql_error_code == 90237 and sp_utils.is_in_stored_procedure()):  # type: ignore[no-untyped-call]
                 raise
+            elif e.sql_error_code == 3001 and "schema" in str(e).lower():
+                raise RuntimeError(
+                    "please grant privileges on schema before submitting a job, see",
+                    "https://docs.snowflake.com/en/developer-guide/snowflake-ml/ml-jobs/access-control-requirements"
+                    " for more details",
+                ) from e
             # 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(
@@ -690,6 +702,7 @@ def _do_submit_job_v2(
         # 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}"})
+
     job_options = {
         "EXTERNAL_ACCESS_INTEGRATIONS": external_access_integrations,
         "QUERY_WAREHOUSE": query_warehouse,

snowflake/ml/model/_client/model/inference_engine_utils.py

@@ -4,14 +4,18 @@ from snowflake.ml.model._client.ops import service_ops
 
 
 def _get_inference_engine_args(
-    experimental_options: Optional[dict[str, Any]],
+    inference_engine_options: Optional[dict[str, Any]],
 ) -> Optional[service_ops.InferenceEngineArgs]:
-    if not experimental_options or "inference_engine" not in experimental_options:
+
+    if not inference_engine_options:
         return None
 
+    if "engine" not in inference_engine_options:
+        raise ValueError("'engine' field is required in inference_engine_options")
+
     return service_ops.InferenceEngineArgs(
-        inference_engine=experimental_options["inference_engine"],
-        inference_engine_args_override=experimental_options.get("inference_engine_args_override"),
+        inference_engine=inference_engine_options["engine"],
+        inference_engine_args_override=inference_engine_options.get("engine_args_override"),
     )
 
 

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

@@ -12,7 +12,7 @@ from snowflake.ml import jobs
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.lineage import lineage_node
-from snowflake.ml.model import task, type_hints
+from snowflake.ml.model import openai_signatures, task, type_hints
 from snowflake.ml.model._client.model import (
     batch_inference_specs,
     inference_engine_utils,
@@ -23,6 +23,7 @@ from snowflake.ml.model._model_composer.model_manifest import model_manifest_sch
 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.ml.model._signatures import core
 from snowflake.snowpark import Session, async_job, dataframe
 
 _TELEMETRY_PROJECT = "MLOps"
@@ -940,14 +941,16 @@ class ModelVersion(lineage_node.LineageNode):
         self,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
-        """Check if the model is a HuggingFace pipeline with text-generation task.
+        """Check if the model is a HuggingFace pipeline with text-generation task
+        and is logged with OPENAI_CHAT_SIGNATURE.
 
         Args:
             statement_params: Optional dictionary of statement parameters to include
                 in the SQL command to fetch model spec.
 
         Raises:
-            ValueError: If the model is not a HuggingFace text-generation model.
+            ValueError: If the model is not a HuggingFace text-generation model or
+                if the model is not logged with OPENAI_CHAT_SIGNATURE.
         """
         # Fetch model spec
         model_spec = self._get_model_spec(statement_params)
@@ -983,6 +986,21 @@ class ModelVersion(lineage_node.LineageNode):
             )
             raise ValueError(f"Inference engine is only supported for task 'text-generation'. {found_tasks_str}")
 
+        # Check if the model is logged with OPENAI_CHAT_SIGNATURE
+        signatures_dict = model_spec.get("signatures", {})
+
+        # Deserialize signatures from model spec to ModelSignature objects for proper semantic comparison.
+        deserialized_signatures = {
+            func_name: core.ModelSignature.from_dict(sig_dict) for func_name, sig_dict in signatures_dict.items()
+        }
+
+        if deserialized_signatures != openai_signatures.OPENAI_CHAT_SIGNATURE:
+            raise ValueError(
+                "Inference engine requires the model to be logged with OPENAI_CHAT_SIGNATURE. "
+                f"Found signatures: {signatures_dict}. "
+                "Please log the model with: signatures=openai_signatures.OPENAI_CHAT_SIGNATURE"
+            )
+
     @overload
     def create_service(
         self,
@@ -1001,6 +1019,7 @@ class ModelVersion(lineage_node.LineageNode):
         force_rebuild: bool = False,
         build_external_access_integration: Optional[str] = None,
         block: bool = True,
+        inference_engine_options: Optional[dict[str, Any]] = None,
         experimental_options: Optional[dict[str, Any]] = None,
     ) -> Union[str, async_job.AsyncJob]:
         """Create an inference service with the given spec.
@@ -1034,10 +1053,12 @@ class ModelVersion(lineage_node.LineageNode):
             block: A bool value indicating whether this function will wait until the service is available.
                 When it is ``False``, this function executes the underlying service creation asynchronously
                 and returns an :class:`AsyncJob`.
-            experimental_options: Experimental options for the service creation with custom inference engine.
-                Currently, `inference_engine`, `inference_engine_args_override`, and `autocapture` are supported.
-                `inference_engine` is the name of the inference engine to use.
-                `inference_engine_args_override` is a list of string arguments to pass to the inference engine.
+            inference_engine_options: Options for the service creation with custom inference engine.
+                Supports `engine` and `engine_args_override`.
+                `engine` is the type of the inference engine to use.
+                `engine_args_override` is a list of string arguments to pass to the inference engine.
+            experimental_options: Experimental options for the service creation.
+                Currently only `autocapture` is supported.
                 `autocapture` is a boolean to enable/disable inference table.
         """
         ...
@@ -1060,6 +1081,7 @@ class ModelVersion(lineage_node.LineageNode):
         force_rebuild: bool = False,
         build_external_access_integrations: Optional[list[str]] = None,
         block: bool = True,
+        inference_engine_options: Optional[dict[str, Any]] = None,
         experimental_options: Optional[dict[str, Any]] = None,
     ) -> Union[str, async_job.AsyncJob]:
         """Create an inference service with the given spec.
@@ -1093,10 +1115,12 @@ class ModelVersion(lineage_node.LineageNode):
             block: A bool value indicating whether this function will wait until the service is available.
                 When it is ``False``, this function executes the underlying service creation asynchronously
                 and returns an :class:`AsyncJob`.
-            experimental_options: Experimental options for the service creation with custom inference engine.
-                Currently, `inference_engine`, `inference_engine_args_override`, and `autocapture` are supported.
-                `inference_engine` is the name of the inference engine to use.
-                `inference_engine_args_override` is a list of string arguments to pass to the inference engine.
+            inference_engine_options: Options for the service creation with custom inference engine.
+                Supports `engine` and `engine_args_override`.
+                `engine` is the type of the inference engine to use.
+                `engine_args_override` is a list of string arguments to pass to the inference engine.
+            experimental_options: Experimental options for the service creation.
+                Currently only `autocapture` is supported.
                 `autocapture` is a boolean to enable/disable inference table.
         """
         ...
@@ -1134,6 +1158,7 @@ class ModelVersion(lineage_node.LineageNode):
         build_external_access_integration: Optional[str] = None,
         build_external_access_integrations: Optional[list[str]] = None,
         block: bool = True,
+        inference_engine_options: Optional[dict[str, Any]] = None,
         experimental_options: Optional[dict[str, Any]] = None,
     ) -> Union[str, async_job.AsyncJob]:
         """Create an inference service with the given spec.
@@ -1169,10 +1194,12 @@ class ModelVersion(lineage_node.LineageNode):
             block: A bool value indicating whether this function will wait until the service is available.
                 When it is False, this function executes the underlying service creation asynchronously
                 and returns an AsyncJob.
-            experimental_options: Experimental options for the service creation with custom inference engine.
-                Currently, `inference_engine`, `inference_engine_args_override`, and `autocapture` are supported.
-                `inference_engine` is the name of the inference engine to use.
-                `inference_engine_args_override` is a list of string arguments to pass to the inference engine.
+            inference_engine_options: Options for the service creation with custom inference engine.
+                Supports `engine` and `engine_args_override`.
+                `engine` is the type of the inference engine to use.
+                `engine_args_override` is a list of string arguments to pass to the inference engine.
+            experimental_options: Experimental options for the service creation.
+                Currently only `autocapture` is supported.
                 `autocapture` is a boolean to enable/disable inference table.
 
 
@@ -1209,9 +1236,10 @@ class ModelVersion(lineage_node.LineageNode):
         # Validate GPU support if GPU resources are requested
         self._throw_error_if_gpu_is_not_supported(gpu_requests, statement_params)
 
-        inference_engine_args = inference_engine_utils._get_inference_engine_args(experimental_options)
+        inference_engine_args = inference_engine_utils._get_inference_engine_args(inference_engine_options)
 
-        # Check if model is HuggingFace text-generation before doing inference engine checks
+        # Check if model is HuggingFace text-generation and is logged with
+        # OPENAI_CHAT_SIGNATURE before doing inference engine checks
         # Only validate if inference engine is actually specified
         if inference_engine_args is not None:
             self._check_huggingface_text_generation_model(statement_params)

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

@@ -515,10 +515,17 @@ class ModelOperator:
             statement_params=statement_params,
         )
         for r in res:
-            if alias_name in r[self._model_client.MODEL_VERSION_ALIASES_COL_NAME]:
-                return sql_identifier.SqlIdentifier(
-                    r[self._model_client.MODEL_VERSION_NAME_COL_NAME], case_sensitive=True
-                )
+            aliases_data = r[self._model_client.MODEL_VERSION_ALIASES_COL_NAME]
+            if aliases_data:
+                aliases_list = json.loads(aliases_data)
+
+                # Compare using Snowflake identifier semantics for exact match
+                for alias in aliases_list:
+                    if sql_identifier.SqlIdentifier(alias) == alias_name:
+                        return sql_identifier.SqlIdentifier(
+                            r[self._model_client.MODEL_VERSION_NAME_COL_NAME], case_sensitive=True
+                        )
+
         return None
 
     def get_tag_value(