snowflake-ml-python 1.24.0__tar.gz → 1.25.0__tar.gz

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Release History
 
+## 1.25.0
+
+### New Features
+
+* ML Job: Added support for creating ML job definitions and launching jobs with different
+  arguments without re-uploading payloads.
+
+* Inference Autocapture (PuPr): The `create_service` API will now accept `autocapture` as a new argument to indicate
+  whether inference data will be captured.
+
+* Model serving: Introduced the `min_instances` field in the `mv.create_service()` and
+  `HuggingFacePipelineModel.log_model_and_create_service()` APIs (defaulting to 0). The service now launches
+  with the `min_instances` and automatically scales between `min_instances` and `max_instances` based on
+  traffic and hardware utilization. When `min_instances` is set to 0, the service will automatically suspend
+  if no traffic is detected for a period of time.
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Inference Autocapture (PuPr): `list_services()` now shows `autocapture_enabled` column to indicate if model
+  service has autocapture enabled.
+
+* Model serving: The `mv.create_service()` and `HuggingFacePipelineModel.log_model_and_create_service()` APIs now
+  include a `min_instances` field (defaulting to 0). When these APIs are called without specifying `min_instances`,
+  the system will now launch the service with 1 instance and enable auto scaling. This replaces the previous behavior,
+  where `min_instances` was automatically set to match `max_instances`, resulting in the immediate launch of the
+  maximum number of instances.
+
+### Deprecations
+
 ## 1.24.0
 
 ### New Features
@@ -103,7 +134,15 @@ x_df = pd.DataFrame.from_records(
     [
         {
             "messages": [
-                {"role": "system", "content": "Complete the sentence."},
+                {
+                  "role": "system",
+                  "content": [
+                        {
+                            "type": "text",
+                            "text": "Complete the sentence."
+                        },
+                  ]
+                },
                 {
                     "role": "user",
                     "content": [

{snowflake_ml_python-1.24.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.24.0
+Version: 1.25.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: 
@@ -417,6 +417,37 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.25.0
+
+### New Features
+
+* ML Job: Added support for creating ML job definitions and launching jobs with different
+  arguments without re-uploading payloads.
+
+* Inference Autocapture (PuPr): The `create_service` API will now accept `autocapture` as a new argument to indicate
+  whether inference data will be captured.
+
+* Model serving: Introduced the `min_instances` field in the `mv.create_service()` and
+  `HuggingFacePipelineModel.log_model_and_create_service()` APIs (defaulting to 0). The service now launches
+  with the `min_instances` and automatically scales between `min_instances` and `max_instances` based on
+  traffic and hardware utilization. When `min_instances` is set to 0, the service will automatically suspend
+  if no traffic is detected for a period of time.
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Inference Autocapture (PuPr): `list_services()` now shows `autocapture_enabled` column to indicate if model
+  service has autocapture enabled.
+
+* Model serving: The `mv.create_service()` and `HuggingFacePipelineModel.log_model_and_create_service()` APIs now
+  include a `min_instances` field (defaulting to 0). When these APIs are called without specifying `min_instances`,
+  the system will now launch the service with 1 instance and enable auto scaling. This replaces the previous behavior,
+  where `min_instances` was automatically set to match `max_instances`, resulting in the immediate launch of the
+  maximum number of instances.
+
+### Deprecations
+
 ## 1.24.0
 
 ### New Features
@@ -520,7 +551,15 @@ x_df = pd.DataFrame.from_records(
     [
         {
             "messages": [
-                {"role": "system", "content": "Complete the sentence."},
+                {
+                  "role": "system",
+                  "content": [
+                        {
+                            "type": "text",
+                            "text": "Complete the sentence."
+                        },
+                  ]
+                },
                 {
                     "role": "user",
                     "content": [

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/_internal/utils/mixins.py

@@ -9,6 +9,7 @@ _SESSION_ACCOUNT_KEY = "session$account"
 _SESSION_ROLE_KEY = "session$role"
 _SESSION_DATABASE_KEY = "session$database"
 _SESSION_SCHEMA_KEY = "session$schema"
+_SESSION_STATE_ATTR = "_session_state"
 
 
 def _identifiers_match(saved: Optional[str], current: Optional[str]) -> bool:
@@ -61,7 +62,7 @@ class SerializableSessionMixin:
         else:
             self.__dict__.update(state)
 
-        self._set_session(session_state)
+        setattr(self, _SESSION_STATE_ATTR, session_state)
 
     def _set_session(self, session_state: _SessionState) -> None:
 
@@ -86,3 +87,27 @@ class SerializableSessionMixin:
                     ),
                 ),
             )
+
+    @property
+    def session(self) -> Optional[snowpark_session.Session]:
+        if _SESSION_KEY not in self.__dict__:
+            session_state = getattr(self, _SESSION_STATE_ATTR, None)
+            if session_state is not None:
+                self._set_session(session_state)
+        return self.__dict__.get(_SESSION_KEY)
+
+    @session.setter
+    def session(self, value: Optional[snowpark_session.Session]) -> None:
+        self.__dict__[_SESSION_KEY] = value
+
+    # _getattr__ is only called when an attribute is NOT found through normal lookup.
+    # 1. Data descriptors (like @property with setter) from the class hierarchy
+    # 2. Instance __dict__ (e.g., self.x = 10)
+    # 3. Non-data descriptors (methods, `@property without setter) from the class hierarchy
+    # __getattr__ — only called if steps 1-3 all fail
+    def __getattr__(self, name: str) -> Any:
+        if name == _SESSION_KEY:
+            return self.session
+        if hasattr(super(), "__getattr__"):
+            return super().__getattr__(name)  # type: ignore[misc]
+        raise AttributeError(f"{type(self).__name__!s} object has no attribute {name!r}")

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/data/_internal/arrow_ingestor.py

@@ -73,15 +73,19 @@ class ArrowIngestor(data_ingestor.DataIngestor, mixins.SerializableSessionMixin)
         self._schema: Optional[pa.Schema] = None
 
     @classmethod
-    def from_sources(cls, session: snowpark.Session, sources: Sequence[data_source.DataSource]) -> "ArrowIngestor":
+    def from_sources(
+        cls, session: snowpark.Session, sources: Sequence[data_source.DataSource], **kwargs: Any
+    ) -> "ArrowIngestor":
         if session is None:
             raise ValueError("Session is required")
+        # Skipping kwargs until needed to avoid impact other workflows.
         return cls(session, sources)
 
     @classmethod
     def from_ray_dataset(
         cls,
         ray_ds: "ray.data.Dataset",
+        **kwargs: Any,
     ) -> "ArrowIngestor":
         raise NotImplementedError
 

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/data/data_connector.py

@@ -94,7 +94,7 @@ class DataConnector:
         **kwargs: Any,
     ) -> DataConnectorType:
         ingestor_class = ingestor_class or cls.DEFAULT_INGESTOR_CLASS
-        ray_ingestor = ingestor_class.from_ray_dataset(ray_ds=ray_ds)
+        ray_ingestor = ingestor_class.from_ray_dataset(ray_ds=ray_ds, **kwargs)
         return cls(ray_ingestor, **kwargs)
 
     @classmethod
@@ -111,7 +111,7 @@ class DataConnector:
         **kwargs: Any,
     ) -> DataConnectorType:
         ingestor_class = ingestor_class or cls.DEFAULT_INGESTOR_CLASS
-        ingestor = ingestor_class.from_sources(session, sources)
+        ingestor = ingestor_class.from_sources(session, sources, **kwargs)
         return cls(ingestor, **kwargs)
 
     @property

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/data/data_ingestor.py

@@ -16,7 +16,7 @@ DataIngestorType = TypeVar("DataIngestorType", bound="DataIngestor")
 class DataIngestor(Protocol):
     @classmethod
     def from_sources(
-        cls: type[DataIngestorType], session: snowpark.Session, sources: Sequence[data_source.DataSource]
+        cls: type[DataIngestorType], session: snowpark.Session, sources: Sequence[data_source.DataSource], **kwargs: Any
     ) -> DataIngestorType:
         raise NotImplementedError
 
@@ -24,6 +24,7 @@ class DataIngestor(Protocol):
     def from_ray_dataset(
         cls: type[DataIngestorType],
         ray_ds: "ray.data.Dataset",
+        **kwargs: Any,
     ) -> DataIngestorType:
         raise NotImplementedError
 

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/experiment/_experiment_info.py

@@ -3,7 +3,7 @@ import functools
 import types
 from typing import Callable, Optional
 
-from snowflake.ml import model
+from snowflake.ml.model._client.model import model_version_impl
 from snowflake.ml.registry._manager import model_manager
 
 
@@ -23,7 +23,7 @@ class ExperimentInfoPatcher:
     """
 
     # Store original method at class definition time to avoid recursive patching
-    _original_log_model: Callable[..., model.ModelVersion] = model_manager.ModelManager.log_model
+    _original_log_model: Callable[..., model_version_impl.ModelVersion] = model_manager.ModelManager.log_model
 
     # Stack of active experiment_info contexts for nested experiment support
     _experiment_info_stack: list[ExperimentInfo] = []
@@ -36,7 +36,7 @@ class ExperimentInfoPatcher:
         if not ExperimentInfoPatcher._experiment_info_stack:
 
             @functools.wraps(ExperimentInfoPatcher._original_log_model)
-            def patched(*args, **kwargs) -> model.ModelVersion:  # type: ignore[no-untyped-def]
+            def patched(*args, **kwargs) -> model_version_impl.ModelVersion:  # type: ignore[no-untyped-def]
                 # Use the most recent (top of stack) experiment_info for nested contexts
                 current_experiment_info = ExperimentInfoPatcher._experiment_info_stack[-1]
                 return ExperimentInfoPatcher._original_log_model(

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/jobs/_interop/data_utils.py

@@ -31,7 +31,7 @@ class StageFileWriter(io.IOBase):
             # Only upload if buffer has content and no exception occurred
             if write_contents and self._buffer.tell() > 0:
                 self._buffer.seek(0)
-                self._session.file.put_stream(self._buffer, self._path)
+                self._session.file.put_stream(self._buffer, self._path, auto_compress=False)
             self._buffer.close()
             self._closed = True
 
@@ -84,15 +84,15 @@ class DtoCodec(Protocol):
 
     @overload
     @staticmethod
-    def decode(stream: io.IOBase, as_dict: Literal[False] = False) -> dto_schema.ResultDTO:
+    def decode(stream: io.IOBase, as_dict: Literal[False] = False) -> dto_schema.PayloadDTO:
         ...
 
     @staticmethod
-    def decode(stream: io.IOBase, as_dict: bool = False) -> Union[dto_schema.ResultDTO, dict[str, Any]]:
+    def decode(stream: io.IOBase, as_dict: bool = False) -> Union[dto_schema.PayloadDTO, dict[str, Any]]:
         pass
 
     @staticmethod
-    def encode(dto: dto_schema.ResultDTO) -> bytes:
+    def encode(dto: dto_schema.PayloadDTO) -> bytes:
         pass
 
 
@@ -104,18 +104,18 @@ class JsonDtoCodec(DtoCodec):
 
     @overload
     @staticmethod
-    def decode(stream: io.IOBase, as_dict: Literal[False] = False) -> dto_schema.ResultDTO:
+    def decode(stream: io.IOBase, as_dict: Literal[False] = False) -> dto_schema.PayloadDTO:
         ...
 
     @staticmethod
-    def decode(stream: io.IOBase, as_dict: bool = False) -> Union[dto_schema.ResultDTO, dict[str, Any]]:
+    def decode(stream: io.IOBase, as_dict: bool = False) -> Union[dto_schema.PayloadDTO, dict[str, Any]]:
         data = cast(dict[str, Any], json.load(stream))
         if as_dict:
             return data
-        return dto_schema.ResultDTO.model_validate(data)
+        return dto_schema.ResultDTOAdapter.validate_python(data)
 
     @staticmethod
-    def encode(dto: dto_schema.ResultDTO) -> bytes:
+    def encode(dto: dto_schema.PayloadDTO) -> bytes:
         # Temporarily extract the value to avoid accidentally applying model_dump() on it
         result_value = dto.value
         dto.value = None  # Clear value to avoid serializing it in the model_dump

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/jobs/_interop/dto_schema.py

@@ -1,7 +1,7 @@
-from typing import Any, Optional, Union
+from typing import Any, Literal, Optional, Union
 
-from pydantic import BaseModel, model_validator
-from typing_extensions import NotRequired, TypedDict
+from pydantic import BaseModel, Discriminator, Tag, TypeAdapter, model_validator
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class BinaryManifest(TypedDict):
@@ -67,22 +67,47 @@ class ExceptionMetadata(ResultMetadata):
     traceback: str
 
 
-class ResultDTO(BaseModel):
+class PayloadDTO(BaseModel):
+    """
+    Base class for serializable payloads.
+
+    Args:
+        kind: Discriminator field for DTO type dispatch.
+        value: The payload value (if JSON-serializable).
+        protocol: The protocol used to serialize the payload (if not JSON-serializable).
+    """
+
+    kind: Literal["base"] = "base"
+    value: Optional[Any] = None
+    protocol: Optional[ProtocolInfo] = None
+    serialize_error: Optional[str] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_fields(cls, data: Any) -> Any:
+        """Ensure at least one of value or protocol keys is specified."""
+        if cls is PayloadDTO and isinstance(data, dict):
+            required_fields = {"value", "protocol"}
+            if not any(field in data for field in required_fields):
+                raise ValueError("At least one of 'value' or 'protocol' must be specified")
+        return data
+
+
+class ResultDTO(PayloadDTO):
     """
     A JSON representation of an execution result.
 
     Args:
+        kind: Discriminator field for DTO type dispatch.
         success: Whether the execution was successful.
         value: The value of the execution or the exception if the execution failed.
         protocol: The protocol used to serialize the result.
         metadata: The metadata of the result.
     """
 
+    kind: Literal["result"] = "result"  # type: ignore[assignment]
     success: bool
-    value: Optional[Any] = None
-    protocol: Optional[ProtocolInfo] = None
     metadata: Optional[Union[ResultMetadata, ExceptionMetadata]] = None
-    serialize_error: Optional[str] = None
 
     @model_validator(mode="before")
     @classmethod
@@ -93,3 +118,23 @@ class ResultDTO(BaseModel):
             if not any(field in data for field in required_fields):
                 raise ValueError("At least one of 'value', 'protocol', or 'metadata' must be specified")
         return data
+
+
+def _get_dto_kind(data: Any) -> str:
+    """Extract the 'kind' discriminator from input, defaulting to 'result' for backward compatibility."""
+    if isinstance(data, dict):
+        kind = data.get("kind", "result")
+    else:
+        kind = getattr(data, "kind", "result")
+    return str(kind)
+
+
+AnyResultDTO = Annotated[
+    Union[
+        Annotated[ResultDTO, Tag("result")],
+        Annotated[PayloadDTO, Tag("base")],
+    ],
+    Discriminator(_get_dto_kind),
+]
+
+ResultDTOAdapter: TypeAdapter[AnyResultDTO] = TypeAdapter(AnyResultDTO)

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.0}/snowflake/ml/jobs/_interop/protocols.py

@@ -17,6 +17,8 @@ Condition = Union[type, tuple[type, ...], Callable[[Any], bool], None]
 
 logger = logging.getLogger(__name__)
 
+SESSION_KEY_PREFIX = "session@"
+
 
 class SerializationError(TypeError):
     """Exception raised when a serialization protocol fails."""
@@ -136,9 +138,10 @@ class CloudPickleProtocol(SerializationProtocol):
 
     def save(self, obj: Any, dest_dir: str, session: Optional[snowpark.Session] = None) -> ProtocolInfo:
         """Save the object to the destination directory."""
+        replaced_obj = self._pack_obj(obj)
         result_path = posixpath.join(dest_dir, self.DEFAULT_PATH)
         with data_utils.open_stream(result_path, "wb", session=session) as f:
-            self._backend.dump(obj, f)
+            self._backend.dump(replaced_obj, f)
         manifest: BinaryManifest = {"path": result_path}
         return self.protocol_info.with_manifest(manifest)
 
@@ -157,12 +160,15 @@ class CloudPickleProtocol(SerializationProtocol):
         payload_manifest = cast(BinaryManifest, payload_info.manifest)
         try:
             if payload_bytes := payload_manifest.get("bytes"):
-                return self._backend.loads(payload_bytes)
-            if payload_b64 := payload_manifest.get("base64"):
-                return self._backend.loads(base64.b64decode(payload_b64))
-            result_path = path_transform(payload_manifest["path"]) if path_transform else payload_manifest["path"]
-            with data_utils.open_stream(result_path, "rb", session=session) as f:
-                return self._backend.load(f)
+                result = self._backend.loads(payload_bytes)
+            elif payload_b64 := payload_manifest.get("base64"):
+                result = self._backend.loads(base64.b64decode(payload_b64))
+            else:
+                result_path = path_transform(payload_manifest["path"]) if path_transform else payload_manifest["path"]
+                with data_utils.open_stream(result_path, "rb", session=session) as f:
+                    result = self._backend.load(f)
+
+            return self._unpack_obj(result, session=session)
         except (
             pickle.UnpicklingError,
             TypeError,
@@ -173,6 +179,117 @@ class CloudPickleProtocol(SerializationProtocol):
                 raise error from pickle_error
             raise
 
+    def _pack_obj(self, obj: Any) -> Any:
+        """Pack objects into JSON-safe dicts using reserved marker keys.
+
+        Markers:
+        - "type@": container type for list/tuple (list or tuple)
+        - "#<i>": positional element for list/tuple at index i
+        - "session@": placeholder for snowpark.Session values
+          - "session@#<i>" for list/tuple entries
+          - "session@<key>" for dict entries
+          - {"session@": None} for a bare Session object
+
+        Example:
+            obj = {"x": [1, session], "s": session}
+            packed = {
+                "x": {"type@": list, "#0": 1, "session@#1": None},
+                "session@s": None,
+            }
+            _unpack_obj(packed, session) == obj
+
+        Args:
+            obj: Object to pack into JSON-safe marker dictionaries.
+
+        Returns:
+            Packed representation with markers for session references.
+        """
+        arguments: dict[str, Any] = {}
+        if isinstance(obj, tuple) or isinstance(obj, list):
+            arguments = {"type@": type(obj)}
+            for i, arg in enumerate(obj):
+                if isinstance(arg, snowpark.Session):
+                    arguments[f"{SESSION_KEY_PREFIX}#{i}"] = None
+                else:
+                    arguments[f"#{i}"] = self._pack_obj(arg)
+            return arguments
+        elif isinstance(obj, dict):
+            for k, v in obj.items():
+                if isinstance(v, snowpark.Session):
+                    arguments[f"{SESSION_KEY_PREFIX}{k}"] = None
+                else:
+                    arguments[k] = self._pack_obj(v)
+            return arguments
+        elif isinstance(obj, snowpark.Session):
+            # Box session into a dict marker so we can distinguish it from other plain objects.
+            arguments[f"{SESSION_KEY_PREFIX}"] = None
+            return arguments
+        else:
+            return obj
+
+    def _unpack_obj(self, obj: Any, session: Optional[snowpark.Session] = None) -> Any:
+        """Unpack dict markers back into containers and Session references.
+
+        Markers:
+        - "type@": container type for list/tuple (list or tuple)
+        - "#<i>": positional element for list/tuple at index i
+        - "session@": placeholder for snowpark.Session values
+          - "session@#<i>" for list/tuple entries
+          - "session@<key>" for dict entries
+          - {"session@": None} for a bare Session object
+
+        Example:
+            packed = {
+                "x": {"type@": list, "#0": 1, "session@#1": None},
+                "session@s": None,
+            }
+            obj = _unpack_obj(packed, session)
+            # obj == {"x": [1, session], "s": session}
+
+        Args:
+            obj: Packed object with marker dictionaries.
+            session: Session to inject for session markers.
+
+        Returns:
+            Unpacked object with session references restored.
+        """
+        if not isinstance(obj, dict):
+            return obj
+        elif len(obj) == 1 and SESSION_KEY_PREFIX in obj:
+            return session
+        else:
+            type = obj.get("type@", None)
+            # If type is None, we are unpacking a dict
+            if type is None:
+                result_dict = {}
+                for k, v in obj.items():
+                    if k.startswith(SESSION_KEY_PREFIX):
+                        result_key = k[len(SESSION_KEY_PREFIX) :]
+                        result_dict[result_key] = session
+                    else:
+                        result_dict[k] = self._unpack_obj(v, session)
+                return result_dict
+            # If type is not None, we are unpacking a tuple or list
+            else:
+                indexes = []
+                for k, _ in obj.items():
+                    if "#" in k:
+                        indexes.append(int(k.split("#")[-1]))
+
+                if not indexes:
+                    return tuple() if type is tuple else []
+                result_list: list[Any] = [None] * (max(indexes) + 1)
+
+                for k, v in obj.items():
+                    if k == "type@":
+                        continue
+                    idx = int(k.split("#")[-1])
+                    if k.startswith(SESSION_KEY_PREFIX):
+                        result_list[idx] = session
+                    else:
+                        result_list[idx] = self._unpack_obj(v, session)
+                return tuple(result_list) if type is tuple else result_list
+
 
 class ArrowTableProtocol(SerializationProtocol):
     """