snowflake-ml-python 1.8.2__py3-none-any.whl → 1.8.3__py3-none-any.whl

snowflake/ml/modeling/impute/simple_imputer.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import copy
 import warnings
-from typing import Any, Dict, Iterable, Optional, Type, Union
+from typing import Any, Iterable, Optional, Union
 
 import numpy as np
 import numpy.typing as npt
@@ -25,7 +25,7 @@ STRATEGY_TO_STATE_DICT = {
     "most_frequent": _utils.BasicStatistics.MODE,
 }
 
-SNOWFLAKE_DATATYPE_TO_NUMPY_DTYPE_MAP: Dict[Type[T.DataType], npt.DTypeLike] = {
+SNOWFLAKE_DATATYPE_TO_NUMPY_DTYPE_MAP: dict[type[T.DataType], npt.DTypeLike] = {
     T.ByteType: np.dtype("int8"),
     T.ShortType: np.dtype("int16"),
     T.IntegerType: np.dtype("int32"),
@@ -164,7 +164,7 @@ class SimpleImputer(base.BaseTransformer):
 
         self.fill_value = fill_value
         self.missing_values = missing_values
-        self.statistics_: Dict[str, Any] = {}
+        self.statistics_: dict[str, Any] = {}
         # TODO(hayu): [SNOW-752265] Support SimpleImputer keep_empty_features.
         #  Add back when `keep_empty_features` is supported.
         # self.keep_empty_features = keep_empty_features
@@ -195,7 +195,7 @@ class SimpleImputer(base.BaseTransformer):
             del self.feature_names_in_
             del self._sklearn_fit_dtype
 
-    def _get_dataset_input_col_datatypes(self, dataset: snowpark.DataFrame) -> Dict[str, T.DataType]:
+    def _get_dataset_input_col_datatypes(self, dataset: snowpark.DataFrame) -> dict[str, T.DataType]:
         """
         Checks that the input columns are all the same datatype category(except for most_frequent strategy) and
         returns the datatype.
@@ -211,7 +211,7 @@ class SimpleImputer(base.BaseTransformer):
                 supported.
         """
 
-        def check_type_consistency(col_types: Dict[str, T.DataType]) -> None:
+        def check_type_consistency(col_types: dict[str, T.DataType]) -> None:
             is_numeric_type = None
             for col_name, col_type in col_types.items():
                 if is_numeric_type is None:

snowflake/ml/modeling/metrics/__init__.py

@@ -5,7 +5,7 @@ import cloudpickle
 from snowflake.ml._internal import init_utils
 from snowflake.ml._internal.utils import result
 
-pkg_dir = os.path.dirname(os.path.abspath(__file__))
+pkg_dir = os.path.dirname(__file__)
 pkg_name = __name__
 exportable_functions = init_utils.fetch_functions_from_modules_in_pkg_dir(pkg_dir=pkg_dir, pkg_name=pkg_name)
 for k, v in exportable_functions.items():

snowflake/ml/modeling/metrics/classification.py

@@ -2,7 +2,7 @@ import inspect
 import json
 import math
 import warnings
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union
+from typing import Any, Iterable, Optional, Union
 
 import cloudpickle
 import numpy as np
@@ -32,8 +32,8 @@ _SUBPROJECT = "Metrics"
 def accuracy_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     normalize: bool = True,
     sample_weight_col_name: Optional[str] = None,
 ) -> float:
@@ -221,7 +221,7 @@ def confusion_matrix(
     return cm
 
 
-def _register_confusion_matrix_computer(*, session: snowpark.Session, statement_params: Dict[str, Any]) -> str:
+def _register_confusion_matrix_computer(*, session: snowpark.Session, statement_params: dict[str, Any]) -> str:
     """Registers confusion matrix computation UDTF in Snowflake and returns the name of the UDTF.
 
     Args:
@@ -247,7 +247,7 @@ def _register_confusion_matrix_computer(*, session: snowpark.Session, statement_
             # Number of labels.
             self._n_label = 0
 
-        def process(self, input_row: List[float], n_label: int) -> None:
+        def process(self, input_row: list[float], n_label: int) -> None:
             """Computes confusion matrix.
 
             Args:
@@ -270,7 +270,7 @@ def _register_confusion_matrix_computer(*, session: snowpark.Session, statement_
                 self.update_confusion_matrix()
                 self._cur_count = 0
 
-        def end_partition(self) -> Iterable[Tuple[bytes, str]]:
+        def end_partition(self) -> Iterable[tuple[bytes, str]]:
             # 3. Compute sum and dot_prod for the remaining rows in the batch.
             if self._cur_count > 0:
                 self.update_confusion_matrix()
@@ -313,8 +313,8 @@ def _register_confusion_matrix_computer(*, session: snowpark.Session, statement_
 def f1_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     labels: Optional[npt.ArrayLike] = None,
     pos_label: Union[str, int] = 1,
     average: Optional[str] = "binary",
@@ -406,8 +406,8 @@ def f1_score(
 def fbeta_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     beta: float,
     labels: Optional[npt.ArrayLike] = None,
     pos_label: Union[str, int] = 1,
@@ -501,8 +501,8 @@ def fbeta_score(
 def log_loss(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     eps: Union[float, str] = "auto",
     normalize: bool = True,
     sample_weight_col_name: Optional[str] = None,
@@ -625,7 +625,7 @@ def log_loss(
 def _register_log_loss_computer(
     *,
     session: snowpark.Session,
-    statement_params: Dict[str, Any],
+    statement_params: dict[str, Any],
     labels: Optional[npt.ArrayLike] = None,
 ) -> str:
     """Registers log loss computation UDTF in Snowflake and returns the name of the UDTF.
@@ -644,16 +644,16 @@ def _register_log_loss_computer(
     class LogLossComputer:
         def __init__(self) -> None:
             self._labels = labels
-            self._y_true: List[List[int]] = []
-            self._y_pred: List[List[float]] = []
-            self._sample_weight: List[float] = []
+            self._y_true: list[list[int]] = []
+            self._y_pred: list[list[float]] = []
+            self._sample_weight: list[float] = []
 
-        def process(self, y_true: List[int], y_pred: List[float], sample_weight: float) -> None:
+        def process(self, y_true: list[int], y_pred: list[float], sample_weight: float) -> None:
             self._y_true.append(y_true)
             self._y_pred.append(y_pred)
             self._sample_weight.append(sample_weight)
 
-        def end_partition(self) -> Iterable[Tuple[float]]:
+        def end_partition(self) -> Iterable[tuple[float]]:
             res = metrics.log_loss(
                 self._y_true,
                 self._y_pred,
@@ -685,18 +685,18 @@ def _register_log_loss_computer(
 def precision_recall_fscore_support(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     beta: float = 1.0,
     labels: Optional[npt.ArrayLike] = None,
     pos_label: Union[str, int] = 1,
     average: Optional[str] = None,
-    warn_for: Union[Tuple[str, ...], Set[str]] = ("precision", "recall", "f-score"),
+    warn_for: Union[tuple[str, ...], set[str]] = ("precision", "recall", "f-score"),
     sample_weight_col_name: Optional[str] = None,
     zero_division: Union[str, int] = "warn",
 ) -> Union[
-    Tuple[float, float, float, None],
-    Tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]],
+    tuple[float, float, float, None],
+    tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]],
 ]:
     """
     Compute precision, recall, F-measure and support for each class.
@@ -854,8 +854,8 @@ def precision_recall_fscore_support(
         result_object = result.deserialize(session, precision_recall_fscore_support_anon_sproc(session, **kwargs))
 
         res: Union[
-            Tuple[float, float, float, None],
-            Tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]],
+            tuple[float, float, float, None],
+            tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]],
         ] = result_object[:4]
         warning = result_object[-1]
         if warning:
@@ -1039,18 +1039,18 @@ def _register_multilabel_confusion_matrix_computer(
         def __init__(self) -> None:
             self._labels = labels
             self._samplewise = samplewise
-            self._y_true: List[List[int]] = []
-            self._y_pred: List[List[int]] = []
-            self._sample_weight: List[float] = []
+            self._y_true: list[list[int]] = []
+            self._y_pred: list[list[int]] = []
+            self._sample_weight: list[float] = []
 
-        def process(self, y_true: List[int], y_pred: List[int], sample_weight: float) -> None:
+        def process(self, y_true: list[int], y_pred: list[int], sample_weight: float) -> None:
             self._y_true.append(y_true)
             self._y_pred.append(y_pred)
             self._sample_weight.append(sample_weight)
 
         def end_partition(
             self,
-        ) -> Iterable[Tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]]]:
+        ) -> Iterable[tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]]]:
             MCM = metrics.multilabel_confusion_matrix(
                 self._y_true,
                 self._y_pred,
@@ -1093,8 +1093,8 @@ def _register_multilabel_confusion_matrix_computer(
 def _binary_precision_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     pos_label: Union[str, int] = 1,
     sample_weight_col_name: Optional[str] = None,
     zero_division: Union[str, int] = "warn",
@@ -1166,8 +1166,8 @@ def _binary_precision_score(
 def precision_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     labels: Optional[npt.ArrayLike] = None,
     pos_label: Union[str, int] = 1,
     average: Optional[str] = "binary",
@@ -1264,8 +1264,8 @@ def precision_score(
 def recall_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     labels: Optional[npt.ArrayLike] = None,
     pos_label: Union[str, int] = 1,
     average: Optional[str] = "binary",
@@ -1376,9 +1376,9 @@ def _sum_array_col(df: snowpark.DataFrame, col_name: str) -> snowpark.DataFrame:
 
 
 def _check_binary_labels(
-    labels: List[Any],
+    labels: list[Any],
     pos_label: Union[str, int] = 1,
-) -> List[Any]:
+) -> list[Any]:
     """Validation associated with binary average labels.
 
     Args:
@@ -1411,7 +1411,7 @@ def _prf_divide(
     metric: str,
     modifier: str,
     average: Optional[str] = None,
-    warn_for: Union[Tuple[str, ...], Set[str]] = ("precision", "recall", "f-score"),
+    warn_for: Union[tuple[str, ...], set[str]] = ("precision", "recall", "f-score"),
     zero_division: Union[str, int] = "warn",
 ) -> npt.NDArray[np.float_]:
     """Performs division and handles divide-by-zero.

snowflake/ml/modeling/metrics/metrics_utils.py

@@ -1,6 +1,6 @@
 import math
 import warnings
-from typing import Any, Collection, Dict, Iterable, List, Optional, Tuple, Union
+from typing import Any, Collection, Iterable, Optional, Union
 
 import cloudpickle
 import numpy as np
@@ -18,7 +18,7 @@ INDEX = "INDEX"
 BATCH_SIZE = 1000
 
 
-def register_accumulator_udtf(*, session: Session, statement_params: Dict[str, Any]) -> str:
+def register_accumulator_udtf(*, session: Session, statement_params: dict[str, Any]) -> str:
     """Registers accumulator UDTF in Snowflake and returns the name of the UDTF.
 
     Args:
@@ -47,7 +47,7 @@ def register_accumulator_udtf(*, session: Session, statement_params: Dict[str, A
             else:
                 self._accumulated_row = self._accumulated_row + row
 
-        def end_partition(self) -> Iterable[Tuple[bytes]]:
+        def end_partition(self) -> Iterable[tuple[bytes]]:
             yield (cloudpickle.dumps(self._accumulated_row),)
 
     accumulator = snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.TABLE_FUNCTION)
@@ -68,7 +68,7 @@ def register_accumulator_udtf(*, session: Session, statement_params: Dict[str, A
     return accumulator
 
 
-def register_sharded_dot_sum_computer(*, session: Session, statement_params: Dict[str, Any]) -> str:
+def register_sharded_dot_sum_computer(*, session: Session, statement_params: dict[str, Any]) -> str:
     """Registers dot and sum computation UDTF in Snowflake and returns the name of the UDTF.
 
     Args:
@@ -110,7 +110,7 @@ def register_sharded_dot_sum_computer(*, session: Session, statement_params: Dic
             # Square root of count - ddof
             self._sqrt_count_d = -1.0
 
-        def process(self, input_row: List[float], count: int, ddof: int) -> None:
+        def process(self, input_row: list[float], count: int, ddof: int) -> None:
             """Computes sum and dot product.
 
             Args:
@@ -138,7 +138,7 @@ def register_sharded_dot_sum_computer(*, session: Session, statement_params: Dic
                 self.accumulate_batch_sum_and_dot_prod()
                 self._cur_count = 0
 
-        def end_partition(self) -> Iterable[Tuple[bytes, str]]:
+        def end_partition(self) -> Iterable[tuple[bytes, str]]:
             # 3. Compute sum and dot_prod for the remaining rows in the batch.
             if self._cur_count > 0:
                 self.accumulate_batch_sum_and_dot_prod()
@@ -185,7 +185,7 @@ def register_sharded_dot_sum_computer(*, session: Session, statement_params: Dic
 
 def validate_and_return_dataframe_and_columns(
     *, df: snowpark.DataFrame, columns: Optional[Collection[str]] = None
-) -> Tuple[snowpark.DataFrame, Collection[str]]:
+) -> tuple[snowpark.DataFrame, Collection[str]]:
     """Validates that the columns are all numeric and returns a dataframe with those columns.
 
     Args:
@@ -212,8 +212,8 @@ def validate_and_return_dataframe_and_columns(
 
 
 def check_label_columns(
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
 ) -> None:
     """Check y true and y pred columns.
 
@@ -238,7 +238,7 @@ def check_label_columns(
         )
 
 
-def flatten_cols(cols: List[Optional[Union[str, List[str]]]]) -> List[str]:
+def flatten_cols(cols: list[Optional[Union[str, list[str]]]]) -> list[str]:
     res = []
     for col in cols:
         if isinstance(col, str):
@@ -251,7 +251,7 @@ def flatten_cols(cols: List[Optional[Union[str, List[str]]]]) -> List[str]:
 def unique_labels(
     *,
     df: snowpark.DataFrame,
-    columns: List[snowpark.Column],
+    columns: list[snowpark.Column],
 ) -> snowpark.DataFrame:
     """Extract indexed ordered unique labels as a dataframe.
 
@@ -311,7 +311,7 @@ def weighted_sum(
     sample_score_column: snowpark.Column,
     sample_weight_column: Optional[snowpark.Column] = None,
     normalize: bool = False,
-    statement_params: Dict[str, str],
+    statement_params: dict[str, str],
 ) -> float:
     """Weighted sum of the sample score column.
 

snowflake/ml/modeling/metrics/ranking.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import cloudpickle
 import numpy as np
@@ -26,7 +26,7 @@ def precision_recall_curve(
     probas_pred_col_name: str,
     pos_label: Optional[Union[str, int]] = None,
     sample_weight_col_name: Optional[str] = None,
-) -> Tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]]:
+) -> tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]]:
     """
     Compute precision-recall pairs for different probability thresholds.
 
@@ -125,7 +125,7 @@ def precision_recall_curve(
 
     kwargs = telemetry.get_sproc_statement_params_kwargs(precision_recall_curve_anon_sproc, statement_params)
     result_object = result.deserialize(session, precision_recall_curve_anon_sproc(session, **kwargs))
-    res: Tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]] = result_object
+    res: tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]] = result_object
     return res
 
 
@@ -133,8 +133,8 @@ def precision_recall_curve(
 def roc_auc_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_score_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_score_col_names: Union[str, list[str]],
     average: Optional[str] = "macro",
     sample_weight_col_name: Optional[str] = None,
     max_fpr: Optional[float] = None,
@@ -289,7 +289,7 @@ def roc_curve(
     pos_label: Optional[Union[str, int]] = None,
     sample_weight_col_name: Optional[str] = None,
     drop_intermediate: bool = True,
-) -> Tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]]:
+) -> tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]]:
     """
     Compute Receiver operating characteristic (ROC).
 
@@ -380,6 +380,6 @@ def roc_curve(
     kwargs = telemetry.get_sproc_statement_params_kwargs(roc_curve_anon_sproc, statement_params)
     result_object = result.deserialize(session, roc_curve_anon_sproc(session, **kwargs))
 
-    res: Tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]] = result_object
+    res: tuple[npt.NDArray[np.float_], npt.NDArray[np.float_], npt.NDArray[np.float_]] = result_object
 
     return res

snowflake/ml/modeling/metrics/regression.py

@@ -1,5 +1,5 @@
 import inspect
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 import cloudpickle
 import numpy as np
@@ -25,8 +25,8 @@ _MULTIOUTPUT_RAW_VALUES = "raw_values"
 def d2_absolute_error_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
 ) -> Union[float, npt.NDArray[np.float_]]:
@@ -119,8 +119,8 @@ def d2_absolute_error_score(
 def d2_pinball_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     alpha: float = 0.5,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
@@ -219,8 +219,8 @@ def d2_pinball_score(
 def explained_variance_score(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
     force_finite: bool = True,
@@ -334,8 +334,8 @@ def explained_variance_score(
 def mean_absolute_error(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
 ) -> Union[float, npt.NDArray[np.float_]]:
@@ -407,8 +407,8 @@ def mean_absolute_error(
 def mean_absolute_percentage_error(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
 ) -> Union[float, npt.NDArray[np.float_]]:
@@ -490,8 +490,8 @@ def mean_absolute_percentage_error(
 def mean_squared_error(
     *,
     df: snowpark.DataFrame,
-    y_true_col_names: Union[str, List[str]],
-    y_pred_col_names: Union[str, List[str]],
+    y_true_col_names: Union[str, list[str]],
+    y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
     squared: bool = True,

snowflake/ml/modeling/model_selection/__init__.py

@@ -2,7 +2,7 @@ import os
 
 from snowflake.ml._internal import init_utils
 
-pkg_dir = os.path.dirname(os.path.abspath(__file__))
+pkg_dir = os.path.dirname(__file__)
 pkg_name = __name__
 exportable_classes = init_utils.fetch_classes_from_modules_in_pkg_dir(pkg_dir=pkg_dir, pkg_name=pkg_name)
 for k, v in exportable_classes.items():

snowflake/ml/modeling/model_selection/grid_search_cv.py

@@ -2,7 +2,7 @@
 # This code is auto-generated using the sklearn_wrapper_template.py_template template.
 # Do not modify the auto-generated code(except automatic reformatting by precommit hooks).
 #
-from typing import Any, Dict, Iterable, List, Optional, Set, Union
+from typing import Any, Iterable, Optional, Union
 
 import cloudpickle as cp
 import numpy as np
@@ -244,7 +244,7 @@ class GridSearchCV(BaseTransformer):
         sample_weight_col: Optional[str] = None,
     ) -> None:
         super().__init__()
-        deps: Set[str] = {
+        deps: set[str] = {
             f"numpy=={np.__version__}",
             f"scikit-learn=={sklearn.__version__}",
             f"cloudpickle=={cp.__version__}",
@@ -268,7 +268,7 @@ class GridSearchCV(BaseTransformer):
         self._sklearn_object: Any = sklearn.model_selection.GridSearchCV(
             **cleaned_up_init_args,
         )
-        self._model_signature_dict: Optional[Dict[str, ModelSignature]] = None
+        self._model_signature_dict: Optional[dict[str, ModelSignature]] = None
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
         self.set_label_cols(label_cols)
@@ -281,7 +281,7 @@ class GridSearchCV(BaseTransformer):
         self._class_name = GridSearchCV.__class__.__name__
         self._subproject = _SUBPROJECT
 
-    def _get_active_columns(self) -> List[str]:
+    def _get_active_columns(self) -> list[str]:
         """ "Get the list of columns that are relevant to the transformer."""
         selected_cols = (
             self.input_cols + self.label_cols + ([self.sample_weight_col] if self.sample_weight_col is not None else [])
@@ -805,7 +805,7 @@ class GridSearchCV(BaseTransformer):
         assert self._sklearn_object is not None
         return self._sklearn_object
 
-    def _get_dependencies(self) -> List[str]:
+    def _get_dependencies(self) -> list[str]:
         return self._deps
 
     def _generate_model_signatures(self, dataset: Union[DataFrame, pd.DataFrame]) -> None:
@@ -820,7 +820,7 @@ class GridSearchCV(BaseTransformer):
                 use_snowflake_identifiers=True,
             )
         )
-        outputs: List[BaseFeatureSpec] = []
+        outputs: list[BaseFeatureSpec] = []
         if hasattr(self, "predict"):
             # keep mypy happy
             assert self._sklearn_object is not None and hasattr(self._sklearn_object, "_estimator_type")
@@ -863,7 +863,7 @@ class GridSearchCV(BaseTransformer):
             self._model_signature_dict[method] = signature
 
     @property
-    def model_signatures(self) -> Dict[str, ModelSignature]:
+    def model_signatures(self) -> dict[str, ModelSignature]:
         """Returns model signature of current class.
 
         Raises:

snowflake/ml/modeling/model_selection/randomized_search_cv.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Iterable, List, Optional, Set, Union
+from typing import Any, Iterable, Optional, Union
 
 import cloudpickle as cp
 import numpy as np
@@ -254,7 +254,7 @@ class RandomizedSearchCV(BaseTransformer):
         sample_weight_col: Optional[str] = None,
     ) -> None:
         super().__init__()
-        deps: Set[str] = {
+        deps: set[str] = {
             f"numpy=={np.__version__}",
             f"scikit-learn=={sklearn.__version__}",
             f"cloudpickle=={cp.__version__}",
@@ -280,7 +280,7 @@ class RandomizedSearchCV(BaseTransformer):
         self._sklearn_object: Any = sklearn.model_selection.RandomizedSearchCV(
             **cleaned_up_init_args,
         )
-        self._model_signature_dict: Optional[Dict[str, ModelSignature]] = None
+        self._model_signature_dict: Optional[dict[str, ModelSignature]] = None
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
         self.set_label_cols(label_cols)
@@ -294,7 +294,7 @@ class RandomizedSearchCV(BaseTransformer):
         self._class_name = RandomizedSearchCV.__class__.__name__
         self._subproject = _SUBPROJECT
 
-    def _get_active_columns(self) -> List[str]:
+    def _get_active_columns(self) -> list[str]:
         """ "Get the list of columns that are relevant to the transformer."""
         selected_cols = (
             self.input_cols + self.label_cols + ([self.sample_weight_col] if self.sample_weight_col is not None else [])
@@ -820,7 +820,7 @@ class RandomizedSearchCV(BaseTransformer):
         assert self._sklearn_object is not None
         return self._sklearn_object
 
-    def _get_dependencies(self) -> List[str]:
+    def _get_dependencies(self) -> list[str]:
         return self._deps
 
     def _generate_model_signatures(self, dataset: Union[DataFrame, pd.DataFrame]) -> None:
@@ -835,7 +835,7 @@ class RandomizedSearchCV(BaseTransformer):
                 use_snowflake_identifiers=True,
             )
         )
-        outputs: List[BaseFeatureSpec] = []
+        outputs: list[BaseFeatureSpec] = []
         if hasattr(self, "predict"):
             # keep mypy happy
             assert self._sklearn_object is not None and hasattr(self._sklearn_object, "_estimator_type")
@@ -878,7 +878,7 @@ class RandomizedSearchCV(BaseTransformer):
             self._model_signature_dict[method] = signature
 
     @property
-    def model_signatures(self) -> Dict[str, ModelSignature]:
+    def model_signatures(self) -> dict[str, ModelSignature]:
         """Returns model signature of current class.
 
         Raises:

snowflake/ml/modeling/pipeline/__init__.py

@@ -2,7 +2,7 @@ import os
 
 from snowflake.ml._internal import init_utils
 
-pkg_dir = os.path.dirname(os.path.abspath(__file__))
+pkg_dir = os.path.dirname(__file__)
 pkg_name = __name__
 exportable_classes = init_utils.fetch_classes_from_modules_in_pkg_dir(pkg_dir=pkg_dir, pkg_name=pkg_name)
 for k, v in exportable_classes.items():