snowflake-ml-python 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

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/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/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/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(

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

@@ -9,6 +9,13 @@ from snowflake.snowpark import row
 _EMPTY_VERSION_RESULT_EXPECTED = "Expected 1 rows"
 _EMPTY_VERSION_RESULT_FOUND = "found: 0 rows"
 
+# Catalog propagation can take tens of seconds on a loaded account, so retries are bounded by elapsed
+# wall-clock time in addition to attempt count.
+SHOW_VERSIONS_RETRY_MAX_ATTEMPTS = 15
+SHOW_VERSIONS_RETRY_MAX_DELAY_MS = 60000
+SHOW_VERSIONS_RETRY_WAIT_MULTIPLIER_MS = 500
+SHOW_VERSIONS_RETRY_WAIT_MAX_MS = 5000
+
 
 def _is_empty_version_result(exc: BaseException) -> bool:
     if not isinstance(exc, connector.DataError):
@@ -104,9 +111,10 @@ class ModelSQLClient(_base._BaseSQLClient):
 
             versions: list[row.Row] = retrying.retry(
                 retry_on_exception=_is_empty_version_result,
-                stop_max_attempt_number=5,
-                wait_exponential_multiplier=100,
-                wait_exponential_max=10000,
+                stop_max_attempt_number=SHOW_VERSIONS_RETRY_MAX_ATTEMPTS,
+                stop_max_delay=SHOW_VERSIONS_RETRY_MAX_DELAY_MS,
+                wait_exponential_multiplier=SHOW_VERSIONS_RETRY_WAIT_MULTIPLIER_MS,
+                wait_exponential_max=SHOW_VERSIONS_RETRY_WAIT_MAX_MS,
             )(_execute)()
             return versions
         return _execute()

snowflake/ml/registry/_manager/model_manager.py

@@ -38,6 +38,21 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Retry once because another session can create the model between existence validation and model creation.
+_MAX_LOG_MODEL_ATTEMPTS_FOR_CREATE_MODEL_RACE = 2
+_OBJECT_ALREADY_EXISTS_SQL_ERROR_CODE = "100132"
+
+
+def _is_create_model_object_already_exists_error(
+    exc: snowpark_exceptions.SnowparkSQLException,
+) -> bool:
+    """True when Snowflake reports object already exists from CREATE MODEL (concurrent creation race)."""
+    return (
+        str(exc.sql_error_code) == _OBJECT_ALREADY_EXISTS_SQL_ERROR_CODE
+        or _OBJECT_ALREADY_EXISTS_SQL_ERROR_CODE in exc.message
+    )
+
+
 # Query-level custom_tags so telemetry can distinguish log_model SQL paths.
 MODEL_LOG_PATH_TAG = "model_log_path"
 MODEL_LOG_PATH_LIVE_COMMIT = "live_commit"
@@ -312,6 +327,69 @@ class ModelManager:
         experiment_info: "ExperimentInfo | None" = None,
         options: type_hints.ModelSaveOption | None = None,
         statement_params: dict[str, Any] | None = None,
+    ) -> model_version_impl.ModelVersion:
+        for attempt_index in range(_MAX_LOG_MODEL_ATTEMPTS_FOR_CREATE_MODEL_RACE):
+            try:
+                return self._log_model_after_existence_checks(
+                    model=model,
+                    model_name=model_name,
+                    version_name=version_name,
+                    progress_status=progress_status,
+                    comment=comment,
+                    metrics=metrics,
+                    conda_dependencies=conda_dependencies,
+                    pip_requirements=pip_requirements,
+                    artifact_repository_map=artifact_repository_map,
+                    resource_constraint=resource_constraint,
+                    target_platforms=target_platforms,
+                    python_version=python_version,
+                    signatures=signatures,
+                    sample_input_data=sample_input_data,
+                    user_files=user_files,
+                    code_paths=code_paths,
+                    ext_modules=ext_modules,
+                    task=task,
+                    experiment_info=experiment_info,
+                    options=options,
+                    statement_params=statement_params,
+                )
+            except snowpark_exceptions.SnowparkSQLException as exc:
+                if (
+                    attempt_index + 1 < _MAX_LOG_MODEL_ATTEMPTS_FOR_CREATE_MODEL_RACE
+                    and _is_create_model_object_already_exists_error(exc)
+                ):
+                    logger.info(
+                        "Model creation encountered a concurrent creation; retrying: %s",
+                        exc,
+                    )
+                    continue
+                raise
+        raise AssertionError("Model logging reached an unreachable state after exhausting retries.")  # pragma: no cover
+
+    def _log_model_after_existence_checks(
+        self,
+        *,
+        model: type_hints.SupportedModelType | model_version_impl.ModelVersion,
+        model_name: str,
+        version_name: str | None,
+        progress_status: type_hints.ProgressStatus,
+        comment: str | None = None,
+        metrics: dict[str, Any] | None = None,
+        conda_dependencies: list[str] | None = None,
+        pip_requirements: list[str] | None = None,
+        artifact_repository_map: dict[str, str] | None = None,
+        resource_constraint: dict[str, str] | None = None,
+        target_platforms: list[type_hints.SupportedTargetPlatformType] | None = None,
+        python_version: str | None = None,
+        signatures: dict[str, model_signature.ModelSignature] | None = None,
+        sample_input_data: type_hints.SupportedDataType | None = None,
+        user_files: dict[str, list[str]] | None = None,
+        code_paths: list[type_hints.CodePathLike] | None = None,
+        ext_modules: list[ModuleType] | None = None,
+        task: type_hints.Task = task.Task.UNKNOWN,
+        experiment_info: "ExperimentInfo | None" = None,
+        options: type_hints.ModelSaveOption | None = None,
+        statement_params: dict[str, Any] | None = None,
     ) -> model_version_impl.ModelVersion:
         database_name_id, schema_name_id, model_name_id = self._parse_fully_qualified_name(model_name)
 

snowflake/ml/version.py

@@ -1,2 +1,2 @@
 # This is parsed by regex in conda recipe meta file. Make sure not to break it.
-VERSION = "2.2.0"
+VERSION = "2.3.0"

{snowflake_ml_python-2.2.0.dist-info → snowflake_ml_python-2.3.0.dist-info}/METADATA

@@ -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.dist-info → snowflake_ml_python-2.3.0.dist-info}/RECORD

@@ -10,7 +10,7 @@ snowflake/cortex/_sse_client.py,sha256=pYsVOmU795LnGQnRE03ChGwQ17nKp7xVHeTpcToTo
 snowflake/cortex/_summarize.py,sha256=yvD-hxiqgB57eMwJDjrz437s0RfeQcG9r8PcG3R0Kuk,1267
 snowflake/cortex/_translate.py,sha256=yN09msgV1HMDk7ibDIrC1hux_LUJakY1KeYh7Z9yEPE,1588
 snowflake/cortex/_util.py,sha256=7CW-ISSp1FEOH_gQD0DouwqOJtiJLOHaFKTED33F3YE,3228
-snowflake/ml/version.py,sha256=Yv0GitnZjxJ6QMMFKiVgCOflrt_kMU5YW3nWiTjE9so,98
+snowflake/ml/version.py,sha256=PxEBviRkj5USpBkrj7P95vXbwxhkWgi2v4nu6LGrjcY,98
 snowflake/ml/_internal/env.py,sha256=EY_2KVe8oR3LgKWdaeRb5rRU-NDNXJppPDsFJmMZUUY,265
 snowflake/ml/_internal/env_utils.py,sha256=qmvqXgfdaxX25k_k4Jr5QWc5wuoyuI-s12ynZBjaRDI,34174
 snowflake/ml/_internal/file_utils.py,sha256=XQnRrjkS61e0He4mz2Ist-MwgLd4Rnodw_i6jEwszxM,15316
@@ -68,7 +68,7 @@ snowflake/ml/dataset/dataset_reader.py,sha256=5HI1ivKY6RO50yOdacI6aYe9U8zYq4h-Ca
 snowflake/ml/experiment/__init__.py,sha256=r7qdyPd3jwxzqvksim2ju5j_LrnYQrta0ZI6XpWUqmc,109
 snowflake/ml/experiment/_experiment_info.py,sha256=uPcso2A4ZUuR4jsXFjW64ztwQ1fVj3C3oHFqwz82hYY,2573
 snowflake/ml/experiment/_source_info.py,sha256=fvdk_bWbQn9Bv3T6vh4ZH77mntL1TfUXJW6GGp7eRWg,20115
-snowflake/ml/experiment/experiment_tracking.py,sha256=CLK5Bv2pPnKAwO386vPjm8Ft8Qf1rpTkghFtyQxnIr4,38538
+snowflake/ml/experiment/experiment_tracking.py,sha256=aBKxlIvSkTo41MvuHzfPEnuSMy7cCN1aAs67hqxmDcY,39534
 snowflake/ml/experiment/utils.py,sha256=zAxH1t-NcVbYeIt1Sfq2vX4dH4ozknQ7VClushnkHzE,817
 snowflake/ml/experiment/_client/artifact.py,sha256=R2WB4Y_kqv43BWLfXv8SEDINn1Bnevzgb-mH5LyvgGk,3035
 snowflake/ml/experiment/_client/experiment_tracking_sql_client.py,sha256=mqHJ35ovBeXs8stMbZgtS_INs8zEe42uCB3sNGeRFbk,14925
@@ -105,7 +105,7 @@ snowflake/ml/feature_store/request_source.py,sha256=ggof9GXZT6fCvbPT6c_LyJUXT7tL
 snowflake/ml/feature_store/stream_config.py,sha256=2Mns0CIOzPKeDrrtJoj7pufjMTwkx8fgTDbs4arxUbc,12325
 snowflake/ml/feature_store/stream_source.py,sha256=JOz60TIzyWlCHs6ITqaP8Hnd8YOA8i6N4hdC9lu-22Q,9493
 snowflake/ml/feature_store/streaming_registration.py,sha256=tAn7Vsbk2eMUNgAEGjREskzj-3U4HuKmoGlTebA5J8E,60727
-snowflake/ml/feature_store/tile_sql_generator.py,sha256=wHe0YuzZ6T9RaPaPqFOagMHsbk_d5JlWLR0637yjx30,100791
+snowflake/ml/feature_store/tile_sql_generator.py,sha256=03BOgvwGsLUj3bfLurwYvQYa4K6IrjzfsNA8jCGaqLQ,101656
 snowflake/ml/feature_store/examples/example_helper.py,sha256=2TA5d6oJlerUjR1kz3M6bWKCmOxznSoQcghiJZJLIvE,12448
 snowflake/ml/feature_store/examples/airline_features/entities.py,sha256=mzHRS-InHpXON0eHds-QLmi7nK9ciOnCruhPZI4niLs,438
 snowflake/ml/feature_store/examples/airline_features/source.yaml,sha256=kzl8ukOK8OuSPsxChEgJ9SPyPnzC-fPHqZC4O6aqd5o,247
@@ -140,7 +140,7 @@ snowflake/ml/fileset/snowfs.py,sha256=3SHuX43bokhd5Z7T333j0mByZ-4JbeyBk5fHLKIOiG
 snowflake/ml/fileset/stage_fs.py,sha256=0jdWkzw-Ovn5JIlxv-Eb2LU9YI-yKvrkE2ZVPty8GFY,20647
 snowflake/ml/jobs/__init__.py,sha256=EkEvFjhZpwLD84kcO0oYCA9rL-UQmU8wTuNXecreIG8,884
 snowflake/ml/jobs/decorators.py,sha256=O0Y4u5yS40L4CGD5H0N5xU5E403OTi2XtGnQi5XbXT0,4018
-snowflake/ml/jobs/job.py,sha256=KBfE7qIezp4I-w9vM1MApTp0ha3z_XM0KCPhdpei8bo,44933
+snowflake/ml/jobs/job.py,sha256=qAeE39XMtWh5neaodPVuxIMPsG2-vCeqwthpbc1jChk,45835
 snowflake/ml/jobs/job_definition.py,sha256=O4PZAFtDKtpLJ0Zt-e-FLCBSwDC0L3xs1UoNYX-obzU,27392
 snowflake/ml/jobs/manager.py,sha256=XjCvTyL4RYNdSa93iZ5761C7jfOQvWf-gmJdwhwamSg,24595
 snowflake/ml/jobs/_interop/__init__.py,sha256=RGilEHNPLoq8lu__pq-iHUkRx3A4xv3GRd_aBPXgdWQ,266
@@ -197,7 +197,7 @@ snowflake/ml/model/_client/model_spec/model_spec_parser.py,sha256=yJFsL2fFlvJ9gb
 snowflake/ml/model/_client/ops/deployment_step.py,sha256=OATDctajCjBkKnZiU3LvSZMh31WxXzCsDB_nf1DgFRQ,1394
 snowflake/ml/model/_client/ops/live_commit_naming.py,sha256=6G8nuMmVDrEl0HH4LqsWT5EB3JaUcaTD9fFOW34rmvg,647
 snowflake/ml/model/_client/ops/metadata_ops.py,sha256=aT3QWIeg-z4tM_Iniegkvr7SycvSQ5cfU0jXWR7N4rI,4847
-snowflake/ml/model/_client/ops/model_ops.py,sha256=jA6ujYB-VpT8g6WlXe0lHP-ZufwrCxHZp0aluWsLZK0,60018
+snowflake/ml/model/_client/ops/model_ops.py,sha256=monHS0AV148shsUI5JriW5n_v30-yFtnyXHitTRGE64,69920
 snowflake/ml/model/_client/ops/param_ops.py,sha256=AA7NfjUsYSv5hzCMrDMrLyRi_ueIKGktW1hBaBtsSgA,19966
 snowflake/ml/model/_client/ops/param_utils.py,sha256=WWLGLfXyblbZXsh9ulzr23fb2zoWcLOQPYBTWkKi3DQ,5374
 snowflake/ml/model/_client/ops/service_ops.py,sha256=5lz_N1APqHoFzfgz5lNqE6YEhKzGSnxxP_b0z7kzwbQ,63887
@@ -206,7 +206,7 @@ snowflake/ml/model/_client/service/inference_job_service_spec.py,sha256=Q23vAQkI
 snowflake/ml/model/_client/service/model_deployment_spec.py,sha256=7jhVxN8_AF6z2gKfb2iqPJ-_O4c6WPpuVbfAUPiBts8,19567
 snowflake/ml/model/_client/service/model_deployment_spec_schema.py,sha256=Gu3iH_zUEo8nsu8f6Cwb2sEhc_G6dBINKtY4hqXzsGM,3034
 snowflake/ml/model/_client/sql/_base.py,sha256=y4u3nmvruHGFXQ5hz9ANGmvduTKUH3M5GF69_v6_Q54,1438
-snowflake/ml/model/_client/sql/model.py,sha256=vcZY6WIgt7mem3TxLe06z0QbcdCC1S0r8xz4VLL8hiA,6871
+snowflake/ml/model/_client/sql/model.py,sha256=1RO37kFwFDiGwPEKSWbcJD0mglx3hG_BP75hR7cZOuc,7342
 snowflake/ml/model/_client/sql/model_version.py,sha256=xXPm7X5Y2VgfaVVDbH341rCkEcuGmWmUG2WDsnA4wH4,26441
 snowflake/ml/model/_client/sql/service.py,sha256=hFGVJqWHWZU6f-N8DmmPWFFHlYS9nI3wMsZcP_mRHcM,21484
 snowflake/ml/model/_client/sql/stage.py,sha256=W1SNeS-q4ZpSkG613Ajad4TB6DdFdwgnGMusQacH5H0,1195
@@ -534,15 +534,15 @@ snowflake/ml/monitoring/_manager/model_monitor_manager.py,sha256=OX99bu6W7ptHTXk
 snowflake/ml/monitoring/entities/model_monitor_config.py,sha256=sFueQ1_w9YogbFfu-K4Hdb0WFgZev3qiwR5xrRB6ACo,2219
 snowflake/ml/registry/__init__.py,sha256=XdPQK9ejYkSJVrSQ7HD3jKQO0hKq2mC4bPCB6qrtH3U,76
 snowflake/ml/registry/registry.py,sha256=ei9v-8-bAOEVydrafCdn4cIBVtIG-fpF2WTc4aesNJQ,37852
-snowflake/ml/registry/_manager/model_manager.py,sha256=E7pFTDaEWRFkWsDrQszm90DwSQCVWGvudahtDmNczQ8,41030
+snowflake/ml/registry/_manager/model_manager.py,sha256=NiZAurDE29jC5go5J_SQfbrfb2EI47bPZrKua5Q2BIk,44701
 snowflake/ml/registry/_manager/model_parameter_reconciler.py,sha256=7MEkXzhI4iSArW3lf5XyI6J0sd6twGAcdf2Hjn9qs4E,19937
 snowflake/ml/utils/authentication.py,sha256=UQeGgGYJkaFJf-EDohPlSWl0sAsGzMxv5d2wduikfAw,3082
 snowflake/ml/utils/html_utils.py,sha256=_jywZlZiy_oDx8dardkyoeTFRkqfTC8ZoFfz75o7ZE4,9870
 snowflake/ml/utils/sparse.py,sha256=nIoSfH0roCQ3QtaIltinDLqV4coCIw2pc2qT_FsFqEE,4116
 snowflake/ml/utils/sql_client.py,sha256=pSe2od6Pkh-8NwG3D-xqN76_uNf-ohOtVbT55HeQg1Y,668
 snowflake/ml/utils/stage_file.py,sha256=FHfFUPF1YG_l7iBYjCiUTVCL4-W5LFZE5mo9MuoD0E8,7910
-snowflake_ml_python-2.2.0.dist-info/licenses/LICENSE.txt,sha256=PdEp56Av5m3_kl21iFkVTX_EbHJKFGEdmYeIO1pL_Yk,11365
-snowflake_ml_python-2.2.0.dist-info/METADATA,sha256=OFw5iHYGKQCU55DTQYoAIhXlQauSYWddGWSbWrBjong,147429
-snowflake_ml_python-2.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-snowflake_ml_python-2.2.0.dist-info/top_level.txt,sha256=TY0gFSHKDdZy3THb0FGomyikWQasEGldIR1O0HGOHVw,10
-snowflake_ml_python-2.2.0.dist-info/RECORD,,
+snowflake_ml_python-2.3.0.dist-info/licenses/LICENSE.txt,sha256=PdEp56Av5m3_kl21iFkVTX_EbHJKFGEdmYeIO1pL_Yk,11365
+snowflake_ml_python-2.3.0.dist-info/METADATA,sha256=iaZjrQJcr6-hZKIpeVNlDAkhAxILmw96V1Fl9OtosMY,148105
+snowflake_ml_python-2.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+snowflake_ml_python-2.3.0.dist-info/top_level.txt,sha256=TY0gFSHKDdZy3THb0FGomyikWQasEGldIR1O0HGOHVw,10
+snowflake_ml_python-2.3.0.dist-info/RECORD,,