snowflake-ml-python 1.22.0__tar.gz → 1.23.0__tar.gz

{snowflake_ml_python-1.22.0 → snowflake_ml_python-1.23.0}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Release History
 
+## 1.23.0
+
+### New Features
+
+* ML Jobs: Enabled support for Python 3.11 and Python 3.12 by default. Jobs will automatically select a
+  runtime environment matching the client Python version.
+
+### Bug Fixes
+
+* Registry: Fix failures on empty output in HuggingFace's Token Classification (aka Named Entity Recognition) models.
+* Model serving: don't parse instance or container statuses to fix bug with missing container status.
+
+### Behavior Changes
+
+### Deprecations
+
 ## 1.22.0
 
 ### New Features
@@ -22,10 +38,60 @@ mv = registry.log_model(
 )
 ```
 
+* Registry: Added support for `image-text-to-text` task type in `huggingface.TransformersPipeline`.
+  Note: Requires vLLM inference engine while creating the service.
+
 ### Bug Fixes
 
 ### Behavior Changes
 
+* Registry: The `openai_signatures.OPENAI_CHAT_SIGNATURE` signature now handles content parts and
+  requires input data to be passed in list of dictionary. To use string content (previous behavior),
+  use `openai_signatures.OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING`.
+
+```python
+from snowflake.ml.model import openai_signatures
+import pandas as pd
+
+mv = snowflake_registry.log_model(
+    model=generator,
+    model_name=...,
+    ...,
+    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
+)
+
+# create a pd.DataFrame with openai.client.chat.completions arguments like below:
+x_df = pd.DataFrame.from_records(
+    [
+        {
+            "messages": [
+                {"role": "system", "content": "Complete the sentence."},
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "A descendant of the Lost City of Atlantis, who swam to Earth while saying, ",
+                        }
+                    ],
+                },
+            ],
+            "max_completion_tokens": 250,
+            "temperature": 0.9,
+            "stop": None,
+            "n": 3,
+            "stream": False,
+            "top_p": 1.0,
+            "frequency_penalty": 0.1,
+            "presence_penalty": 0.2,
+        }
+    ],
+)
+
+# OpenAI Chat Completion compatible output
+output_df = mv.run(X=x_df)
+```
+
 ### Deprecations
 
 ## 1.21.0

{snowflake_ml_python-1.22.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.22.0
+Version: 1.23.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,22 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.23.0
+
+### New Features
+
+* ML Jobs: Enabled support for Python 3.11 and Python 3.12 by default. Jobs will automatically select a
+  runtime environment matching the client Python version.
+
+### Bug Fixes
+
+* Registry: Fix failures on empty output in HuggingFace's Token Classification (aka Named Entity Recognition) models.
+* Model serving: don't parse instance or container statuses to fix bug with missing container status.
+
+### Behavior Changes
+
+### Deprecations
+
 ## 1.22.0
 
 ### New Features
@@ -439,10 +455,60 @@ mv = registry.log_model(
 )
 ```
 
+* Registry: Added support for `image-text-to-text` task type in `huggingface.TransformersPipeline`.
+  Note: Requires vLLM inference engine while creating the service.
+
 ### Bug Fixes
 
 ### Behavior Changes
 
+* Registry: The `openai_signatures.OPENAI_CHAT_SIGNATURE` signature now handles content parts and
+  requires input data to be passed in list of dictionary. To use string content (previous behavior),
+  use `openai_signatures.OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING`.
+
+```python
+from snowflake.ml.model import openai_signatures
+import pandas as pd
+
+mv = snowflake_registry.log_model(
+    model=generator,
+    model_name=...,
+    ...,
+    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
+)
+
+# create a pd.DataFrame with openai.client.chat.completions arguments like below:
+x_df = pd.DataFrame.from_records(
+    [
+        {
+            "messages": [
+                {"role": "system", "content": "Complete the sentence."},
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "A descendant of the Lost City of Atlantis, who swam to Earth while saying, ",
+                        }
+                    ],
+                },
+            ],
+            "max_completion_tokens": 250,
+            "temperature": 0.9,
+            "stop": None,
+            "n": 3,
+            "stream": False,
+            "top_p": 1.0,
+            "frequency_penalty": 0.1,
+            "presence_penalty": 0.2,
+        }
+    ],
+)
+
+# OpenAI Chat Completion compatible output
+output_df = mv.run(X=x_df)
+```
+
 ### Deprecations
 
 ## 1.21.0

{snowflake_ml_python-1.22.0 → snowflake_ml_python-1.23.0}/snowflake/ml/jobs/__init__.py

@@ -2,6 +2,7 @@ from snowflake.ml.jobs._interop.exception_utils import install_exception_display
 from snowflake.ml.jobs._utils.types import JOB_STATUS
 from snowflake.ml.jobs.decorators import remote
 from snowflake.ml.jobs.job import MLJob
+from snowflake.ml.jobs.job_definition import MLJobDefinition
 from snowflake.ml.jobs.manager import (
     delete_job,
     get_job,
@@ -24,4 +25,5 @@ __all__ = [
     "MLJob",
     "JOB_STATUS",
     "submit_from_stage",
+    "MLJobDefinition",
 ]

{snowflake_ml_python-1.22.0 → snowflake_ml_python-1.23.0}/snowflake/ml/jobs/_utils/constants.py

@@ -5,6 +5,7 @@ from snowflake.ml.jobs._utils.types import ComputeResources
 DEFAULT_CONTAINER_NAME = "main"
 MEMORY_VOLUME_NAME = "dshm"
 STAGE_VOLUME_NAME = "stage-volume"
+DEFAULT_PYTHON_VERSION = "3.10"
 
 # Environment variables
 STAGE_MOUNT_PATH_ENV_VAR = "MLRS_STAGE_MOUNT_PATH"

{snowflake_ml_python-1.22.0 → snowflake_ml_python-1.23.0}/snowflake/ml/jobs/_utils/payload_utils.py

@@ -11,6 +11,7 @@ from importlib.abc import Traversable
 from pathlib import Path, PurePath
 from types import ModuleType
 from typing import IO, Any, Callable, Optional, Union, cast, get_args, get_origin
+from uuid import uuid4
 
 import cloudpickle as cp
 from packaging import version
@@ -36,10 +37,15 @@ _SUPPORTED_ARG_TYPES = {str, int, float}
 _SUPPORTED_ENTRYPOINT_EXTENSIONS = {".py"}
 _ENTRYPOINT_FUNC_NAME = "func"
 _STARTUP_SCRIPT_PATH = PurePath("startup.sh")
+JOB_ID_PREFIX = "MLJOB_"
 
 
 def _compress_and_upload_file(
-    session: snowpark.Session, source_path: Path, stage_path: PurePath, import_path: Optional[str] = None
+    session: snowpark.Session,
+    source_path: Path,
+    stage_path: PurePath,
+    import_path: Optional[str] = None,
+    overwrite: bool = True,
 ) -> None:
     absolute_source_path = source_path.absolute()
     leading_path = absolute_source_path.as_posix()[: -len(import_path)] if import_path else None
@@ -49,11 +55,13 @@ def _compress_and_upload_file(
             cast(IO[bytes], stream),
             stage_path.joinpath(filename).as_posix(),
             auto_compress=False,
-            overwrite=True,
+            overwrite=overwrite,
         )
 
 
-def _upload_directory(session: snowpark.Session, source_path: Path, payload_stage_path: PurePath) -> None:
+def _upload_directory(
+    session: snowpark.Session, source_path: Path, payload_stage_path: PurePath, overwrite: bool = True
+) -> None:
     # Manually traverse the directory and upload each file, since Snowflake PUT
     # can't handle directories. Reduce the number of PUT operations by using
     # wildcard patterns to batch upload files with the same extension.
@@ -81,12 +89,14 @@ def _upload_directory(session: snowpark.Session, source_path: Path, payload_stag
         session.file.put(
             str(path),
             payload_stage_path.joinpath(path.parent.relative_to(source_path)).as_posix(),
-            overwrite=True,
+            overwrite=overwrite,
             auto_compress=False,
         )
 
 
-def upload_payloads(session: snowpark.Session, stage_path: PurePath, *payload_specs: types.PayloadSpec) -> None:
+def upload_payloads(
+    session: snowpark.Session, stage_path: PurePath, *payload_specs: types.PayloadSpec, overwrite: bool = True
+) -> None:
     for spec in payload_specs:
         source_path = spec.source_path
         remote_relative_path = spec.remote_relative_path
@@ -109,6 +119,7 @@ def upload_payloads(session: snowpark.Session, stage_path: PurePath, *payload_sp
                         source_path,
                         stage_path,
                         remote_relative_path.as_posix() if remote_relative_path else None,
+                        overwrite=overwrite,
                     )
                 else:
                     _upload_directory(session, source_path, payload_stage_path)
@@ -120,12 +131,13 @@ def upload_payloads(session: snowpark.Session, stage_path: PurePath, *payload_sp
                         source_path,
                         stage_path,
                         remote_relative_path.as_posix() if remote_relative_path else None,
+                        overwrite=overwrite,
                     )
                 else:
                     session.file.put(
                         str(source_path.resolve()),
                         payload_stage_path.as_posix(),
-                        overwrite=True,
+                        overwrite=overwrite,
                         auto_compress=False,
                     )
 
@@ -455,7 +467,9 @@ class JobPayload:
         self.pip_requirements = pip_requirements
         self.imports = imports
 
-    def upload(self, session: snowpark.Session, stage_path: Union[str, PurePath]) -> types.UploadedPayload:
+    def upload(
+        self, session: snowpark.Session, stage_path: Union[str, PurePath], overwrite: bool = False
+    ) -> types.UploadedPayload:
         # Prepare local variables
         stage_path = PurePath(stage_path) if isinstance(stage_path, str) else stage_path
         source = resolve_source(self.source)
@@ -482,7 +496,6 @@ class JobPayload:
 
         # Handle list entrypoints (custom commands like ["arctic_training"])
         if isinstance(entrypoint, (list, tuple)):
-            payload_name = entrypoint[0] if entrypoint else None
             # For list entrypoints, still upload source if it's a path
             if isinstance(source, Path):
                 upload_payloads(session, app_stage_path, types.PayloadSpec(source, None))
@@ -491,30 +504,24 @@ class JobPayload:
             python_entrypoint: list[Union[str, PurePath]] = list(entrypoint)
         else:
             # Standard file-based entrypoint handling
-            payload_name = None
             if not isinstance(source, types.PayloadPath):
-                if isinstance(source, function_payload_utils.FunctionPayload):
-                    payload_name = source.function.__name__
-
                 source_code = generate_python_code(source, source_code_display=True)
                 _ = session.file.put_stream(
                     io.BytesIO(source_code.encode()),
                     stage_location=app_stage_path.joinpath(entrypoint.file_path).as_posix(),
                     auto_compress=False,
-                    overwrite=True,
+                    overwrite=overwrite,
                 )
                 source = Path(entrypoint.file_path.parent)
 
             elif isinstance(source, stage_utils.StagePath):
-                payload_name = entrypoint.file_path.stem
                 # copy payload to stage
                 if source == entrypoint.file_path:
                     source = source.parent
-                upload_payloads(session, app_stage_path, types.PayloadSpec(source, None))
+                upload_payloads(session, app_stage_path, types.PayloadSpec(source, None), overwrite=overwrite)
 
             elif isinstance(source, Path):
-                payload_name = entrypoint.file_path.stem
-                upload_payloads(session, app_stage_path, types.PayloadSpec(source, None))
+                upload_payloads(session, app_stage_path, types.PayloadSpec(source, None), overwrite=overwrite)
                 if source.is_file():
                     source = source.parent
 
@@ -565,7 +572,6 @@ class JobPayload:
                 *python_entrypoint,
             ],
             env_vars=env_vars,
-            payload_name=payload_name,
         )
 
 
@@ -759,3 +765,17 @@ def create_function_payload(
     payload = function_payload_utils.FunctionPayload(func, session, session_argument, *bound.args, **bound.kwargs)
 
     return payload
+
+
+def get_payload_name(source: Union[str, Callable[..., Any]], entrypoint: Optional[Union[str, list[str]]] = None) -> str:
+
+    if entrypoint and isinstance(entrypoint, (list, tuple)):
+        return entrypoint[0]
+    elif entrypoint and isinstance(entrypoint, str):
+        return f"{PurePath(entrypoint).stem}"
+    elif source and not callable(source):
+        return f"{PurePath(source).stem}"
+    elif isinstance(source, function_payload_utils.FunctionPayload):
+        return f"{source.function.__name__}"
+    else:
+        return f"{JOB_ID_PREFIX}{str(uuid4()).replace('-', '_').upper()}"

{snowflake_ml_python-1.22.0 → snowflake_ml_python-1.23.0}/snowflake/ml/jobs/_utils/query_helper.py

@@ -14,10 +14,17 @@ def result_set_to_rows(session: snowpark.Session, result: dict[str, Any]) -> lis
 
 
 @snowflake_plan.SnowflakePlan.Decorator.wrap_exception  # type: ignore[misc]
-def run_query(session: snowpark.Session, query_text: str, params: Optional[Sequence[Any]] = None) -> list[Row]:
+def run_query(
+    session: snowpark.Session,
+    query_text: str,
+    params: Optional[Sequence[Any]] = None,
+    statement_params: Optional[dict[str, Any]] = None,
+) -> list[Row]:
     kwargs: dict[str, Any] = {"query": query_text, "params": params}
     if not is_in_stored_procedure():  # type: ignore[no-untyped-call]
         kwargs["_force_qmark_paramstyle"] = True
+    if statement_params:
+        kwargs["_statement_params"] = statement_params
     result = session._conn.run_query(**kwargs)
     if not isinstance(result, dict) or "data" not in result:
         raise ValueError(f"Unprocessable result: {result}")

snowflake_ml_python-1.23.0/snowflake/ml/jobs/_utils/runtime_env_utils.py

@@ -0,0 +1,117 @@
+import datetime
+import logging
+from typing import Any, Literal, Optional, Union
+
+from packaging.version import Version
+from pydantic import BaseModel, Field, RootModel, field_validator
+
+from snowflake import snowpark
+from snowflake.ml.jobs._utils import constants, query_helper
+
+
+class SpcsContainerRuntime(BaseModel):
+    python_version: Version = Field(alias="pythonVersion")
+    hardware_type: str = Field(alias="hardwareType")
+    runtime_container_image: str = Field(alias="runtimeContainerImage")
+
+    @field_validator("python_version", mode="before")
+    @classmethod
+    def validate_python_version(cls, v: Union[str, Version]) -> Version:
+        if isinstance(v, Version):
+            return v
+        try:
+            return Version(v)
+        except Exception:
+            raise ValueError(f"Invalid Python version format: {v}")
+
+    class Config:
+        frozen = True
+        extra = "allow"
+        arbitrary_types_allowed = True
+
+
+class RuntimeEnvironmentEntry(BaseModel):
+    spcs_container_runtime: Optional[SpcsContainerRuntime] = Field(alias="spcsContainerRuntime", default=None)
+    created_on: datetime.datetime = Field(alias="createdOn")
+    id: Optional[str] = Field(alias="id")
+
+    class Config:
+        extra = "allow"
+        frozen = True
+
+
+class RuntimeEnvironmentsDict(RootModel[dict[str, RuntimeEnvironmentEntry]]):
+    @field_validator("root", mode="before")
+    @classmethod
+    def _filter_to_dict_entries(cls, data: Any) -> dict[str, dict[str, Any]]:
+        """
+        Pre-validation hook: keep only those items at the root level
+        whose values are dicts. Non-dict values will be dropped.
+
+        Args:
+            data: The input data to filter, expected to be a dictionary.
+
+        Returns:
+            A dictionary containing only the key-value pairs where values are dictionaries.
+
+        Raises:
+            ValueError: If input data is not a dictionary.
+        """
+        # If the entire root is not a dict, raise error immediately
+        if not isinstance(data, dict):
+            raise ValueError(f"Expected dictionary data, but got {type(data).__name__}: {data}")
+
+        # Filter out any key whose value is not a dict
+        return {key: value for key, value in data.items() if isinstance(value, dict)}
+
+    def get_spcs_container_runtimes(
+        self,
+        *,
+        hardware_type: Optional[str] = None,
+        python_version: Optional[Version] = None,
+    ) -> list[SpcsContainerRuntime]:
+        # TODO(SNOW-2682000): parse version from NRE in a safer way, like relying on the label,id or image tag.
+        entries: list[RuntimeEnvironmentEntry] = [
+            entry
+            for entry in self.root.values()
+            if entry.spcs_container_runtime is not None
+            and (hardware_type is None or entry.spcs_container_runtime.hardware_type.lower() == hardware_type.lower())
+            and (
+                python_version is None
+                or (
+                    entry.spcs_container_runtime.python_version.major == python_version.major
+                    and entry.spcs_container_runtime.python_version.minor == python_version.minor
+                )
+            )
+        ]
+        entries.sort(key=lambda e: e.created_on, reverse=True)
+
+        return [entry.spcs_container_runtime for entry in entries if entry.spcs_container_runtime is not None]
+
+
+def _extract_image_tag(image_url: str) -> Optional[str]:
+    image_tag = image_url.rsplit(":", 1)[-1]
+    return image_tag
+
+
+def find_runtime_image(
+    session: snowpark.Session, target_hardware: Literal["CPU", "GPU"], target_python_version: Optional[str] = None
+) -> Optional[str]:
+    python_version = (
+        Version(target_python_version) if target_python_version else Version(constants.DEFAULT_PYTHON_VERSION)
+    )
+    rows = query_helper.run_query(session, "CALL SYSTEM$NOTEBOOKS_FIND_LABELED_RUNTIMES()")
+    if not rows:
+        return None
+    try:
+        runtime_envs = RuntimeEnvironmentsDict.model_validate_json(rows[0][0])
+        spcs_container_runtimes = runtime_envs.get_spcs_container_runtimes(
+            hardware_type=target_hardware,
+            python_version=python_version,
+        )
+    except Exception as e:
+        logging.warning(f"Failed to parse runtime image name from {rows[0][0]}, error: {e}")
+        return None
+
+    selected_runtime = spcs_container_runtimes[0] if spcs_container_runtimes else None
+    return selected_runtime.runtime_container_image if selected_runtime else None

{snowflake_ml_python-1.22.0 → snowflake_ml_python-1.23.0}/snowflake/ml/jobs/_utils/stage_utils.py

@@ -52,7 +52,7 @@ class StagePath:
         if self._path.parent == Path(""):
             return StagePath(self._root)
         else:
-            return StagePath(f"{self._root}/{self._path.parent}")
+            return StagePath(f"{self._root}/{self._path.parent.as_posix()}")
 
     @property
     def root(self) -> str:
@@ -67,7 +67,7 @@ class StagePath:
         if path == Path(""):
             return self.root
         else:
-            return f"{self.root}/{path}"
+            return f"{self.root}/{path.as_posix()}"
 
     def is_relative_to(self, *other: Union[str, os.PathLike[str]]) -> bool:
         if not other:

{snowflake_ml_python-1.22.0 → snowflake_ml_python-1.23.0}/snowflake/ml/jobs/_utils/types.py

@@ -1,7 +1,7 @@
 import os
 from dataclasses import dataclass, field
 from pathlib import PurePath
-from typing import Literal, Optional, Protocol, Union, runtime_checkable
+from typing import Any, Literal, Optional, Protocol, Union, runtime_checkable
 
 from typing_extensions import Self
 
@@ -103,7 +103,6 @@ class UploadedPayload:
     stage_path: PurePath
     entrypoint: list[Union[str, PurePath]]
     env_vars: dict[str, str] = field(default_factory=dict)
-    payload_name: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -128,3 +127,24 @@ class ServiceInfo:
     status: str
     compute_pool: str
     target_instances: int
+
+
+@dataclass
+class JobOptions:
+    external_access_integrations: Optional[list[str]] = None
+    query_warehouse: Optional[str] = None
+    target_instances: Optional[int] = None
+    min_instances: Optional[int] = None
+    use_async: Optional[bool] = True
+    generate_suffix: Optional[bool] = True
+
+
+@dataclass
+class SpecOptions:
+    stage_path: str
+    args: Optional[list[str]] = None
+    env_vars: Optional[dict[str, str]] = None
+    enable_metrics: Optional[bool] = None
+    spec_overrides: Optional[dict[str, Any]] = None
+    runtime: Optional[str] = None
+    enable_stage_mount_v2: Optional[bool] = True