MNT _convert_container columns_name -> column_names (scikit-learn#33955)

Author: lorentzenchr

sklearn/compose/tests/test_column_transformer.py

@@ -202,7 +202,7 @@ def test_column_transformer_dataframe(constructor_name):
 
     X_array = np.array([[0, 1, 2], [2, 4, 6]]).T
     X_df = _convert_container(
-        X_array, constructor_name, columns_name=["first", "second"]
+        X_array, constructor_name, column_names=["first", "second"]
     )
 
     X_res_first = np.array([0, 1, 2]).reshape(-1, 1)
@@ -530,7 +530,7 @@ def test_column_transformer_list():
 @pytest.mark.parametrize("constructor_name", ["array", "pandas", "polars"])
 def test_column_transformer_sparse_stacking(csr_container, constructor_name):
     X = np.array([[0, 1, 2], [2, 4, 6]]).T
-    X = _convert_container(X, constructor_name, columns_name=["first", "second"])
+    X = _convert_container(X, constructor_name, column_names=["first", "second"])
 
     col_trans = ColumnTransformer(
         [("trans1", Trans(), [0]), ("trans2", SparseMatrixTrans(csr_container), 1)],

sklearn/datasets/_arff_parser.py

@@ -185,21 +185,21 @@ def _io_to_generator(gzip_file):
         pd = check_pandas_support("fetch_openml with as_frame=True")
 
         columns_info = OrderedDict(arff_container["attributes"])
-        columns_names = list(columns_info.keys())
+        column_names = list(columns_info.keys())
 
         # calculate chunksize
         first_row = next(arff_container["data"])
-        first_df = pd.DataFrame([first_row], columns=columns_names, copy=False)
+        first_df = pd.DataFrame([first_row], columns=column_names, copy=False)
 
         row_bytes = first_df.memory_usage(deep=True).sum()
         chunksize = get_chunk_n_rows(row_bytes)
 
         # read arff data with chunks
-        columns_to_keep = [col for col in columns_names if col in columns_to_select]
+        columns_to_keep = [col for col in column_names if col in columns_to_select]
         dfs = [first_df[columns_to_keep]]
         for data in chunk_generator(arff_container["data"], chunksize):
             dfs.append(
-                pd.DataFrame(data, columns=columns_names, copy=False)[columns_to_keep]
+                pd.DataFrame(data, columns=column_names, copy=False)[columns_to_keep]
             )
         # dfs[0] contains only one row, which may not have enough data to infer to
         # column's dtype. Here we use `dfs[1]` to configure the dtype in dfs[0]

sklearn/ensemble/_hist_gradient_boosting/tests/test_monotonic_constraints.py

@@ -225,9 +225,9 @@ def test_predictions(global_random_seed, use_feature_names):
     f_c = rng.randint(low=0, high=9, size=n_samples)
 
     X = np.c_[f_a, f_0, f_b, f_1, f_c]
-    columns_name = ["f_a", "f_0", "f_b", "f_1", "f_c"]
+    column_names = ["f_a", "f_0", "f_b", "f_1", "f_c"]
     constructor_name = "pandas" if use_feature_names else "array"
-    X = _convert_container(X, constructor_name, columns_name=columns_name)
+    X = _convert_container(X, constructor_name, column_names=column_names)
 
     noise = rng.normal(loc=0.0, scale=0.01, size=n_samples)
     y = 5 * f_0 + np.sin(10 * np.pi * f_0) - 5 * f_1 - np.cos(10 * np.pi * f_1) + noise
@@ -261,24 +261,24 @@ def test_predictions(global_random_seed, use_feature_names):
     # First non-categorical feature (POS)
     # assert pred is all increasing when f_0 is all increasing
     X = np.c_[constant, linspace, constant, constant, constant]
-    X = _convert_container(X, constructor_name, columns_name=columns_name)
+    X = _convert_container(X, constructor_name, column_names=column_names)
     pred = gbdt.predict(X)
     assert is_increasing(pred)
     # assert pred actually follows the variations of f_0
     X = np.c_[constant, sin, constant, constant, constant]
-    X = _convert_container(X, constructor_name, columns_name=columns_name)
+    X = _convert_container(X, constructor_name, column_names=column_names)
     pred = gbdt.predict(X)
     assert np.all((np.diff(pred) >= 0) == (np.diff(sin) >= 0))
 
     # Second non-categorical feature (NEG)
     # assert pred is all decreasing when f_1 is all increasing
     X = np.c_[constant, constant, constant, linspace, constant]
-    X = _convert_container(X, constructor_name, columns_name=columns_name)
+    X = _convert_container(X, constructor_name, column_names=column_names)
     pred = gbdt.predict(X)
     assert is_decreasing(pred)
     # assert pred actually follows the inverse variations of f_1
     X = np.c_[constant, constant, constant, sin, constant]
-    X = _convert_container(X, constructor_name, columns_name=columns_name)
+    X = _convert_container(X, constructor_name, column_names=column_names)
     pred = gbdt.predict(X)
     assert ((np.diff(pred) <= 0) == (np.diff(sin) >= 0)).all()
 

sklearn/inspection/_plot/tests/test_boundary_decision_display.py

@@ -485,7 +485,7 @@ def test_dataframe_support(pyplot, constructor_name):
     * https://github.com/scikit-learn/scikit-learn/issues/28717
     """
     df = _convert_container(
-        X, constructor_name=constructor_name, columns_name=["col_x", "col_y"]
+        X, constructor_name=constructor_name, column_names=["col_x", "col_y"]
     )
     estimator = LogisticRegression().fit(df, y)
 

sklearn/inspection/_plot/tests/test_plot_partial_dependence.py

@@ -206,7 +206,7 @@ def test_plot_partial_dependence_str_features(
     bmi = diabetes.data[:, diabetes.feature_names.index("bmi")]
 
     X = _convert_container(
-        diabetes.data, input_type, columns_name=diabetes.feature_names
+        diabetes.data, input_type, column_names=diabetes.feature_names
     )
 
     if feature_names_type is None:
@@ -808,8 +808,8 @@ def test_plot_partial_dependence_with_categorical(
     pyplot, categorical_features, array_type
 ):
     X = [[1, 1, "A"], [2, 0, "C"], [3, 2, "B"]]
-    column_name = ["col_A", "col_B", "col_C"]
-    X = _convert_container(X, array_type, columns_name=column_name)
+    column_names = ["col_A", "col_B", "col_C"]
+    X = _convert_container(X, array_type, column_names=column_names)
     y = np.array([1.2, 0.5, 0.45]).T
 
     preprocessor = make_column_transformer((OneHotEncoder(), categorical_features))
@@ -821,7 +821,7 @@ def test_plot_partial_dependence_with_categorical(
         model,
         X,
         features=["col_C"],
-        feature_names=column_name,
+        feature_names=column_names,
         categorical_features=categorical_features,
     )
 
@@ -843,7 +843,7 @@ def test_plot_partial_dependence_with_categorical(
         model,
         X,
         features=[("col_A", "col_C")],
-        feature_names=column_name,
+        feature_names=column_names,
         categorical_features=categorical_features,
     )
 
@@ -991,8 +991,8 @@ def test_grid_resolution_with_categorical(pyplot, categorical_features, array_ty
     respect to the number of categories in the categorical features targeted.
     """
     X = [["A", 1, "A"], ["B", 0, "C"], ["C", 2, "B"]]
-    column_name = ["col_A", "col_B", "col_C"]
-    X = _convert_container(X, array_type, columns_name=column_name)
+    column_names = ["col_A", "col_B", "col_C"]
+    X = _convert_container(X, array_type, column_names=column_names)
     y = np.array([1.2, 0.5, 0.45]).T
 
     preprocessor = make_column_transformer((OneHotEncoder(), categorical_features))
@@ -1007,7 +1007,7 @@ def test_grid_resolution_with_categorical(pyplot, categorical_features, array_ty
             model,
             X,
             features=["col_C"],
-            feature_names=column_name,
+            feature_names=column_names,
             categorical_features=categorical_features,
             grid_resolution=2,
         )

sklearn/inspection/tests/test_pd_utils.py

@@ -16,7 +16,7 @@
 def test_check_feature_names(feature_names, array_type, expected_feature_names):
     X = np.random.randn(10, 3)
     column_names = ["a", "b", "c"]
-    X = _convert_container(X, constructor_name=array_type, columns_name=column_names)
+    X = _convert_container(X, constructor_name=array_type, column_names=column_names)
     feature_names_validated = _check_feature_names(X, feature_names)
     assert feature_names_validated == expected_feature_names
 

sklearn/preprocessing/tests/test_function_transformer.py

@@ -192,7 +192,7 @@ def test_function_transformer_raise_error_with_mixed_dtype(X_type):
     dtype = "object"
 
     data = ["one", "two", "three", "one", "one", 5, 6]
-    data = _convert_container(data, X_type, columns_name=["value"], dtype=dtype)
+    data = _convert_container(data, X_type, column_names=["value"], dtype=dtype)
 
     def func(X):
         return np.array([mapping[X[i]] for i in range(X.size)], dtype=object)
@@ -201,7 +201,7 @@ def inverse_func(X):
         return _convert_container(
             [inverse_mapping[x] for x in X],
             X_type,
-            columns_name=["value"],
+            column_names=["value"],
             dtype=dtype,
         )
 

sklearn/tests/test_base.py

@@ -924,7 +924,7 @@ def test_feature_names_in_on_dataframes(constructor_name, minversion):
     data = [[1, 4, 2], [3, 3, 6]]
     columns = ["col_0", "col_1", "col_2"]
     df = _convert_container(
-        data, constructor_name, columns_name=columns, minversion=minversion
+        data, constructor_name, column_names=columns, minversion=minversion
     )
 
     class NoOpTransformer(TransformerMixin, BaseEstimator):
@@ -946,7 +946,7 @@ def transform(self, X):
         assert_allclose(df, X_out)
 
     bad_names = ["a", "b", "c"]
-    df_bad = _convert_container(data, constructor_name, columns_name=bad_names)
+    df_bad = _convert_container(data, constructor_name, column_names=bad_names)
     with pytest.raises(ValueError, match="The feature names should match"):
         no_op.transform(df_bad)
 

sklearn/utils/_testing.py

@@ -967,7 +967,7 @@ def assert_run_python_script_without_output(source_code, pattern=".+", timeout=6
 def _convert_container(
     container,
     constructor_name,
-    columns_name=None,
+    column_names=None,
     dtype=None,
     minversion=None,
     categorical_feature_names=None,
@@ -983,8 +983,8 @@ def _convert_container(
             "sparse_csr_array", "sparse_csc_array", "pyarrow", "polars", \
             "polars_series"}
         The type of the returned container.
-    columns_name : index or array-like, default=None
-        For pandas/polars container supporting `columns_names`, it will affect
+    column_names : index or array-like, default=None
+        For pandas/polars container supporting `column_names`, it will affect
         specific names.
     dtype : dtype, default=None
         Force the dtype of the container. Does not apply to `"slice"`
@@ -1012,7 +1012,7 @@ def _convert_container(
         return np.asarray(container, dtype=dtype)
     elif constructor_name == "pandas":
         pd = pytest.importorskip("pandas", minversion=minversion)
-        result = pd.DataFrame(container, columns=columns_name, dtype=dtype, copy=False)
+        result = pd.DataFrame(container, columns=column_names, dtype=dtype, copy=False)
         if categorical_feature_names is not None:
             for col_name in categorical_feature_names:
                 result[col_name] = result[col_name].astype("category")
@@ -1021,9 +1021,9 @@ def _convert_container(
         pa = pytest.importorskip("pyarrow", minversion=minversion)
         array = np.asarray(container)
         array = array[:, None] if array.ndim == 1 else array
-        if columns_name is None:
-            columns_name = [f"col{i}" for i in range(array.shape[1])]
-        data = {name: array[:, i] for i, name in enumerate(columns_name)}
+        if column_names is None:
+            column_names = [f"col{i}" for i in range(array.shape[1])]
+        data = {name: array[:, i] for i, name in enumerate(column_names)}
         result = pa.Table.from_pydict(data)
         if categorical_feature_names is not None:
             for col_idx, col_name in enumerate(result.column_names):
@@ -1034,7 +1034,7 @@ def _convert_container(
         return result
     elif constructor_name == "polars":
         pl = pytest.importorskip("polars", minversion=minversion)
-        result = pl.DataFrame(container, schema=columns_name, orient="row")
+        result = pl.DataFrame(container, schema=column_names, orient="row")
         if categorical_feature_names is not None:
             for col_name in categorical_feature_names:
                 result = result.with_columns(pl.col(col_name).cast(pl.Categorical))

sklearn/utils/tests/test_indexing.py

@@ -214,9 +214,9 @@ def test_safe_indexing_2d_container_axis_1(array_type, indices_type, indices):
     if indices_type == "slice" and isinstance(indices[1], int):
         indices_converted[1] += 1
 
-    columns_name = ["col_0", "col_1", "col_2"]
+    column_names = ["col_0", "col_1", "col_2"]
     array = _convert_container(
-        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, columns_name
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, column_names
     )
     indices_converted = _convert_container(indices_converted, indices_type)
 
@@ -278,9 +278,9 @@ def test_safe_indexing_1d_container_mask(array_type, indices_type):
     [(0, [[4, 5, 6], [7, 8, 9]]), (1, [[2, 3], [5, 6], [8, 9]])],
 )
 def test_safe_indexing_2d_mask(array_type, indices_type, axis, expected_subset):
-    columns_name = ["col_0", "col_1", "col_2"]
+    column_names = ["col_0", "col_1", "col_2"]
     array = _convert_container(
-        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, columns_name
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, column_names
     )
     indices = [False, True, True]
     indices = _convert_container(indices, indices_type)
@@ -332,9 +332,9 @@ def test_safe_indexing_1d_scalar(array_type):
 )
 @pytest.mark.parametrize("indices", [2, "col_2"])
 def test_safe_indexing_2d_scalar_axis_1(array_type, expected_output_type, indices):
-    columns_name = ["col_0", "col_1", "col_2"]
+    column_names = ["col_0", "col_1", "col_2"]
     array = _convert_container(
-        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, columns_name
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], array_type, column_names
     )
 
     if isinstance(indices, str) and array_type in ("array", "sparse"):
@@ -513,7 +513,7 @@ def test_get_column_indices_pandas_nonunique_columns_error(key):
 def test_get_column_indices_dataframes(constructor_name):
     """Check _get_column_indices for edge cases with 2d input X."""
     df = _convert_container(
-        [[1, 2, 3], [4, 5, 6]], constructor_name, columns_name=["a", "b", "c"]
+        [[1, 2, 3], [4, 5, 6]], constructor_name, column_names=["a", "b", "c"]
     )
 
     key_results = [