snowflake-ml-python 2.2.0__tar.gz → 2.3.0__tar.gz

{snowflake_ml_python-2.2.0 → snowflake_ml_python-2.3.0}/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Release History
 
-## 2.2.0
+## 2.3.0
+
+### New Features
+
+* Experiment Tracking: `ExperimentTracking` accepts an optional `model_registry` parameter. When provided,
+  `log_model` stores models in the registry's database and schema instead of the experiment's, so experiments
+  and models can live in separate schemas.
+
+### Bug Fixes
+
+* Feature Store: Offline reads of a feature view with several list aggregations or several secondary-key
+  aggregation windows used to return incomplete results in some scenarios. The bug has been fixed
+  and the existing feature views pick up the fix on their next read, with no re-registration or backfill required.
+
+### Behavior Changes
+
+### Deprecations
+
+## 2.2.0 (2026-09-21)
 
 ### New Features
 
@@ -14,8 +32,17 @@
 
 ### Bug Fixes
 
+* Registry: `ModelVersion.load()` now compares the model owner to `CURRENT_ROLE()` (the role that
+  executes SQL) instead of `Session.get_current_role()`. Owner's-rights Streamlit apps and
+  `EXECUTE AS OWNER` procedures can load when statements run as the owner even if the caller's
+  primary role is not the owner.
+
 ### Behavior Changes
 
+* Dependencies: `scipy` is no longer a required dependency of `snowflake-ml-python`. It is still
+  installed transitively with `pip install snowflake-ml-python[scikit-learn]`. Direct `scipy` usage
+  in `snowflake.ml.modeling.preprocessing` already requires that extra.
+
 ### Deprecations
 
 ## 2.1.0 (2026-09-14)
@@ -37,21 +64,12 @@
 
 ### Bug Fixes
 
-* Registry: `ModelVersion.load()` now compares the model owner to `CURRENT_ROLE()` (the role that
-  executes SQL) instead of `Session.get_current_role()`. Owner's-rights Streamlit apps and
-  `EXECUTE AS OWNER` procedures can load when statements run as the owner even if the caller's
-  primary role is not the owner.
-
 * Registry: Fixed logging of MLflow models created with `mlflow.sklearn.save_model()`. The model is
   now re-logged from the scikit-learn estimator using the serialization format it was saved with,
   instead of from MLflow's PyFunc wrapper with the version-dependent default format.
 
 ### Behavior Changes
 
-* Dependencies: `scipy` is no longer a required dependency of `snowflake-ml-python`. It is still
-  installed transitively with `pip install snowflake-ml-python[scikit-learn]`. Direct `scipy` usage
-  in `snowflake.ml.modeling.preprocessing` already requires that extra.
-
 ### Deprecations
 
 ## 2.0.0 (2026-09-09)

{snowflake_ml_python-2.2.0 → snowflake_ml_python-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 2.2.0
+Version: 2.3.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: 
@@ -424,7 +424,25 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 2.2.0
+## 2.3.0
+
+### New Features
+
+* Experiment Tracking: `ExperimentTracking` accepts an optional `model_registry` parameter. When provided,
+  `log_model` stores models in the registry's database and schema instead of the experiment's, so experiments
+  and models can live in separate schemas.
+
+### Bug Fixes
+
+* Feature Store: Offline reads of a feature view with several list aggregations or several secondary-key
+  aggregation windows used to return incomplete results in some scenarios. The bug has been fixed
+  and the existing feature views pick up the fix on their next read, with no re-registration or backfill required.
+
+### Behavior Changes
+
+### Deprecations
+
+## 2.2.0 (2026-09-21)
 
 ### New Features
 
@@ -438,8 +456,17 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Bug Fixes
 
+* Registry: `ModelVersion.load()` now compares the model owner to `CURRENT_ROLE()` (the role that
+  executes SQL) instead of `Session.get_current_role()`. Owner's-rights Streamlit apps and
+  `EXECUTE AS OWNER` procedures can load when statements run as the owner even if the caller's
+  primary role is not the owner.
+
 ### Behavior Changes
 
+* Dependencies: `scipy` is no longer a required dependency of `snowflake-ml-python`. It is still
+  installed transitively with `pip install snowflake-ml-python[scikit-learn]`. Direct `scipy` usage
+  in `snowflake.ml.modeling.preprocessing` already requires that extra.
+
 ### Deprecations
 
 ## 2.1.0 (2026-09-14)
@@ -461,21 +488,12 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ### Bug Fixes
 
-* Registry: `ModelVersion.load()` now compares the model owner to `CURRENT_ROLE()` (the role that
-  executes SQL) instead of `Session.get_current_role()`. Owner's-rights Streamlit apps and
-  `EXECUTE AS OWNER` procedures can load when statements run as the owner even if the caller's
-  primary role is not the owner.
-
 * Registry: Fixed logging of MLflow models created with `mlflow.sklearn.save_model()`. The model is
   now re-logged from the scikit-learn estimator using the serialization format it was saved with,
   instead of from MLflow's PyFunc wrapper with the version-dependent default format.
 
 ### Behavior Changes
 
-* Dependencies: `scipy` is no longer a required dependency of `snowflake-ml-python`. It is still
-  installed transitively with `pip install snowflake-ml-python[scikit-learn]`. Direct `scipy` usage
-  in `snowflake.ml.modeling.preprocessing` already requires that extra.
-
 ### Deprecations
 
 ## 2.0.0 (2026-09-09)

{snowflake_ml_python-2.2.0 → snowflake_ml_python-2.3.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -52,6 +52,7 @@ class ExperimentTracking:
         database_name: str | None = None,
         schema_name: str | None = None,
         capture_source_info: bool = True,
+        model_registry: registry.Registry | None = None,
     ) -> None:
         """
         Initializes experiment tracking within a pre-created schema.
@@ -68,6 +69,12 @@ class ExperimentTracking:
                 of the enclosing ML job when running inside one. Set to False to skip collection
                 entirely. Collection is always non-fatal and never blocks run creation. Defaults to
                 True.
+            model_registry: An optional Registry instance to use for ``log_model``. When provided,
+                models are logged to the database and schema owned by this registry instead of the
+                experiment's database and schema. This is useful when the experiment lives in one
+                schema (e.g. ``analytics.experiments``) but models should be stored in another
+                (e.g. ``ml.models``). If None, models are logged to the same location as the
+                experiment. Defaults to None.
 
         Raises:
             ValueError: If no database is provided and no active database exists in the session.
@@ -109,11 +116,7 @@ class ExperimentTracking:
             database_name=self._database_name,
             schema_name=self._schema_name,
         )
-        self._registry = registry.Registry(
-            session=session,
-            database_name=self._database_name,
-            schema_name=self._schema_name,
-        )
+        self._registry = model_registry
         self._session = session
 
         # The experiment in context
@@ -139,7 +142,10 @@ class ExperimentTracking:
         else:
             state = dict(self.__dict__)
 
-        # Remove unpicklable attributes
+        # Remove unpicklable attributes; save registry coordinates for reconstruction.
+        if self._registry is not None:
+            state["_registry_database_name"] = self._registry._database_name
+            state["_registry_schema_name"] = self._registry._schema_name
         state["_session"] = None
         state["_sql_client"] = None
         state["_registry"] = None
@@ -168,11 +174,14 @@ class ExperimentTracking:
             database_name=self._database_name,
             schema_name=self._schema_name,
         )
-        self._registry = registry.Registry(
-            session=self._session,
-            database_name=self._database_name,
-            schema_name=self._schema_name,
-        )
+        registry_db = state.pop("_registry_database_name", None)
+        registry_schema = state.pop("_registry_schema_name", None)
+        if registry_db is not None:
+            self._registry = registry.Registry(
+                session=self._session,
+                database_name=registry_db,
+                schema_name=registry_schema,
+            )
         if self._run:
             self._patch_stdout_and_stderr()
             # _patch_stdout_and_stderr sets _logging_context if live logging is enabled
@@ -277,8 +286,17 @@ class ExperimentTracking:
         **kwargs: Any,
     ) -> ml_model.ModelVersion:
         run = self._get_or_start_run()
+        target_registry = (
+            self._registry
+            if self._registry is not None
+            else registry.Registry(
+                session=self._session,
+                database_name=self._database_name,
+                schema_name=self._schema_name,
+            )
+        )
         with experiment_info.ExperimentInfoPatcher(experiment_info=run._get_experiment_info()):
-            return self._registry.log_model(model, model_name=model_name, **kwargs)
+            return target_registry.log_model(model, model_name=model_name, **kwargs)
 
     def list_model_versions(self, run_name: str | None = None) -> list[ml_model.ModelVersion]:
         """
@@ -784,11 +802,6 @@ class ExperimentTracking:
             database_name=database_name,
             schema_name=schema_name,
         )
-        self._registry = registry.Registry(
-            session=self._session,
-            database_name=database_name,
-            schema_name=schema_name,
-        )
 
     def _print_urls(
         self,

{snowflake_ml_python-2.2.0 → snowflake_ml_python-2.3.0}/snowflake/ml/feature_store/tile_sql_generator.py

@@ -1143,6 +1143,34 @@ class MergingSqlGenerator:
 
         return cte_name, cte_body.strip()
 
+    def _left_join_subqueries_on_bounds(self, subqueries: list[tuple[str, list[str]]]) -> str:
+        """LEFT JOIN each per-subquery result onto the unique (entity, boundary) rows.
+
+        Driving from UNIQUE_BOUNDS rather than from the first subquery keeps row
+        presence independent of any single window or feature: each subquery applies
+        its own row-level filter, so one with no qualifying tiles must contribute
+        NULLs for its own columns instead of dropping the entity from the CTE and
+        taking every other subquery's results with it.
+
+        Args:
+            subqueries: One (subquery_sql, output_columns) pair per window group or
+                feature. Each subquery must be grouped by the join keys plus
+                TILE_BOUNDARY so the joins stay one-to-one.
+
+        Returns:
+            SQL string selecting the join keys plus every subquery's output columns.
+        """
+        group_by_cols = list(self._join_keys) + [_TILE_BOUNDARY_COL]
+        projected = [f"UB.{col}" for col in group_by_cols]
+        for index, (_, output_cols) in enumerate(subqueries):
+            projected.extend(f"sq{index}.{col}" for col in output_cols)
+
+        result = f"SELECT {', '.join(projected)}\n    FROM UNIQUE_BOUNDS_FV{self._fv_index} UB"
+        for index, (query, _) in enumerate(subqueries):
+            join_cond = " AND ".join(f"UB.{col} = sq{index}.{col}" for col in group_by_cols)
+            result += f"\n    LEFT JOIN {query} sq{index}\n    ON {join_cond}"
+        return result
+
     def _generate_secondary_key_merged_cte(self) -> tuple[str, str]:
         """Generate the CTE for secondary-key aggregations.
 
@@ -1315,22 +1343,13 @@ class MergingSqlGenerator:
         if len(subqueries) == 1:
             cte_body = subqueries[0][2].strip()
         else:
-            # Multiple (sk, window) groups — LEFT JOIN on (entity_keys, boundary).
-            _, _, first_query = subqueries[0]
-            projected: list[str] = [f"sq0.{col}" for col in group_by_cols]
-            projected.append(f"sq0.{subqueries[0][0]}")
-            for col in subqueries[0][1]:
-                projected.append(f"sq0.{col}")
-            for i, (keys_col, value_cols, _) in enumerate(subqueries[1:], 1):
-                projected.append(f"sq{i}.{keys_col}")
-                for col in value_cols:
-                    projected.append(f"sq{i}.{col}")
-
-            result = f"SELECT {', '.join(projected)}\n    FROM {first_query} sq0"
-            for i, (_, _, query) in enumerate(subqueries[1:], 1):
-                join_cond = " AND ".join(f"sq0.{col} = sq{i}.{col}" for col in group_by_cols)
-                result += f"\n    LEFT JOIN {query} sq{i}\n    ON {join_cond}"
-            cte_body = result
+            # Multiple (sk, window) groups: a group whose window covers no tiles
+            # emits no row, so the chain is driven from the unique (entity,
+            # boundary) rows to keep each group's arrays independent. Missing
+            # groups surface as [] via the combined CTE's COALESCE.
+            cte_body = self._left_join_subqueries_on_bounds(
+                [(query, [keys_col, *value_cols]) for keys_col, value_cols, query in subqueries]
+            )
 
         return cte_name, cte_body.strip()
 
@@ -1574,21 +1593,11 @@ class MergingSqlGenerator:
         if len(feature_subqueries) == 1:
             return feature_subqueries[0][1]
 
-        # Multiple list features: join them together
-        first_name, first_query = feature_subqueries[0]
-        result = "SELECT sq0.*, "
-        for i, (name, _) in enumerate(feature_subqueries[1:], 1):
-            result += f"sq{i}.{name}"
-            if i < len(feature_subqueries) - 1:
-                result += ", "
-
-        result += f"\n    FROM {first_query} sq0"
-
-        for i, (_name, query) in enumerate(feature_subqueries[1:], 1):
-            join_cond = " AND ".join(f"sq0.{col} = sq{i}.{col}" for col in group_by_cols)
-            result += f"\n    LEFT JOIN {query} sq{i}\n    ON {join_cond}"
-
-        return result
+        # Multiple list features: a feature with no non-NULL values in the window
+        # emits no row, so the chain is driven from the unique (entity, boundary)
+        # rows to keep each feature's array independent of the others. A missing
+        # feature stays NULL, which is this path's "no data" encoding.
+        return self._left_join_subqueries_on_bounds([(query, [name]) for name, query in feature_subqueries])
 
     def _generate_combined_cte(self) -> tuple[str, str]:
         """Generate the final CTE that combines and expands results.

{snowflake_ml_python-2.2.0 → snowflake_ml_python-2.3.0}/snowflake/ml/jobs/job.py

@@ -362,13 +362,29 @@ class MLJob(Generic[T], SerializableSessionMixin):
         """
         if self._result is None:
             self.wait(timeout)
+            # Retrying would push the call past the caller's timeout, so only retry when unbounded.
+            remaining = _INSTANCE_RECORD_TIMEOUT_SECONDS if timeout < 0 else 0
             try:
-                self._result = interop_utils.load(
-                    self._result_path, session=self._session, path_transform=self._transform_path
-                )
+                while True:
+                    try:
+                        self._result = interop_utils.load(
+                            self._result_path, session=self._session, path_transform=self._transform_path
+                        )
+                        break
+                    except (OSError, json.JSONDecodeError) as error:
+                        if remaining <= 0:
+                            raise
+                        logger.warning(
+                            "job result retrieval: result is not yet readable: %s; retrying in %d second(s)",
+                            error,
+                            _INSTANCE_RECORD_POLL_INTERVAL_SECONDS,
+                        )
+                        time.sleep(_INSTANCE_RECORD_POLL_INTERVAL_SECONDS)
+                        remaining -= _INSTANCE_RECORD_POLL_INTERVAL_SECONDS
             except Exception as e:
                 raise RuntimeError(f"Failed to retrieve result for job, error: {e!r}") from e
 
+        assert self._result is not None
         return cast(T, self._result.get_value())
 
     @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["timeout"])

{snowflake_ml_python-2.2.0 → snowflake_ml_python-2.3.0}/snowflake/ml/model/_client/ops/model_ops.py

@@ -5,7 +5,7 @@ import os
 import pathlib
 import tempfile
 import warnings
-from typing import Any, Literal, TypedDict, cast, overload
+from typing import Any, Literal, NoReturn, TypedDict, cast, overload
 
 import yaml
 from typing_extensions import NotRequired
@@ -31,7 +31,13 @@ from snowflake.ml.model._packager.model_env import model_env
 from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.ml.model._packager.model_runtime import model_runtime
 from snowflake.ml.model._signatures import snowpark_handler
-from snowflake.snowpark import dataframe, functions as F, row, session
+from snowflake.snowpark import (
+    dataframe,
+    exceptions as snowpark_exceptions,
+    functions as F,
+    row,
+    session,
+)
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 logger = logging.getLogger(__name__)
@@ -986,6 +992,220 @@ class ModelOperator:
         task_val = model_attributes.get("task", type_hints.Task.UNKNOWN.value)
         return type_hints.Task(task_val)
 
+    @staticmethod
+    def _is_peft_adapter_spec(parsed_model_spec: model_spec.ModelSpec) -> bool:
+        """Return whether the specification describes a PEFT adapter version.
+
+        Args:
+            parsed_model_spec: Parsed model specification from SHOW VERSIONS.
+
+        Returns:
+            True when the model type is peft_adapter or blob options name a pin.
+        """
+        try:
+            if parsed_model_spec.model_type == "peft_adapter":
+                return True
+        except (KeyError, ValueError):
+            pass
+        return any(
+            isinstance(options.get("base_model_name"), str)
+            and options.get("base_model_name")
+            and isinstance(options.get("base_model_version"), str)
+            and options.get("base_model_version")
+            for options in parsed_model_spec.model_options.values()
+        )
+
+    def _peft_pin_identity_from_lineage(
+        self,
+        *,
+        database_name: sql_identifier.SqlIdentifier | None,
+        schema_name: sql_identifier.SqlIdentifier | None,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+    ) -> tuple[str, str] | Literal["absent", "blocked"]:
+        """Resolve the adapter pin's current name from upstream model lineage.
+
+        Args:
+            database_name: Database of the adapter version.
+            schema_name: Schema of the adapter version.
+            model_name: Adapter model name.
+            version_name: Adapter version name.
+
+        Returns:
+            Current pin fully-qualified name and version when exactly one ACTIVE
+            upstream model exists; ``absent`` when lineage has no model upstream
+            or cannot be read; ``blocked`` when the pin is MASKED, DELETED, incomplete,
+            or not unique.
+        """
+        try:
+            trace_df = self._session.lineage.trace(
+                self._model_client.fully_qualified_object_name(database_name, schema_name, model_name),
+                "MODEL",
+                object_version=version_name.identifier(),
+                direction="upstream",
+                distance=1,
+            )
+            rows = trace_df.collect()
+            model_nodes: list[tuple[str, str, str]] = []
+            for lineage_row in rows:
+                lineage_object = json.loads(lineage_row["SOURCE_OBJECT"])
+                if str(lineage_object.get("domain", "")).lower() != "model":
+                    continue
+                raw_name = lineage_object.get("name")
+                raw_version = lineage_object.get("version")
+                status = str(lineage_object.get("status", ""))
+                if not isinstance(raw_name, str) or not raw_name:
+                    model_nodes.append(("", "", status))
+                    continue
+                parsed_name = ".".join(
+                    identifier.rename_to_valid_snowflake_identifier(part)
+                    for part in identifier.parse_schema_level_object_identifier(raw_name)
+                    if part is not None
+                )
+                pin_version = raw_version if isinstance(raw_version, str) else ""
+                model_nodes.append((parsed_name, pin_version, status))
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            ValueError,
+            json.JSONDecodeError,
+            snowpark_exceptions.SnowparkSQLException,
+        ) as err:
+            logger.debug("adapter model: could not read pin lineage: %s", err)
+            return "absent"
+        if not model_nodes:
+            return "absent"
+        if len(model_nodes) != 1:
+            return "blocked"
+        pin_name, pin_version, status = model_nodes[0]
+        if status.upper() != "ACTIVE" or not pin_name or not pin_version:
+            return "blocked"
+        return pin_name, pin_version
+
+    @staticmethod
+    def _peft_pin_identity_from_blob_options(
+        parsed_model_spec: model_spec.ModelSpec,
+    ) -> tuple[str, str] | None:
+        """Return the pin name and version from adapter blob options.
+
+        Args:
+            parsed_model_spec: Adapter specification whose blob options may name the pin.
+
+        Returns:
+            Pin fully-qualified name and version, or None when those options are missing.
+        """
+        for options in parsed_model_spec.model_options.values():
+            name = options.get("base_model_name")
+            version = options.get("base_model_version")
+            if isinstance(name, str) and name and isinstance(version, str) and version:
+                return name, version
+        return None
+
+    def _fetch_model_spec_for_pin(
+        self,
+        pin_name: str,
+        pin_version: str,
+        *,
+        statement_params: dict[str, Any] | None = None,
+    ) -> model_spec.ModelSpec | None:
+        """Load a pin specification by fully-qualified name and version.
+
+        Args:
+            pin_name: Fully-qualified pin model name.
+            pin_version: Pin version name.
+            statement_params: Optional dictionary of statement parameters.
+
+        Returns:
+            The pin specification, or None when the name is unparsable or the pin cannot be loaded.
+        """
+        try:
+            database_name, schema_name, model_name = sql_identifier.parse_fully_qualified_name(pin_name)
+        except ValueError:
+            return None
+        if database_name is None or schema_name is None:
+            return None
+        try:
+            return self._fetch_model_spec(
+                database_name=database_name,
+                schema_name=schema_name,
+                model_name=model_name,
+                version_name=sql_identifier.SqlIdentifier(pin_version),
+                statement_params=statement_params,
+            )
+        except (
+            IndexError,
+            KeyError,
+            TypeError,
+            ValueError,
+            yaml.YAMLError,
+            snowpark_exceptions.SnowparkSQLException,
+        ) as err:
+            logger.debug("adapter model: could not load pin specification: %s", err)
+            return None
+
+    def _fetch_peft_pin_spec(
+        self,
+        parsed_model_spec: model_spec.ModelSpec,
+        *,
+        database_name: sql_identifier.SqlIdentifier | None,
+        schema_name: sql_identifier.SqlIdentifier | None,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: dict[str, Any] | None = None,
+    ) -> model_spec.ModelSpec | None:
+        """Load the pin model specification for an adapter version.
+
+        Prefers the current names from the adapter's upstream model lineage so a pin
+        rename still resolves. Blob options are used only when lineage has no model
+        upstream (the pin edge is not visible yet).
+
+        Args:
+            parsed_model_spec: Adapter specification whose blob options may name the pin.
+            database_name: Database of the adapter version.
+            schema_name: Schema of the adapter version.
+            model_name: Adapter model name.
+            version_name: Adapter version name.
+            statement_params: Optional dictionary of statement parameters.
+
+        Returns:
+            The pin specification, or None when the pin cannot be resolved or loaded.
+        """
+        lineage_pin = self._peft_pin_identity_from_lineage(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+        )
+        if lineage_pin == "blocked":
+            return None
+        if lineage_pin == "absent":
+            blob_pin = ModelOperator._peft_pin_identity_from_blob_options(parsed_model_spec)
+            if blob_pin is None:
+                return None
+            pin_name, pin_version = blob_pin
+        else:
+            pin_name, pin_version = lineage_pin
+        return self._fetch_model_spec_for_pin(
+            pin_name,
+            pin_version,
+            statement_params=statement_params,
+        )
+
+    @staticmethod
+    def _raise_unresolved_adapter_pin_signatures() -> NoReturn:
+        """Raise when adapter catalog methods cannot be mapped onto pin signatures.
+
+        Raises:
+            SnowflakeMLException: Always. Catalog methods exist but pin signatures could not be used.
+        """
+        raise exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=ValueError(
+                "adapter model: catalog methods exist but method signatures could not be resolved from the pin."
+            ),
+        )
+
     def get_functions(
         self,
         *,
@@ -1058,20 +1278,47 @@ class ModelOperator:
                 )
 
         signatures = parsed_model_spec.signatures
+        signature_spec = parsed_model_spec
+        is_peft_adapter = False
+        if not signatures and function_names_and_types:
+            is_peft_adapter = ModelOperator._is_peft_adapter_spec(parsed_model_spec)
+            if is_peft_adapter:
+                pin_spec = self._fetch_peft_pin_spec(
+                    parsed_model_spec,
+                    database_name=database_name,
+                    schema_name=schema_name,
+                    model_name=model_name,
+                    version_name=version_name,
+                    statement_params=statement_params,
+                )
+                if pin_spec is None or not pin_spec.signatures:
+                    ModelOperator._raise_unresolved_adapter_pin_signatures()
+                signatures = pin_spec.signatures
+                signature_spec = pin_spec
+
         function_names = [name for name, _, _ in function_names_and_types]
-        function_name_mapping = ModelOperator._match_model_spec_with_sql_functions(
-            function_names, list(signatures.keys())
-        )
+        try:
+            function_name_mapping = ModelOperator._match_model_spec_with_sql_functions(
+                function_names, list(signatures.keys())
+            )
+        except AssertionError:
+            if is_peft_adapter:
+                ModelOperator._raise_unresolved_adapter_pin_signatures()
+            raise
 
         model_func_info = []
 
         for function_name, function_type, is_object_output in function_names_and_types:
+            if function_name not in function_name_mapping:
+                if is_peft_adapter:
+                    ModelOperator._raise_unresolved_adapter_pin_signatures()
+                raise KeyError(function_name)
             target_method = function_name_mapping[function_name]
 
             is_partitioned = False
             if function_type == model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value:
                 # better to set default True here because worse case it will be slow but not error out
-                is_partitioned = parsed_model_spec.is_partitioned(target_method)
+                is_partitioned = signature_spec.is_partitioned(target_method)
 
             model_func_info.append(
                 model_manifest_schema.ModelFunctionInfo(