snowflake-ml-python 1.9.1__py3-none-any.whl → 1.9.2__py3-none-any.whl

snowflake/ml/jobs/_utils/stage_utils.py

@@ -14,7 +14,10 @@ _SNOWURL_PATH_RE = re.compile(
     r"(?P<path>versions(?:/(?P<version>[^/]+)(?:/(?P<relpath>.*))?)?)$"
 )
 
-_STAGEF_PATH_RE = re.compile(r"^@(?P<stage>~|%?\w+)(?:/(?P<relpath>[\w\-./]*))?$")
+# Break long regex into two main parts
+_STAGE_PATTERN = rf"~|%?(?:(?:{identifier._SF_IDENTIFIER}\.?){{,2}}{identifier._SF_IDENTIFIER})"
+_RELPATH_PATTERN = r"[\w\-./]*"
+_STAGEF_PATH_RE = re.compile(rf"^@(?P<stage>{_STAGE_PATTERN})(?:/(?P<relpath>{_RELPATH_PATTERN}))?$")
 
 
 class StagePath:
@@ -29,6 +32,14 @@ class StagePath:
         self._root = self._raw_path[0:start].rstrip("/") if relpath else self._raw_path.rstrip("/")
         self._path = Path(relpath or "")
 
+    @property
+    def parts(self) -> tuple[str, ...]:
+        return self._path.parts
+
+    @property
+    def name(self) -> str:
+        return self._path.name
+
     @property
     def parent(self) -> "StagePath":
         if self._path.parent == Path(""):
@@ -51,18 +62,28 @@ class StagePath:
         else:
             return f"{self.root}/{path}"
 
-    def is_relative_to(self, path: Union[str, PathLike[str], "StagePath"]) -> bool:
+    def is_relative_to(self, *other: Union[str, os.PathLike[str]]) -> bool:
+        if not other:
+            raise TypeError("is_relative_to() requires at least one argument")
+        # For now, we only support a single argument, like pathlib.Path in Python < 3.12
+        path = other[0]
         stage_path = path if isinstance(path, StagePath) else StagePath(os.fspath(path))
         if stage_path.root == self.root:
             return self._path.is_relative_to(stage_path._path)
         else:
             return False
 
-    def relative_to(self, path: Union[str, PathLike[str], "StagePath"]) -> PurePath:
+    def relative_to(self, *other: Union[str, os.PathLike[str]]) -> PurePath:
+        if not other:
+            raise TypeError("relative_to() requires at least one argument")
+        if not self.is_relative_to(*other):
+            raise ValueError(f"{other} does not start with {self._raw_path}")
+        path = other[0]
         stage_path = path if isinstance(path, StagePath) else StagePath(os.fspath(path))
         if self.root == stage_path.root:
             return self._path.relative_to(stage_path._path)
-        raise ValueError(f"{self._raw_path} does not start with {stage_path._raw_path}")
+        else:
+            raise ValueError(f"{self._raw_path} does not start with {stage_path._raw_path}")
 
     def absolute(self) -> "StagePath":
         return self
@@ -88,6 +109,9 @@ class StagePath:
     def __str__(self) -> str:
         return self.as_posix()
 
+    def __repr__(self) -> str:
+        return f"StagePath('{self.as_posix()}')"
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, StagePath):
             raise NotImplementedError
@@ -96,24 +120,16 @@ class StagePath:
     def __fspath__(self) -> str:
         return self._compose_path(self._path)
 
-    def joinpath(self, *args: Union[str, PathLike[str], "StagePath"]) -> "StagePath":
+    def joinpath(self, *args: Union[str, PathLike[str]]) -> "StagePath":
         path = self
         for arg in args:
             path = path._make_child(arg)
         return path
 
-    def _make_child(self, path: Union[str, PathLike[str], "StagePath"]) -> "StagePath":
+    def _make_child(self, path: Union[str, PathLike[str]]) -> "StagePath":
         stage_path = path if isinstance(path, StagePath) else StagePath(os.fspath(path))
         if self.root == stage_path.root:
             child_path = self._path.joinpath(stage_path._path)
             return StagePath(self._compose_path(child_path))
         else:
             return stage_path
-
-
-def identify_stage_path(path: str) -> Union[StagePath, Path]:
-    try:
-        stage_path = StagePath(path)
-    except ValueError:
-        return Path(path)
-    return stage_path

snowflake/ml/jobs/_utils/types.py

@@ -1,8 +1,7 @@
+import os
 from dataclasses import dataclass
 from pathlib import PurePath
-from typing import Literal, Optional, Union
-
-from snowflake.ml.jobs._utils import stage_utils
+from typing import Iterator, Literal, Optional, Protocol, Union, runtime_checkable
 
 JOB_STATUS = Literal[
     "PENDING",
@@ -15,9 +14,70 @@ JOB_STATUS = Literal[
 ]
 
 
+@runtime_checkable
+class PayloadPath(Protocol):
+    """A protocol for path-like objects used in this module, covering methods from pathlib.Path and StagePath."""
+
+    @property
+    def name(self) -> str:
+        ...
+
+    @property
+    def suffix(self) -> str:
+        ...
+
+    @property
+    def parent(self) -> "PayloadPath":
+        ...
+
+    def exists(self) -> bool:
+        ...
+
+    def is_file(self) -> bool:
+        ...
+
+    def is_absolute(self) -> bool:
+        ...
+
+    def absolute(self) -> "PayloadPath":
+        ...
+
+    def joinpath(self, *other: Union[str, os.PathLike[str]]) -> "PayloadPath":
+        ...
+
+    def as_posix(self) -> str:
+        ...
+
+    def is_relative_to(self, *other: Union[str, os.PathLike[str]]) -> bool:
+        ...
+
+    def relative_to(self, *other: Union[str, os.PathLike[str]]) -> PurePath:
+        ...
+
+    def __fspath__(self) -> str:
+        ...
+
+    def __str__(self) -> str:
+        ...
+
+    def __repr__(self) -> str:
+        ...
+
+
+@dataclass
+class PayloadSpec:
+    """Represents a payload item to be uploaded."""
+
+    source_path: PayloadPath
+    remote_relative_path: Optional[PurePath] = None
+
+    def __iter__(self) -> Iterator[Union[PayloadPath, Optional[PurePath]]]:
+        return iter((self.source_path, self.remote_relative_path))
+
+
 @dataclass(frozen=True)
 class PayloadEntrypoint:
-    file_path: Union[PurePath, stage_utils.StagePath]
+    file_path: PayloadPath
     main_func: Optional[str]
 
 

snowflake/ml/jobs/job.py

@@ -3,6 +3,7 @@ import logging
 import os
 import time
 from functools import cached_property
+from pathlib import Path
 from typing import Any, Generic, Literal, Optional, TypeVar, Union, cast, overload
 
 import yaml
@@ -95,10 +96,24 @@ class MLJob(Generic[T], SerializableSessionMixin):
     @property
     def _result_path(self) -> str:
         """Get the job's result file location."""
-        result_path = self._container_spec["env"].get(constants.RESULT_PATH_ENV_VAR)
-        if result_path is None:
+        result_path_str = self._container_spec["env"].get(constants.RESULT_PATH_ENV_VAR)
+        if result_path_str is None:
             raise RuntimeError(f"Job {self.name} doesn't have a result path configured")
-        return f"{self._stage_path}/{result_path}"
+        volume_mounts = self._container_spec["volumeMounts"]
+        stage_mount_str = next(v for v in volume_mounts if v.get("name") == constants.STAGE_VOLUME_NAME)["mountPath"]
+
+        result_path = Path(result_path_str)
+        stage_mount = Path(stage_mount_str)
+        try:
+            relative_path = result_path.relative_to(stage_mount)
+        except ValueError:
+            if result_path.is_absolute():
+                raise ValueError(
+                    f"Result path {result_path} is absolute, but should be relative to stage mount {stage_mount}"
+                )
+            relative_path = result_path
+
+        return f"{self._stage_path}/{relative_path.as_posix()}"
 
     @overload
     def get_logs(
@@ -181,7 +196,10 @@ class MLJob(Generic[T], SerializableSessionMixin):
         start_time = time.monotonic()
         warning_shown = False
         while (status := self.status) not in TERMINAL_JOB_STATUSES:
-            if status == "PENDING" and not warning_shown:
+            elapsed = time.monotonic() - start_time
+            if elapsed >= timeout >= 0:
+                raise TimeoutError(f"Job {self.name} did not complete within {timeout} seconds")
+            elif status == "PENDING" and not warning_shown and elapsed >= 2:  # Only show warning after 2s
                 pool_info = _get_compute_pool_info(self._session, self._compute_pool)
                 if (pool_info.max_nodes - pool_info.active_nodes) < self.min_instances:
                     logger.warning(
@@ -189,8 +207,6 @@ class MLJob(Generic[T], SerializableSessionMixin):
                         f"{self.min_instances} nodes required). Job execution may be delayed."
                     )
                     warning_shown = True
-            if timeout >= 0 and (elapsed := time.monotonic() - start_time) >= timeout:
-                raise TimeoutError(f"Job {self.name} did not complete within {elapsed} seconds")
             time.sleep(delay)
             delay = min(delay * 1.2, constants.JOB_POLL_MAX_DELAY_SECONDS)  # Exponential backoff
         return self.status

snowflake/ml/jobs/manager.py

@@ -447,6 +447,10 @@ def _submit_job(
     spec_overrides = kwargs.pop("spec_overrides", None)
     enable_metrics = kwargs.pop("enable_metrics", True)
     query_warehouse = kwargs.pop("query_warehouse", None)
+    additional_payloads = kwargs.pop("additional_payloads", None)
+
+    if additional_payloads:
+        logger.warning("'additional_payloads' is in private preview since 1.9.1. Do not use it in production.")
 
     # Warn if there are unknown kwargs
     if kwargs:
@@ -477,9 +481,7 @@ def _submit_job(
 
     # Upload payload
     uploaded_payload = payload_utils.JobPayload(
-        source,
-        entrypoint=entrypoint,
-        pip_requirements=pip_requirements,
+        source, entrypoint=entrypoint, pip_requirements=pip_requirements, additional_payloads=additional_payloads
     ).upload(session, stage_path)
 
     # Generate service spec

snowflake/ml/model/_client/ops/service_ops.py

@@ -96,11 +96,13 @@ class ServiceLogMetadata:
         msg: str,
         is_model_build_service_done: bool,
         is_model_logger_service_done: bool,
+        operation_id: str,
         propagate: bool = False,
     ) -> None:
         to_service_logger = service_logger.get_logger(
             f"{to_service.display_service_name}-{to_service.instance_id}",
             to_service.log_color,
+            operation_id=operation_id,
         )
         to_service_logger.propagate = propagate
         self.service_logger = to_service_logger
@@ -196,6 +198,9 @@ class ServiceOperator:
         hf_model_args: Optional[HFModelArgs] = None,
     ) -> Union[str, async_job.AsyncJob]:
 
+        # Generate operation ID for this deployment
+        operation_id = service_logger.get_operation_id()
+
         # Fall back to the registry's database and schema if not provided
         database_name = database_name or self._database_name
         schema_name = schema_name or self._schema_name
@@ -327,6 +332,7 @@ class ServiceOperator:
             model_inference_service=model_inference_service,
             model_inference_service_exists=model_inference_service_exists,
             force_rebuild=force_rebuild,
+            operation_id=operation_id,
             statement_params=statement_params,
         )
 
@@ -347,6 +353,7 @@ class ServiceOperator:
         model_inference_service: ServiceLogInfo,
         model_inference_service_exists: bool,
         force_rebuild: bool,
+        operation_id: str,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> threading.Thread:
         """Start the service log streaming in a separate thread."""
@@ -360,6 +367,7 @@ class ServiceOperator:
                 model_inference_service,
                 model_inference_service_exists,
                 force_rebuild,
+                operation_id,
                 statement_params,
             ),
         )
@@ -372,6 +380,7 @@ class ServiceOperator:
         service_log_meta: ServiceLogMetadata,
         model_build_service: ServiceLogInfo,
         model_inference_service: ServiceLogInfo,
+        operation_id: str,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         """Helper function to fetch logs and update the service log metadata if needed.
@@ -386,6 +395,7 @@ class ServiceOperator:
             service_log_meta: The ServiceLogMetadata holds the state of the service log metadata.
             model_build_service: The ServiceLogInfo for the model build service.
             model_inference_service: The ServiceLogInfo for the model inference service.
+            operation_id: The operation ID for the service, e.g. "model_deploy_a1b2c3d4_1703875200"
             statement_params: The statement parameters to use for the service client.
         """
 
@@ -415,6 +425,7 @@ class ServiceOperator:
                     "Model build is not rebuilding the inference image, but using a previously built image.",
                     is_model_build_service_done=True,
                     is_model_logger_service_done=service_log_meta.is_model_logger_service_done,
+                    operation_id=operation_id,
                 )
 
         try:
@@ -488,6 +499,7 @@ class ServiceOperator:
                     f"Model Logger service {service.display_service_name} complete.",
                     is_model_build_service_done=False,
                     is_model_logger_service_done=service_log_meta.is_model_logger_service_done,
+                    operation_id=operation_id,
                 )
             # check if model build service is done
             # and transition the service log metadata to the model inference service
@@ -497,6 +509,7 @@ class ServiceOperator:
                     f"Image build service {service.display_service_name} complete.",
                     is_model_build_service_done=True,
                     is_model_logger_service_done=service_log_meta.is_model_logger_service_done,
+                    operation_id=operation_id,
                 )
             else:
                 module_logger.warning(f"Service {service.display_service_name} is done, but not transitioning.")
@@ -509,6 +522,7 @@ class ServiceOperator:
         model_inference_service: ServiceLogInfo,
         model_inference_service_exists: bool,
         force_rebuild: bool,
+        operation_id: str,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         """Stream service logs while the async job is running."""
@@ -516,14 +530,14 @@ class ServiceOperator:
         model_build_service_logger = service_logger.get_logger(  # BuildJobName
             model_build_service.display_service_name,
             model_build_service.log_color,
+            operation_id=operation_id,
         )
-        model_build_service_logger.propagate = False
         if model_logger_service:
             model_logger_service_logger = service_logger.get_logger(  # ModelLoggerName
                 model_logger_service.display_service_name,
                 model_logger_service.log_color,
+                operation_id=operation_id,
             )
-            model_logger_service_logger.propagate = False
 
             service_log_meta = ServiceLogMetadata(
                 service_logger=model_logger_service_logger,
@@ -557,6 +571,7 @@ class ServiceOperator:
                     force_rebuild=force_rebuild,
                     model_build_service=model_build_service,
                     model_inference_service=model_inference_service,
+                    operation_id=operation_id,
                     statement_params=statement_params,
                 )
             except Exception as ex:

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

@@ -2,7 +2,7 @@ import dataclasses
 import enum
 import logging
 import textwrap
-from typing import Any, Optional, Union
+from typing import Any, Optional
 
 from snowflake import snowpark
 from snowflake.ml._internal.utils import (
@@ -69,43 +69,6 @@ class ServiceSQLClient(_base._BaseSQLClient):
     CONTAINER_STATUS = "status"
     MESSAGE = "message"
 
-    def build_model_container(
-        self,
-        *,
-        database_name: Optional[sql_identifier.SqlIdentifier],
-        schema_name: Optional[sql_identifier.SqlIdentifier],
-        model_name: sql_identifier.SqlIdentifier,
-        version_name: sql_identifier.SqlIdentifier,
-        compute_pool_name: sql_identifier.SqlIdentifier,
-        image_repo_database_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_schema_name: Optional[sql_identifier.SqlIdentifier],
-        image_repo_name: sql_identifier.SqlIdentifier,
-        gpu: Optional[Union[str, int]],
-        force_rebuild: bool,
-        external_access_integration: sql_identifier.SqlIdentifier,
-        statement_params: Optional[dict[str, Any]] = None,
-    ) -> None:
-        actual_image_repo_database = image_repo_database_name or self._database_name
-        actual_image_repo_schema = image_repo_schema_name or self._schema_name
-        actual_model_database = database_name or self._database_name
-        actual_model_schema = schema_name or self._schema_name
-        fq_model_name = self.fully_qualified_object_name(actual_model_database, actual_model_schema, model_name)
-        fq_image_repo_name = identifier.get_schema_level_object_identifier(
-            actual_image_repo_database.identifier(),
-            actual_image_repo_schema.identifier(),
-            image_repo_name.identifier(),
-        )
-        is_gpu_str = "TRUE" if gpu else "FALSE"
-        force_rebuild_str = "TRUE" if force_rebuild else "FALSE"
-        query_result_checker.SqlResultValidator(
-            self._session,
-            (
-                f"CALL SYSTEM$BUILD_MODEL_CONTAINER('{fq_model_name}', '{version_name}', '{compute_pool_name}',"
-                f" '{fq_image_repo_name}', '{is_gpu_str}', '{force_rebuild_str}', '', '{external_access_integration}')"
-            ),
-            statement_params=statement_params,
-        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
-
     def deploy_model(
         self,
         *,

snowflake/ml/model/_packager/model_handlers/sklearn.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import warnings
 from typing import TYPE_CHECKING, Callable, Optional, Sequence, Union, cast, final
@@ -24,6 +25,8 @@ if TYPE_CHECKING:
     import sklearn.base
     import sklearn.pipeline
 
+logger = logging.getLogger(__name__)
+
 
 def _unpack_container_runtime_pipeline(model: "sklearn.pipeline.Pipeline") -> "sklearn.pipeline.Pipeline":
     new_steps = []
@@ -201,13 +204,13 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
                 explain_target_method = str(explain_target_method)  # mypy complains if we don't cast to str here
 
                 input_signature = handlers_utils.get_input_signature(model_meta, explain_target_method)
-                transformed_background_data = _apply_transforms_up_to_last_step(
-                    model=model,
-                    data=background_data,
-                    input_feature_names=[spec.name for spec in input_signature],
-                )
 
                 try:
+                    transformed_background_data = _apply_transforms_up_to_last_step(
+                        model=model,
+                        data=background_data,
+                        input_feature_names=[spec.name for spec in input_signature],
+                    )
                     model_meta = handlers_utils.add_inferred_explain_method_signature(
                         model_meta=model_meta,
                         explain_method="explain",
@@ -217,6 +220,7 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
                         output_feature_names=transformed_background_data.columns,
                     )
                 except Exception:
+                    logger.debug("Explainability is disabled due to an exception.", exc_info=True)
                     if kwargs.get("enable_explainability", None):
                         # user explicitly enabled explainability, so we should raise the error
                         raise ValueError(

snowflake/ml/model/_packager/model_runtime/_snowml_inference_alternative_requirements.py

@@ -13,6 +13,7 @@ REQUIREMENTS = [
     "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",

snowflake/ml/model/_signatures/pandas_handler.py

@@ -86,6 +86,9 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
                 df_col_data = utils.series_dropna(df_col_data)
                 df_col_dtype = df_col_data.dtype
 
+            if utils.check_if_series_is_empty(df_col_data):
+                continue
+
             if df_col_dtype == np.dtype("O"):
                 # Check if all objects have the same type
                 if not all(isinstance(data_row, type(df_col_data.iloc[0])) for data_row in df_col_data):

snowflake/ml/model/_signatures/utils.py

@@ -412,3 +412,7 @@ def infer_dict(name: str, data: dict[str, Any]) -> core.FeatureGroupSpec:
             specs.append(core.FeatureSpec(name=key, dtype=core.DataType.from_numpy_type(np.array(value).dtype)))
 
     return core.FeatureGroupSpec(name=name, specs=specs)
+
+
+def check_if_series_is_empty(series: Optional[pd.Series]) -> bool:
+    return series is None or series.empty

snowflake/ml/model/model_signature.py

@@ -272,6 +272,8 @@ def _validate_pandas_df(data: pd.DataFrame, features: Sequence[core.BaseFeatureS
                     ),
                 )
         else:
+            if utils.check_if_series_is_empty(data_col):
+                continue
             if isinstance(data_col.iloc[0], list):
                 if not ft_shape:
                     raise snowml_exceptions.SnowflakeMLException(

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 = "1.9.1"
+VERSION = "1.9.2"

{snowflake_ml_python-1.9.1.dist-info → snowflake_ml_python-1.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.9.1
+Version: 1.9.2
 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: 
@@ -243,6 +243,7 @@ Requires-Dist: importlib_resources<7,>=6.1.1
 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: pydantic<3,>=2.8.2
 Requires-Dist: pyjwt<3,>=2.0.0
@@ -273,7 +274,7 @@ Requires-Dist: tensorflow<3,>=2.17.0; extra == "all"
 Requires-Dist: tokenizers<1,>=0.15.1; extra == "all"
 Requires-Dist: torch<3,>=2.0.1; extra == "all"
 Requires-Dist: torchdata<1,>=0.4; extra == "all"
-Requires-Dist: transformers<5,>=4.39.3; extra == "all"
+Requires-Dist: transformers!=4.51.3,<5,>=4.39.3; extra == "all"
 Provides-Extra: altair
 Requires-Dist: altair<6,>=5; extra == "altair"
 Provides-Extra: catboost
@@ -298,7 +299,7 @@ Requires-Dist: sentence-transformers<4,>=2.7.0; extra == "transformers"
 Requires-Dist: sentencepiece<0.2.0,>=0.1.95; extra == "transformers"
 Requires-Dist: tokenizers<1,>=0.15.1; extra == "transformers"
 Requires-Dist: torch<3,>=2.0.1; extra == "transformers"
-Requires-Dist: transformers<5,>=4.39.3; extra == "transformers"
+Requires-Dist: transformers!=4.51.3,<5,>=4.39.3; extra == "transformers"
 Dynamic: license-file
 
 # Snowpark ML
@@ -409,7 +410,44 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.9.1
+## 1.9.2
+
+### Bug Fixes
+
+- DataConnector: Fix `self._session` related errors inside Container Runtime.
+- Registry: Fix a bug when trying to pass `None` to array (`pd.dtype('O')`) in signature and pandas data handler.
+
+### New Features
+
+- Experiment Tracking (PrPr): Automatically log the model, metrics, and parameters while training
+  XGBoost and LightGBM models.
+
+```python
+from snowflake.ml.experiment import ExperimentTracking
+from snowflake.ml.experiment.callback import SnowflakeXgboostCallback, SnowflakeLightgbmCallback
+
+exp = ExperimentTracking(session=sp_session, database_name="ML", schema_name="PUBLIC")
+
+exp.set_experiment("MY_EXPERIMENT")
+
+# XGBoost
+callback = SnowflakeXgboostCallback(
+  exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
+)
+model = XGBClassifier(callbacks=[callback])
+with exp.start_run():
+  model.fit(X, y, eval_set=[(X_test, y_test)])
+
+# LightGBM
+callback = SnowflakeLightgbmCallback(
+  exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
+)
+model = LGBMClassifier()
+with exp.start_run():
+  model.fit(X, y, eval_set=[(X_test, y_test)], callbacks=[callback])
+```
+
+## 1.9.1 (07-18-2025)
 
 ### Bug Fixes