snowflake-ml-python 1.11.0__tar.gz → 1.12.0__tar.gz

{snowflake_ml_python-1.11.0 → snowflake_ml_python-1.12.0}/CHANGELOG.md

@@ -1,6 +1,67 @@
 # Release History
 
-## 1.11.0
+## 1.12.0
+
+### Bug Fixes
+
+* Registry: Fixed an issue where the string representation of dictionary-type output columns was being incorrectly
+  created during structured output deserialization. Now, the original data type is properly preserved.
+
+### Behavior Changes
+
+### New Features
+
+* Registry: Add OpenAI chat completion compatible signature option for `text-generation` models.
+
+```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": "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)
+```
+
+* Model Monitoring: Added support for segment columns to enable filtered analysis.
+  * Added `segment_columns` parameter to `ModelMonitorSourceConfig` to specify columns for segmenting monitoring data
+  * Segment columns must be of STRING type and exist in the source table
+  * Added methods to dynamically manage segments:
+    * `add_segment_column()`: Add a new segment column to an existing monitor
+    * `drop_segment_column()`: Remove a segment column from an existing monitor
+* Experiment Tracking (PrPr): Support for logging artifacts (files and directories) with `log_artifact`
+* Experiment Tracking (PrPr): Support for listing artifacts in a run with `list_artifacts`
+* Experiment Tracking (PrPr): Support for downloading artifacts in a run with `download_artifacts`
+
+## 1.11.0 (08-12-2025)
 
 ### Bug Fixes
 

{snowflake_ml_python-1.11.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.11.0
+Version: 1.12.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: 
@@ -244,17 +244,17 @@ Requires-Dist: numpy<3,>=1.23
 Requires-Dist: packaging<25,>=20.9
 Requires-Dist: pandas<3,>=2.1.4
 Requires-Dist: platformdirs<5
-Requires-Dist: pyarrow
+Requires-Dist: pyarrow<19.0.0
 Requires-Dist: pydantic<3,>=2.8.2
 Requires-Dist: pyjwt<3,>=2.0.0
 Requires-Dist: pytimeparse<2,>=1.1.8
 Requires-Dist: pyyaml<7,>=6.0
 Requires-Dist: retrying<2,>=1.3.3
 Requires-Dist: s3fs<2026,>=2024.6.1
-Requires-Dist: scikit-learn<1.6
+Requires-Dist: scikit-learn<1.7
 Requires-Dist: scipy<2,>=1.9
 Requires-Dist: shap<1,>=0.46.0
-Requires-Dist: snowflake-connector-python[pandas]<4,>=3.15.0
+Requires-Dist: snowflake-connector-python[pandas]<4,>=3.16.0
 Requires-Dist: snowflake-snowpark-python!=1.26.0,<2,>=1.17.0
 Requires-Dist: snowflake.core<2,>=1.0.2
 Requires-Dist: sqlparse<1,>=0.4
@@ -410,7 +410,68 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.11.0
+## 1.12.0
+
+### Bug Fixes
+
+* Registry: Fixed an issue where the string representation of dictionary-type output columns was being incorrectly
+  created during structured output deserialization. Now, the original data type is properly preserved.
+
+### Behavior Changes
+
+### New Features
+
+* Registry: Add OpenAI chat completion compatible signature option for `text-generation` models.
+
+```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": "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)
+```
+
+* Model Monitoring: Added support for segment columns to enable filtered analysis.
+  * Added `segment_columns` parameter to `ModelMonitorSourceConfig` to specify columns for segmenting monitoring data
+  * Segment columns must be of STRING type and exist in the source table
+  * Added methods to dynamically manage segments:
+    * `add_segment_column()`: Add a new segment column to an existing monitor
+    * `drop_segment_column()`: Remove a segment column from an existing monitor
+* Experiment Tracking (PrPr): Support for logging artifacts (files and directories) with `log_artifact`
+* Experiment Tracking (PrPr): Support for listing artifacts in a run with `list_artifacts`
+* Experiment Tracking (PrPr): Support for downloading artifacts in a run with `download_artifacts`
+
+## 1.11.0 (08-12-2025)
 
 ### Bug Fixes
 

{snowflake_ml_python-1.11.0 → snowflake_ml_python-1.12.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "The machine learning client library that is used for interacting
 classifiers = [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Environment :: Other Environment", "Intended Audience :: Developers", "Intended Audience :: Education", "Intended Audience :: Information Technology", "Intended Audience :: System Administrators", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Database", "Topic :: Software Development", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Scientific/Engineering :: Information Analysis",]
 requires-python = ">=3.9, <3.13"
 dynamic = [ "version", "readme",]
-dependencies = [ "absl-py>=0.15,<2", "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<25", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "s3fs>=2024.6.1,<2026", "scikit-learn<1.6", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.15.0,<4", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "snowflake.core>=1.0.2,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost>=1.7.3,<3",]
+dependencies = [ "absl-py>=0.15,<2", "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<25", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow<19.0.0", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "s3fs>=2024.6.1,<2026", "scikit-learn<1.7", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.16.0,<4", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "snowflake.core>=1.0.2,<2", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost>=1.7.3,<3",]
 [[project.authors]]
 name = "Snowflake, Inc"
 email = "support@snowflake.com"

{snowflake_ml_python-1.11.0 → snowflake_ml_python-1.12.0}/snowflake/cortex/_complete.py

@@ -88,7 +88,7 @@ class MidStreamException(Exception):
             message = reason
         if http_resp:
             message = f"Error in stream (HTTP Response: {http_resp.status}) - {http_resp.reason}"
-        if request_id != "":
+        if request_id is not None and request_id != "":
             # add request_id to error message
             message += f" (Request ID: {request_id})"
         super().__init__(message)
@@ -327,7 +327,8 @@ def _return_stream_response(
             # This is the case of midstream errors which were introduced specifically for structured output.
             # TODO: discuss during code review
             if parsed_resp.get("error"):
-                raise MidStreamException(reason=response.text, request_id=request_id)
+                error_info = parsed_resp["error"]
+                raise MidStreamException(reason=str(error_info), request_id=request_id)
             else:
                 pass
 

{snowflake_ml_python-1.11.0 → snowflake_ml_python-1.12.0}/snowflake/ml/_internal/utils/service_logger.py

@@ -9,8 +9,33 @@ from typing import Optional
 
 import platformdirs
 
+
+class ProgressBarAwareConsoleHandler(logging.StreamHandler):  # type: ignore[type-arg]
+    """A logging handler that adapts to different progress bar systems to avoid interfering with display."""
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+
+            # Check if tqdm progress bars are active - use tqdm.write() to avoid interference
+            try:
+                import tqdm
+
+                if hasattr(tqdm.tqdm, "_instances") and tqdm.tqdm._instances:
+                    tqdm.tqdm.write(msg, file=self.stream)
+                    return
+            except (ImportError, AttributeError):
+                pass
+
+            # Fallback to regular stream writing (works for all contexts including Streamlit)
+            self.stream.write(msg + "\n")
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+
 # Module-level logger for operational messages that should appear on console
-stdout_handler = logging.StreamHandler(sys.stdout)
+stdout_handler = ProgressBarAwareConsoleHandler(sys.stdout)
 stdout_handler.setFormatter(logging.Formatter("%(message)s"))
 
 console_logger = logging.getLogger(__name__)

snowflake_ml_python-1.12.0/snowflake/ml/experiment/_client/artifact.py

@@ -0,0 +1,76 @@
+import os
+import posixpath
+from typing import NamedTuple
+
+
+class ArtifactInfo(NamedTuple):
+    name: str
+    size: int
+    md5: str
+    last_modified: str
+
+
+def get_put_path_pairs(local_path: str, artifact_path: str) -> list[tuple[str, str]]:
+    """Enumerate files to upload and their destination subdirectories.
+
+    Expands a local path (file or directory) into a list of pairs used for uploading
+    artifacts to the stage.
+
+    Args:
+        local_path: Absolute or relative path to a local file or directory to upload.
+        artifact_path: Destination subdirectory under the run's artifact root in the
+            stage. If empty, files are uploaded to the root. When uploading a
+            directory, this value is prepended to each file's relative path.
+
+    Returns:
+        A list of tuples ``(local_file_path, destination_artifact_subdir)``. For a
+        single file, the list contains one entry with ``destination_artifact_subdir``
+        set to ``artifact_path``. For directories, one entry per file is produced and
+        subdirectories are preserved using POSIX separators.
+
+    Raises:
+        FileNotFoundError: If ``local_path`` does not exist.
+    """
+    if not os.path.exists(local_path):
+        raise FileNotFoundError(f"Local path does not exist: {local_path}")
+
+    if os.path.isfile(local_path):
+        return [(local_path, artifact_path)]
+
+    pairs: list[tuple[str, str]] = []
+    base_dir = local_path
+    for root, _, files in os.walk(base_dir):
+        if not files:
+            continue
+        rel_dir = os.path.relpath(root, base_dir)
+        rel_dir_posix = "" if rel_dir in (".", "") else rel_dir.replace(os.sep, "/")
+        dest_artifact_path = posixpath.join(artifact_path, rel_dir_posix) if rel_dir_posix else artifact_path
+        for filename in files:
+            file_path = os.path.join(root, filename)
+            pairs.append((file_path, dest_artifact_path))
+    return pairs
+
+
+def get_download_path_pairs(artifacts: list[ArtifactInfo], base_target_dir: str) -> list[tuple[str, str]]:
+    """Given artifact metadata entries, computes where each artifact should be written
+    locally.
+
+    Args:
+        artifacts: List of artifact metadata where ``name`` is a POSIX-style path
+            relative to the run's artifact root (e.g., ``"file.txt"`` or
+            ``"nested/dir/file.txt"``).
+        base_target_dir: Local base directory to download into. If empty, the
+            current working directory is used. Directories will be created as
+            needed.
+
+    Returns:
+        A list of tuples ``(artifact_relative_path, local_directory)``. Each tuple
+        provides the relative path to request from the stage and the local directory
+        where the file should be written.
+    """
+    planned: list[tuple[str, str]] = []
+    for info in artifacts:
+        rel_dir = os.path.dirname(info.name)
+        local_dir = base_target_dir if rel_dir in ("", ".") else os.path.join(base_target_dir, rel_dir)
+        planned.append((info.name, local_dir))
+    return planned

{snowflake_ml_python-1.11.0 → snowflake_ml_python-1.12.0}/snowflake/ml/experiment/_client/experiment_tracking_sql_client.py

@@ -1,9 +1,10 @@
 from typing import Optional
 
 from snowflake.ml._internal.utils import query_result_checker, sql_identifier
+from snowflake.ml.experiment._client import artifact
 from snowflake.ml.model._client.sql import _base
 from snowflake.ml.utils import sql_client
-from snowflake.snowpark import row, session
+from snowflake.snowpark import file_operation, row, session
 
 
 class ExperimentTrackingSQLClient(_base._BaseSQLClient):
@@ -88,6 +89,59 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
             f"ALTER EXPERIMENT {experiment_fqn} MODIFY RUN {run_name} SET METADATA=$${run_metadata}$$",
         ).has_dimensions(expected_rows=1, expected_cols=1).validate()
 
+    def put_artifact(
+        self,
+        *,
+        experiment_name: sql_identifier.SqlIdentifier,
+        run_name: sql_identifier.SqlIdentifier,
+        artifact_path: str,
+        file_path: str,
+        auto_compress: bool = False,
+    ) -> file_operation.PutResult:
+        return self._session.file.put(
+            local_file_name=file_path,
+            stage_location=self._build_snow_uri(experiment_name, run_name, artifact_path),
+            overwrite=True,
+            auto_compress=auto_compress,
+        )[0]
+
+    def list_artifacts(
+        self,
+        *,
+        experiment_name: sql_identifier.SqlIdentifier,
+        run_name: sql_identifier.SqlIdentifier,
+        artifact_path: str,
+    ) -> list[artifact.ArtifactInfo]:
+        results = (
+            query_result_checker.SqlResultValidator(
+                self._session, f"LIST {self._build_snow_uri(experiment_name, run_name, artifact_path)}"
+            )
+            .has_dimensions(expected_cols=4)
+            .validate()
+        )
+        return [
+            artifact.ArtifactInfo(
+                name=str(result.name).removeprefix(f"/versions/{run_name}/"),
+                size=result.size,
+                md5=result.md5,
+                last_modified=result.last_modified,
+            )
+            for result in results
+        ]
+
+    def get_artifact(
+        self,
+        *,
+        experiment_name: sql_identifier.SqlIdentifier,
+        run_name: sql_identifier.SqlIdentifier,
+        artifact_path: str,
+        target_path: str,
+    ) -> file_operation.GetResult:
+        return self._session.file.get(
+            stage_location=self._build_snow_uri(experiment_name, run_name, artifact_path),
+            target_directory=target_path,
+        )[0]
+
     def show_runs_in_experiment(
         self, *, experiment_name: sql_identifier.SqlIdentifier, like: Optional[str] = None
     ) -> list[row.Row]:
@@ -96,3 +150,12 @@ class ExperimentTrackingSQLClient(_base._BaseSQLClient):
         return query_result_checker.SqlResultValidator(
             self._session, f"SHOW RUNS {like_clause} IN EXPERIMENT {experiment_fqn}"
         ).validate()
+
+    def _build_snow_uri(
+        self, experiment_name: sql_identifier.SqlIdentifier, run_name: sql_identifier.SqlIdentifier, artifact_path: str
+    ) -> str:
+        experiment_fqn = self.fully_qualified_object_name(self._database_name, self._schema_name, experiment_name)
+        uri = f"snow://experiment/{experiment_fqn}/versions/{run_name}"
+        if artifact_path:
+            uri += f"/{artifact_path}"
+        return uri

{snowflake_ml_python-1.11.0 → snowflake_ml_python-1.12.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -5,14 +5,17 @@ from typing import Any, Optional, Union
 from urllib.parse import quote
 
 import snowflake.snowpark._internal.utils as snowpark_utils
-from snowflake.ml import model, registry
+from snowflake.ml import model as ml_model, registry
 from snowflake.ml._internal.human_readable_id import hrid_generator
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.experiment import (
     _entities as entities,
     _experiment_info as experiment_info,
 )
-from snowflake.ml.experiment._client import experiment_tracking_sql_client as sql_client
+from snowflake.ml.experiment._client import (
+    artifact,
+    experiment_tracking_sql_client as sql_client,
+)
 from snowflake.ml.model import type_hints
 from snowflake.ml.utils import sql_client as sql_client_utils
 from snowflake.snowpark import session
@@ -118,11 +121,11 @@ class ExperimentTracking:
     @functools.wraps(registry.Registry.log_model)
     def log_model(
         self,
-        model: Union[type_hints.SupportedModelType, model.ModelVersion],
+        model: Union[type_hints.SupportedModelType, ml_model.ModelVersion],
         *,
         model_name: str,
         **kwargs: Any,
-    ) -> model.ModelVersion:
+    ) -> ml_model.ModelVersion:
         run = self._get_or_start_run()
         with experiment_info.ExperimentInfoPatcher(experiment_info=run._get_experiment_info()):
             return self._registry.log_model(model, model_name=model_name, **kwargs)
@@ -280,6 +283,88 @@ class ExperimentTracking:
             run_metadata=json.dumps(metadata.to_dict()),
         )
 
+    def log_artifact(
+        self,
+        local_path: str,
+        artifact_path: Optional[str] = None,
+    ) -> None:
+        """
+        Log an artifact or a directory of artifacts under the current run. If no run is active, this method will create
+        a new run.
+
+        Args:
+            local_path: The path to the local file or directory to write.
+            artifact_path: The directory within the run directory to write the artifacts to. If None, the artifacts will
+                be logged in the root directory of the run.
+        """
+        run = self._get_or_start_run()
+        for file_path, dest_artifact_path in artifact.get_put_path_pairs(local_path, artifact_path or ""):
+            self._sql_client.put_artifact(
+                experiment_name=run.experiment_name,
+                run_name=run.name,
+                artifact_path=dest_artifact_path,
+                file_path=file_path,
+            )
+
+    def list_artifacts(
+        self,
+        run_name: str,
+        artifact_path: Optional[str] = None,
+    ) -> list[artifact.ArtifactInfo]:
+        """
+        List artifacts for a given run within the current experiment.
+
+        Args:
+            run_name: Name of the run to list artifacts from.
+            artifact_path: Optional subdirectory within the run's artifact directory to scope the listing.
+                If None, lists from the root of the run's artifact directory.
+
+        Returns:
+            A list of artifact entries under the specified path.
+
+        Raises:
+            RuntimeError: If no experiment is currently set.
+        """
+        if not self._experiment:
+            raise RuntimeError("No experiment set. Please set an experiment before listing artifacts.")
+
+        return self._sql_client.list_artifacts(
+            experiment_name=self._experiment.name,
+            run_name=sql_identifier.SqlIdentifier(run_name),
+            artifact_path=artifact_path or "",
+        )
+
+    def download_artifacts(
+        self,
+        run_name: str,
+        artifact_path: Optional[str] = None,
+        target_path: Optional[str] = None,
+    ) -> None:
+        """
+        Download artifacts from a run to a local directory.
+
+        Args:
+            run_name: Name of the run to download artifacts from.
+            artifact_path: Optional path to file or subdirectory within the run's artifact directory to download.
+                If None, downloads all artifacts from the root of the run's artifact directory.
+            target_path: Optional local directory to download files into. If None, downloads into the
+                current working directory.
+
+        Raises:
+            RuntimeError: If no experiment is currently set.
+        """
+        if not self._experiment:
+            raise RuntimeError("No experiment set. Please set an experiment before downloading artifacts.")
+
+        artifacts = self.list_artifacts(run_name=run_name, artifact_path=artifact_path or "")
+        for relative_path, local_dir in artifact.get_download_path_pairs(artifacts, target_path or ""):
+            self._sql_client.get_artifact(
+                experiment_name=self._experiment.name,
+                run_name=sql_identifier.SqlIdentifier(run_name),
+                artifact_path=relative_path,
+                target_path=local_dir,
+            )
+
     def _get_or_set_experiment(self) -> entities.Experiment:
         if self._experiment:
             return self._experiment