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

snowflake/ml/modeling/pipeline/pipeline.py

@@ -4,7 +4,7 @@ import os
 import posixpath
 import tempfile
 from itertools import chain
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 import cloudpickle as cp
 import numpy as np
@@ -63,7 +63,7 @@ def has_callable_attr(obj: object, attr: str) -> bool:
     return callable(getattr(obj, attr, None))
 
 
-def _get_column_indices(all_columns: List[str], target_columns: List[str]) -> List[int]:
+def _get_column_indices(all_columns: list[str], target_columns: list[str]) -> list[int]:
     """
     Extract the indices of the target_columns from all_columns.
 
@@ -96,7 +96,7 @@ def _get_column_indices(all_columns: List[str], target_columns: List[str]) -> Li
 
 
 class Pipeline(base.BaseTransformer):
-    def __init__(self, steps: List[Tuple[str, Any]]) -> None:
+    def __init__(self, steps: list[tuple[str, Any]]) -> None:
         """
         Pipeline of transforms.
 
@@ -119,14 +119,14 @@ class Pipeline(base.BaseTransformer):
         # to only work with list of steps ending with an estimator or a dummy estimator like SKLearn?
         self._is_final_step_estimator = Pipeline._is_estimator(steps[-1][1])
         self._is_fitted = False
-        self._feature_names_in: List[np.ndarray[Any, np.dtype[Any]]] = []
-        self._n_features_in: List[int] = []
-        self._transformers_to_input_indices: Dict[str, List[int]] = {}
+        self._feature_names_in: list[np.ndarray[Any, np.dtype[Any]]] = []
+        self._n_features_in: list[int] = []
+        self._transformers_to_input_indices: dict[str, list[int]] = {}
         self._modifies_label_or_sample_weight = True
 
-        self._model_signature_dict: Optional[Dict[str, ModelSignature]] = None
+        self._model_signature_dict: Optional[dict[str, ModelSignature]] = None
 
-        deps: Set[str] = {f"pandas=={pd.__version__}", f"scikit-learn=={skversion}"}
+        deps: set[str] = {f"pandas=={pd.__version__}", f"scikit-learn=={skversion}"}
         for _, obj in steps:
             if isinstance(obj, base.BaseTransformer):
                 deps = deps | set(obj._get_dependencies())
@@ -146,10 +146,10 @@ class Pipeline(base.BaseTransformer):
     def _is_transformer(obj: object) -> bool:
         return has_callable_attr(obj, "fit") and has_callable_attr(obj, "transform")
 
-    def _get_transformers(self) -> List[Tuple[str, Any]]:
+    def _get_transformers(self) -> list[tuple[str, Any]]:
         return self.steps[:-1] if self._is_final_step_estimator else self.steps
 
-    def _get_estimator(self) -> Optional[Tuple[str, Any]]:
+    def _get_estimator(self) -> Optional[tuple[str, Any]]:
         return self.steps[-1] if self._is_final_step_estimator else None
 
     def _validate_steps(self) -> None:
@@ -215,7 +215,7 @@ class Pipeline(base.BaseTransformer):
         processed_cols = set(chain.from_iterable([trans.get_input_cols() for (_, trans) in self._get_transformers()]))
         return len(target_cols & processed_cols) > 0
 
-    def _get_sanitized_list_of_columns(self, columns: List[str]) -> List[str]:
+    def _get_sanitized_list_of_columns(self, columns: list[str]) -> list[str]:
         """
         Removes the label and sample_weight columns from the input list of columns and returns the results for the
         purpous of computing column indices for SKLearn ColumnTransformer objects.
@@ -237,7 +237,7 @@ class Pipeline(base.BaseTransformer):
 
         return [c for c in columns if c not in target_cols]
 
-    def _append_step_feature_consumption_info(self, step_name: str, all_cols: List[str], input_cols: List[str]) -> None:
+    def _append_step_feature_consumption_info(self, step_name: str, all_cols: list[str], input_cols: list[str]) -> None:
         if self._modifies_label_or_sample_weight:
             all_cols = self._get_sanitized_list_of_columns(all_cols)
             self._feature_names_in.append(np.asarray(all_cols, dtype=object))
@@ -269,7 +269,7 @@ class Pipeline(base.BaseTransformer):
 
         return transformed_dataset
 
-    def _upload_model_to_stage(self, stage_name: str, estimator: object, session: Session) -> Tuple[str, str]:
+    def _upload_model_to_stage(self, stage_name: str, estimator: object, session: Session) -> tuple[str, str]:
         """
         Util method to pickle and upload the model to a temp Snowflake stage.
 
@@ -331,10 +331,10 @@ class Pipeline(base.BaseTransformer):
 
             def pipeline_within_one_sproc(
                 session: Session,
-                sql_queries: List[str],
+                sql_queries: list[str],
                 stage_estimator_file_name: str,
                 stage_result_file_name: str,
-                sproc_statement_params: Dict[str, str],
+                sproc_statement_params: dict[str, str],
             ) -> str:
                 import os
 
@@ -774,7 +774,7 @@ class Pipeline(base.BaseTransformer):
 
         return ct
 
-    def _get_label_cols(self) -> List[str]:
+    def _get_label_cols(self) -> list[str]:
         """Util function to get the label columns from the pipeline.
         The label column is only present in the estimator
 
@@ -885,7 +885,7 @@ class Pipeline(base.BaseTransformer):
 
         return pipeline.Pipeline(steps=sksteps)
 
-    def _get_dependencies(self) -> List[str]:
+    def _get_dependencies(self) -> list[str]:
         return self._deps
 
     def _generate_model_signatures(self, dataset: Union[snowpark.DataFrame, pd.DataFrame]) -> None:
@@ -919,7 +919,7 @@ class Pipeline(base.BaseTransformer):
                 )
 
     @property
-    def model_signatures(self) -> Dict[str, ModelSignature]:
+    def model_signatures(self) -> dict[str, ModelSignature]:
         if self._model_signature_dict is None:
             raise exceptions.SnowflakeMLException(
                 error_code=error_codes.INVALID_ATTRIBUTE,

snowflake/ml/modeling/preprocessing/__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/preprocessing/k_bins_discretizer.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 from itertools import chain
-from typing import Dict, Iterable, List, Optional, Union, cast
+from typing import Iterable, Optional, Union, cast
 
 import numpy as np
 import numpy.typing as npt
@@ -104,7 +104,7 @@ class KBinsDiscretizer(base.BaseTransformer):
     def __init__(
         self,
         *,
-        n_bins: Union[int, List[int]] = 5,
+        n_bins: Union[int, list[int]] = 5,
         encode: str = "onehot",
         strategy: str = "quantile",
         input_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -229,7 +229,7 @@ class KBinsDiscretizer(base.BaseTransformer):
         # https://docs.google.com/document/d/1cilfCCtKYv6HvHqaqdZxfHAvQ0gg-t1AM8KYCQtJiLE/edit
         agg_queries = []
         for idx, col_name in enumerate(self.input_cols):
-            percentiles = np.linspace(0, 1, cast(List[int], self.n_bins)[idx] + 1)
+            percentiles = np.linspace(0, 1, cast(list[int], self.n_bins)[idx] + 1)
             for i, pct in enumerate(percentiles.tolist()):
                 agg_queries.append(F.percentile_cont(pct).within_group(col_name).alias(f"{col_name}_pct_{i}"))
         state_df = dataset.agg(agg_queries)
@@ -246,7 +246,7 @@ class KBinsDiscretizer(base.BaseTransformer):
         self.bin_edges_ = np.zeros(len(self.input_cols), dtype=object)
         self.n_bins_ = np.zeros(len(self.input_cols), dtype=np.int_)
         start = 0
-        for i, b in enumerate(cast(List[int], self.n_bins)):
+        for i, b in enumerate(cast(list[int], self.n_bins)):
             self.bin_edges_[i] = decimal_to_float(state[start : start + b + 1])
             start += b + 1
             self.n_bins_[i] = len(self.bin_edges_[i]) - 1
@@ -275,7 +275,7 @@ class KBinsDiscretizer(base.BaseTransformer):
         # 2. Populate internal state variables
         self.bin_edges_ = np.zeros(len(self.input_cols), dtype=object)
         self.n_bins_ = np.zeros(len(self.input_cols), dtype=np.int_)
-        for i, b in enumerate(cast(List[int], self.n_bins)):
+        for i, b in enumerate(cast(list[int], self.n_bins)):
             self.bin_edges_[i] = np.linspace(state[i * 2], state[i * 2 + 1], b + 1)
             self.n_bins_[i] = len(self.bin_edges_[i]) - 1
 
@@ -345,7 +345,7 @@ class KBinsDiscretizer(base.BaseTransformer):
             session=dataset._session,
             statement_params=telemetry.get_statement_params(base.PROJECT, base.SUBPROJECT, self.__class__.__name__),
         )
-        def vec_bucketize_temp(x: T.PandasSeries[float], boarders: T.PandasSeries[List[float]]) -> T.PandasSeries[int]:
+        def vec_bucketize_temp(x: T.PandasSeries[float], boarders: T.PandasSeries[list[float]]) -> T.PandasSeries[int]:
             # NB: vectorized udf doesn't work well with const array arg, so we pass it in as a list via PandasSeries
             boarders = boarders[0]
             res = np.searchsorted(boarders[1:-1], x, side="right")
@@ -387,9 +387,9 @@ class KBinsDiscretizer(base.BaseTransformer):
             statement_params=telemetry.get_statement_params(base.PROJECT, base.SUBPROJECT, self.__class__.__name__),
         )
         def vec_bucketize_sparse_output_temp(
-            x: T.PandasSeries[float], boarders: T.PandasSeries[List[float]]
-        ) -> T.PandasSeries[Dict[str, int]]:
-            res: List[Dict[str, int]] = []
+            x: T.PandasSeries[float], boarders: T.PandasSeries[list[float]]
+        ) -> T.PandasSeries[dict[str, int]]:
+            res: list[dict[str, int]] = []
             boarders = boarders[0]
             buckets = np.searchsorted(boarders[1:-1], x, side="right")
             assert isinstance(buckets, np.ndarray), f"expecting buckets to be numpy ndarray, got {type(buckets)}"
@@ -434,9 +434,9 @@ class KBinsDiscretizer(base.BaseTransformer):
             statement_params=telemetry.get_statement_params(base.PROJECT, base.SUBPROJECT, self.__class__.__name__),
         )
         def vec_bucketize_dense_output_temp(
-            x: T.PandasSeries[float], boarders: T.PandasSeries[List[float]]
-        ) -> T.PandasSeries[List[int]]:
-            res: List[npt.NDArray[np.int32]] = []
+            x: T.PandasSeries[float], boarders: T.PandasSeries[list[float]]
+        ) -> T.PandasSeries[list[int]]:
+            res: list[npt.NDArray[np.int32]] = []
             boarders = boarders[0]
             buckets = np.searchsorted(boarders[1:-1], x, side="right")
             assert isinstance(buckets, np.ndarray), f"expecting buckets to be numpy ndarray, got {type(buckets)}"
@@ -491,7 +491,7 @@ class KBinsDiscretizer(base.BaseTransformer):
         else:
             return transformed_dataset
 
-    def get_output_cols(self) -> List[str]:
+    def get_output_cols(self) -> list[str]:
         """
         Get output column names.
         Expand output column names for 'onehot-dense' encoding.

snowflake/ml/modeling/preprocessing/max_abs_scaler.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Iterable, List, Optional, Union
+from typing import Iterable, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -88,10 +88,10 @@ class MaxAbsScaler(base.BaseTransformer):
             max_abs_: dict {column_name: value} or None
                 Per feature maximum absolute value.
         """
-        self.max_abs_: Dict[str, float] = {}
-        self.scale_: Dict[str, float] = {}
+        self.max_abs_: dict[str, float] = {}
+        self.scale_: dict[str, float] = {}
 
-        self.custom_states: List[str] = [
+        self.custom_states: list[str] = [
             "SQL>>>max(abs({col_name}))",
         ]
 

snowflake/ml/modeling/preprocessing/min_max_scaler.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Iterable, List, Optional, Tuple, Union
+from typing import Iterable, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -69,7 +69,7 @@ class MinMaxScaler(base.BaseTransformer):
     def __init__(
         self,
         *,
-        feature_range: Tuple[float, float] = (0, 1),
+        feature_range: tuple[float, float] = (0, 1),
         clip: bool = False,
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -101,13 +101,13 @@ class MinMaxScaler(base.BaseTransformer):
         self.feature_range = feature_range
         self.clip = clip
 
-        self.min_: Dict[str, float] = {}
-        self.scale_: Dict[str, float] = {}
-        self.data_min_: Dict[str, float] = {}
-        self.data_max_: Dict[str, float] = {}
-        self.data_range_: Dict[str, float] = {}
+        self.min_: dict[str, float] = {}
+        self.scale_: dict[str, float] = {}
+        self.data_min_: dict[str, float] = {}
+        self.data_max_: dict[str, float] = {}
+        self.data_range_: dict[str, float] = {}
 
-        self.custom_states: List[str] = [_utils.NumericStatistics.MIN, _utils.NumericStatistics.MAX]
+        self.custom_states: list[str] = [_utils.NumericStatistics.MIN, _utils.NumericStatistics.MAX]
 
         super().__init__(drop_input_cols=drop_input_cols, custom_states=self.custom_states)
 

snowflake/ml/modeling/preprocessing/normalizer.py

@@ -72,7 +72,6 @@ class Normalizer(base.BaseTransformer):
 
         This is a stateless transformer, so there is nothing to reset.
         """
-        pass
 
     def _fit(self, dataset: Union[snowpark.DataFrame, pd.DataFrame]) -> "Normalizer":
         """

snowflake/ml/modeling/preprocessing/one_hot_encoder.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import numbers
 import uuid
-from typing import Any, Dict, Iterable, List, Optional, Union
+from typing import Any, Iterable, Optional, Union
 
 import numpy as np
 import numpy.typing as npt
@@ -214,7 +214,7 @@ class OneHotEncoder(base.BaseTransformer):
     def __init__(
         self,
         *,
-        categories: Union[str, List[type_utils.LiteralNDArrayType], Dict[str, type_utils.LiteralNDArrayType]] = "auto",
+        categories: Union[str, list[type_utils.LiteralNDArrayType], dict[str, type_utils.LiteralNDArrayType]] = "auto",
         drop: Optional[Union[str, npt.ArrayLike]] = None,
         sparse: bool = False,
         handle_unknown: str = "error",
@@ -238,23 +238,23 @@ class OneHotEncoder(base.BaseTransformer):
         ) or self.min_frequency is not None
 
         # Fit state
-        self.categories_: Dict[str, type_utils.LiteralNDArrayType] = {}
-        self._categories_list: List[type_utils.LiteralNDArrayType] = []
+        self.categories_: dict[str, type_utils.LiteralNDArrayType] = {}
+        self._categories_list: list[type_utils.LiteralNDArrayType] = []
         self.drop_idx_: Optional[npt.NDArray[np.int_]] = None
         self._drop_idx_after_grouping: Optional[npt.NDArray[np.int_]] = None
-        self._n_features_outs: List[int] = []
-        self._snowpark_cols: Dict[str, List[str]] = dict()
+        self._n_features_outs: list[int] = []
+        self._snowpark_cols: dict[str, list[str]] = dict()
 
         # Fit state if output columns are set before fitting
-        self._dense_output_cols_mappings: Dict[str, List[str]] = {}
-        self._inferred_output_cols: List[str] = []
+        self._dense_output_cols_mappings: dict[str, list[str]] = {}
+        self._inferred_output_cols: list[str] = []
 
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
         self.set_passthrough_cols(passthrough_cols)
 
     @property
-    def infrequent_categories_(self) -> List[Optional[type_utils.LiteralNDArrayType]]:
+    def infrequent_categories_(self) -> list[Optional[type_utils.LiteralNDArrayType]]:
         """Infrequent categories for each feature."""
         # raises an AttributeError if `_infrequent_indices` is not defined
         infrequent_indices = self._infrequent_indices
@@ -329,7 +329,7 @@ class OneHotEncoder(base.BaseTransformer):
             self._drop_idx_after_grouping = sklearn_encoder.drop_idx_
         self._n_features_outs = sklearn_encoder._n_features_outs
 
-        _state_pandas_counts: List[pd.DataFrame] = []
+        _state_pandas_counts: list[pd.DataFrame] = []
         for idx, input_col in enumerate(self.input_cols):
             self.categories_[input_col] = self._categories_list[idx]
             _column_counts = (
@@ -362,7 +362,7 @@ class OneHotEncoder(base.BaseTransformer):
         self._n_features_outs = self._compute_n_features_outs()
         self._update_categories_state()
 
-    def _fit_category_state(self, dataset: snowpark.DataFrame, return_counts: bool) -> Dict[str, Any]:
+    def _fit_category_state(self, dataset: snowpark.DataFrame, return_counts: bool) -> dict[str, Any]:
         """
         Get the number of samples, categories and (optional) category counts of dataset.
         Fitted categories are assigned to the object.
@@ -552,7 +552,7 @@ class OneHotEncoder(base.BaseTransformer):
             categories_pandas = categories_pandas.rename(columns={_STATE: categories_col})
 
             # {column_name: ndarray([category])}
-            categories: Dict[str, type_utils.LiteralNDArrayType] = categories_pandas.set_index(_COLUMN_NAME).to_dict()[
+            categories: dict[str, type_utils.LiteralNDArrayType] = categories_pandas.set_index(_COLUMN_NAME).to_dict()[
                 categories_col
             ]
             # Giving the original type back to categories.
@@ -769,7 +769,7 @@ class OneHotEncoder(base.BaseTransformer):
 
         state_pandas = self._state_pandas
 
-        def map_encoded_value(row: pd.Series) -> Dict[str, Any]:
+        def map_encoded_value(row: pd.Series) -> dict[str, Any]:
             n_features_out = row[_N_FEATURES_OUT]
             encoding = row[_ENCODING]
             encoded_value = {str(encoding): 1, "array_length": n_features_out}
@@ -836,7 +836,7 @@ class OneHotEncoder(base.BaseTransformer):
         """
         state_pandas = self._state_pandas
 
-        def map_encoded_value(row: pd.Series) -> List[int]:
+        def map_encoded_value(row: pd.Series) -> list[int]:
             n_features_out = row[_N_FEATURES_OUT]
             encoding = row[_ENCODING]
             encoded_value = [0] * n_features_out
@@ -934,7 +934,7 @@ class OneHotEncoder(base.BaseTransformer):
             packages=["numpy", "scikit-learn"],
             statement_params=telemetry.get_statement_params(base.PROJECT, base.SUBPROJECT, self.__class__.__name__),
         )
-        def one_hot_encoder_sparse_transform(data: pd.DataFrame) -> List[List[Optional[Dict[Any, Any]]]]:
+        def one_hot_encoder_sparse_transform(data: pd.DataFrame) -> list[list[Optional[dict[Any, Any]]]]:
             data = data.replace({np.nan: None})  # fill NA with None as represented in `categories_`
             transformed_csr = encoder_sklearn.transform(data)
             transformed_coo = transformed_csr.tocoo()
@@ -943,7 +943,7 @@ class OneHotEncoder(base.BaseTransformer):
             transformed_vals = []
             for _, row in data.iterrows():
                 base_encoding = 0
-                row_transformed_vals: List[Optional[Dict[Any, Any]]] = []
+                row_transformed_vals: list[Optional[dict[Any, Any]]] = []
                 for col_idx, val in row.items():
                     if val in encoder_sklearn.categories_[col_idx] or encoder_sklearn.handle_unknown != "ignore":
                         if col_idx > 0:
@@ -1101,7 +1101,7 @@ class OneHotEncoder(base.BaseTransformer):
     def _handle_unknown_in_transform(
         self,
         transformed_dataset: snowpark.DataFrame,
-        input_cols: Optional[List[str]] = None,
+        input_cols: Optional[list[str]] = None,
     ) -> snowpark.DataFrame:
         """
         Handle unknown values in the transformed dataset.
@@ -1206,7 +1206,7 @@ class OneHotEncoder(base.BaseTransformer):
         if not self._infrequent_enabled:
             return drop_idx
 
-        default_to_infrequent: Optional[List[int]] = self._default_to_infrequent_mappings[feature_idx]
+        default_to_infrequent: Optional[list[int]] = self._default_to_infrequent_mappings[feature_idx]
         if default_to_infrequent is None:
             return drop_idx
 
@@ -1346,7 +1346,7 @@ class OneHotEncoder(base.BaseTransformer):
             self.drop_idx_ = np.asarray(drop_idx_, dtype=object)
 
     def _fit_infrequent_category_mapping(
-        self, n_samples: int, category_counts: Dict[str, Dict[str, Dict[str, int]]]
+        self, n_samples: int, category_counts: dict[str, dict[str, dict[str, int]]]
     ) -> None:
         """
         Fit infrequent categories.
@@ -1442,7 +1442,7 @@ class OneHotEncoder(base.BaseTransformer):
         output = np.flatnonzero(infrequent_mask)
         return output if output.size > 0 else None
 
-    def _compute_n_features_outs(self) -> List[int]:
+    def _compute_n_features_outs(self) -> list[int]:
         """Compute the n_features_out for each input feature."""
         output = [len(cats) for cats in self._categories_list]
 
@@ -1463,7 +1463,7 @@ class OneHotEncoder(base.BaseTransformer):
 
         return output
 
-    def get_output_cols(self) -> List[str]:
+    def get_output_cols(self) -> list[str]:
         """
         Output columns getter.
 
@@ -1472,7 +1472,7 @@ class OneHotEncoder(base.BaseTransformer):
         """
         return self._inferred_output_cols
 
-    def _get_inferred_output_cols(self) -> List[str]:
+    def _get_inferred_output_cols(self) -> list[str]:
         """
         Get output column names meeting Snowflake requirements.
         Only useful when fitting a pandas dataframe.
@@ -1556,11 +1556,11 @@ class OneHotEncoder(base.BaseTransformer):
         sklearn_initial_keywords: Optional[Union[str, Iterable[str]]] = None,
         sklearn_unused_keywords: Optional[Union[str, Iterable[str]]] = None,
         snowml_only_keywords: Optional[Union[str, Iterable[str]]] = None,
-        sklearn_added_keyword_to_version_dict: Optional[Dict[str, str]] = None,
-        sklearn_added_kwarg_value_to_version_dict: Optional[Dict[str, Dict[str, str]]] = None,
-        sklearn_deprecated_keyword_to_version_dict: Optional[Dict[str, str]] = None,
-        sklearn_removed_keyword_to_version_dict: Optional[Dict[str, str]] = None,
-    ) -> Dict[str, Any]:
+        sklearn_added_keyword_to_version_dict: Optional[dict[str, str]] = None,
+        sklearn_added_kwarg_value_to_version_dict: Optional[dict[str, dict[str, str]]] = None,
+        sklearn_deprecated_keyword_to_version_dict: Optional[dict[str, str]] = None,
+        sklearn_removed_keyword_to_version_dict: Optional[dict[str, str]] = None,
+    ) -> dict[str, Any]:
         """Modified snowflake.ml.framework.base.Base.get_sklearn_args with `sparse` and `sparse_output` handling."""
         default_sklearn_args = _utils.get_default_args(default_sklearn_obj.__class__.__init__)
         given_args = self.get_params()
@@ -1580,7 +1580,7 @@ class OneHotEncoder(base.BaseTransformer):
         if version.parse(sklearn_version) >= version.parse(_SKLEARN_DEPRECATED_KEYWORD_TO_VERSION_DICT["sparse"]):
             given_args["sparse_output"] = given_args.pop("sparse")
 
-        sklearn_args: Dict[str, Any] = _utils.get_filtered_valid_sklearn_args(
+        sklearn_args: dict[str, Any] = _utils.get_filtered_valid_sklearn_args(
             args=given_args,
             default_sklearn_args=default_sklearn_args,
             sklearn_initial_keywords=sklearn_initial_keywords,

snowflake/ml/modeling/preprocessing/ordinal_encoder.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import numbers
 import uuid
-from typing import Any, Dict, Iterable, List, Optional, Union
+from typing import Any, Iterable, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -102,7 +102,7 @@ class OrdinalEncoder(base.BaseTransformer):
     def __init__(
         self,
         *,
-        categories: Union[str, List[type_utils.LiteralNDArrayType], Dict[str, type_utils.LiteralNDArrayType]] = "auto",
+        categories: Union[str, list[type_utils.LiteralNDArrayType], dict[str, type_utils.LiteralNDArrayType]] = "auto",
         handle_unknown: str = "error",
         unknown_value: Optional[Union[int, float]] = None,
         encoded_missing_value: Union[int, float] = np.nan,
@@ -161,9 +161,9 @@ class OrdinalEncoder(base.BaseTransformer):
         self.unknown_value = unknown_value
         self.encoded_missing_value = encoded_missing_value
 
-        self.categories_: Dict[str, type_utils.LiteralNDArrayType] = {}
-        self._categories_list: List[type_utils.LiteralNDArrayType] = []
-        self._missing_indices: Dict[int, int] = {}
+        self.categories_: dict[str, type_utils.LiteralNDArrayType] = {}
+        self._categories_list: list[type_utils.LiteralNDArrayType] = []
+        self._missing_indices: dict[int, int] = {}
         self._infrequent_enabled = False
         self._vocab_table_name = snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.TABLE)
 
@@ -221,7 +221,7 @@ class OrdinalEncoder(base.BaseTransformer):
 
         self._categories_list = sklearn_encoder.categories_
 
-        _state_pandas_ordinals: List[pd.DataFrame] = []
+        _state_pandas_ordinals: list[pd.DataFrame] = []
         for idx, input_col in enumerate(sorted(self.input_cols)):
             self.categories_[input_col] = self._categories_list[idx]
             # A column with values [a, b, b, None, a] will get mapped into a `_column_ordinals`
@@ -673,7 +673,7 @@ class OrdinalEncoder(base.BaseTransformer):
     def _check_unknown(
         self,
         dataset: snowpark.DataFrame,
-        statement_params: Dict[str, Any],
+        statement_params: dict[str, Any],
         batch: bool = False,
     ) -> None:
         """
@@ -690,8 +690,8 @@ class OrdinalEncoder(base.BaseTransformer):
 
         def create_unknown_df(
             dataset: snowpark.DataFrame,
-            input_cols: List[str],
-            output_cols: List[str],
+            input_cols: list[str],
+            output_cols: list[str],
         ) -> snowpark.DataFrame:
             # dataframe with unknown values
             # columns: COLUMN_NAME, UNKNOWN_VALUE

snowflake/ml/modeling/preprocessing/robust_scaler.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Iterable, List, Optional, Tuple, Union
+from typing import Iterable, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -70,7 +70,7 @@ class RobustScaler(base.BaseTransformer):
         *,
         with_centering: bool = True,
         with_scaling: bool = True,
-        quantile_range: Tuple[float, float] = (25.0, 75.0),
+        quantile_range: tuple[float, float] = (25.0, 75.0),
         unit_variance: bool = False,
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -112,12 +112,12 @@ class RobustScaler(base.BaseTransformer):
         self.unit_variance = unit_variance
 
         self._state_is_set = False
-        self._center: Dict[str, float] = {}
-        self._scale: Dict[str, float] = {}
+        self._center: dict[str, float] = {}
+        self._scale: dict[str, float] = {}
 
         l_range = self.quantile_range[0] / 100.0
         r_range = self.quantile_range[1] / 100.0
-        self.custom_states: List[str] = [
+        self.custom_states: list[str] = [
             _utils.NumericStatistics.MEDIAN,
             "SQL>>>percentile_cont(" + str(l_range) + ") within group (order by {col_name})",
             "SQL>>>percentile_cont(" + str(r_range) + ") within group (order by {col_name})",
@@ -140,11 +140,11 @@ class RobustScaler(base.BaseTransformer):
         self._state_is_set = False
 
     @property
-    def center_(self) -> Optional[Dict[str, float]]:
+    def center_(self) -> Optional[dict[str, float]]:
         return None if (not self.with_centering or not self._state_is_set) else self._center
 
     @property
-    def scale_(self) -> Optional[Dict[str, float]]:
+    def scale_(self) -> Optional[dict[str, float]]:
         return None if (not self.with_scaling or not self._state_is_set) else self._scale
 
     def _fit(self, dataset: Union[snowpark.DataFrame, pd.DataFrame]) -> "RobustScaler":

snowflake/ml/modeling/preprocessing/standard_scaler.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Iterable, List, Optional, Union
+from typing import Iterable, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -106,11 +106,11 @@ class StandardScaler(base.BaseTransformer):
         self.with_mean = with_mean
         self.with_std = with_std
 
-        self.scale_: Optional[Dict[str, float]] = {} if with_std else None
-        self.mean_: Optional[Dict[str, float]] = {} if with_mean else None
-        self.var_: Optional[Dict[str, float]] = {} if with_std else None
+        self.scale_: Optional[dict[str, float]] = {} if with_std else None
+        self.mean_: Optional[dict[str, float]] = {} if with_mean else None
+        self.var_: Optional[dict[str, float]] = {} if with_std else None
 
-        self.custom_states: List[str] = []
+        self.custom_states: list[str] = []
         if with_mean:
             self.custom_states.append(_utils.NumericStatistics.MEAN)
         if with_std: