Merge remote-tracking branch 'upstream/main' into fix-tablereport-narrow-range

jeromedockes · jeromedockes · commit 8d9d42b8ec37 · 2026-06-29T16:30:35.000+02:00
diff --git a/CHANGES.rst b/CHANGES.rst
@@ -44,6 +44,9 @@ New Features
   columns (the bin count and edges, and numbers of low and high outliers). Now
   ``json()`` contains all the information shown in the report html rendering,
   including the plots. :pr:`2164` by :user:`Jérôme Dockès <jeromedockes>`.
+- Added :func:`skrub.selectors.object` to select columns with the ``object``
+  (pandas) or ``pl.Object`` (polars) dtype. :pr:`2171` by :user:`Omkar Kabde
+  <omkar-334>`.
 
 Changes
 -------
@@ -65,6 +68,12 @@ Changes
 
 Bugfixes
 --------
+- :class:`MinHashEncoder` with the default ``hashing="fast"`` now uses every
+  n-gram size in ``ngram_range`` (the upper bound is inclusive, as documented
+  and as already done by ``hashing="murmur"``). Previously the largest size was
+  dropped, so the default ``ngram_range=(2, 4)`` ignored 4-grams and a
+  single-size range such as ``(3, 3)`` produced the same constant encoding for
+  every string. :pr:`2168` by :user:`José Maia <glitch-ux>`.
 - A bug in how the :class:`TableVectorizer` and :class:`Cleaner` treated columns
   duration columns in pandas and polars has been fixed. Now, both classes convert
   durations to the total number of seconds (with fractional part). This is done
@@ -74,6 +83,9 @@ Bugfixes
   double dollar (``$$``) signs has been fixed.
   :pr:`2154` by :user:`Katerina Michenina <Michenina-Lab>`,
   :user:`CecilyTS <CecilyTS>`, :user:`Eve Rabin <eve2705>`.
+- An error that happened when running ``TableReport`` or ``column_associations``
+  on some dataframes with non-string column names has been fixed in :pr:`2179`
+  by :user:`Jérôme Dockès <jeromedockes>`.
 
 Deprecations
 ------------
diff --git a/doc/api_reference.py b/doc/api_reference.py
@@ -158,6 +158,7 @@
                     "selectors.inv",
                     "selectors.make_selector",
                     "selectors.numeric",
+                    "selectors.object",
                     "selectors.regex",
                     "selectors.select",
                     "selectors.string",
diff --git a/doc/modules/multi_column_operations/type_of_selectors.rst b/doc/modules/multi_column_operations/type_of_selectors.rst
@@ -79,6 +79,7 @@ Selectors based on column data types
 - :func:`~skrub.selectors.any_date`: Select columns with date or datetime data types
 - :func:`~skrub.selectors.categorical`: Select columns with categorical data types
 - :func:`~skrub.selectors.string`: Select columns with string data types
+- :func:`~skrub.selectors.object`: Select columns with the ``object`` (pandas) or ``pl.Object`` (polars) dtype
 - :func:`~skrub.selectors.boolean`: Select columns with boolean data types
 
 Selectors based on column content and properties
diff --git a/pixi.lock b/pixi.lock
diff --git a/skrub/_check_input.py b/skrub/_check_input.py
@@ -20,14 +20,6 @@ def cast_column_names_to_strings(df):
 
 
 def _column_names_to_strings(column_names):
-    non_string = [c for c in column_names if not isinstance(c, str)]
-    if not non_string:
-        return column_names
-    warnings.warn(
-        f"Some dataframe column names are not strings: {non_string}.\n"
-        "All dataframe column names must be strings in skrub pipelines; "
-        "converting to strings."
-    )
     return list(map(str, column_names))
 
 
diff --git a/skrub/_column_associations.py b/skrub/_column_associations.py
@@ -302,9 +302,11 @@ def _melt(df, left_col, right_col, val):
 def _melt_pandas(df, left_col, right_col, val):
     # Deal with multi-level index and columns
     if df.index.nlevels > 1:
-        df.index = df.index.to_flat_index().astype("string")
+        df.index = df.index.to_flat_index()
+    df.index = df.index.astype("string")
     if df.columns.nlevels > 1:
-        df.columns = df.columns.to_flat_index().astype("string")
+        df.columns = df.columns.to_flat_index()
+    df.columns = df.columns.astype("string")
     return df.melt(ignore_index=False, var_name=right_col, value_name=val).reset_index(
         names=left_col
     )
diff --git a/skrub/_data_ops/tests/test_data_ops.py b/skrub/_data_ops/tests/test_data_ops.py
@@ -879,34 +879,42 @@ def test_concat_vertical_duplicate_cols():
 def test_concat_non_str_colname():
     int_columns = pd.DataFrame({0: [1, 2], 1: [3, 4]})
     string_columns = pd.DataFrame({"0": [1, 2], "1": [3, 4]})
+    result = (
+        skrub.as_data_op(int_columns)
+        .skb.concat([skrub.as_data_op(string_columns)], axis=1)
+        .skb.eval()
+    )
+    assert result.shape == (2, 4)
 
-    # check that a warning is raised because of non-string column name
-    with pytest.warns(
-        UserWarning, match="Some dataframe column names are not strings:"
-    ):
-        skrub.as_data_op(int_columns).skb.concat(
-            [skrub.as_data_op(string_columns)], axis=1
-        )
-    with pytest.warns(
-        UserWarning, match="Some dataframe column names are not strings:"
-    ):
-        skrub.as_data_op(int_columns).skb.concat(
-            [skrub.as_data_op(int_columns)], axis=1
-        )
+    result = (
+        skrub.as_data_op(int_columns)
+        .skb.concat([skrub.as_data_op(int_columns)], axis=1)
+        .skb.eval()
+    )
+    assert result.shape == (2, 4)
 
-    # no warnings raised when all column names are strings
-    with warnings.catch_warnings():
-        warnings.simplefilter("error")
-        skrub.as_data_op(string_columns).skb.concat(
-            [skrub.as_data_op(string_columns)], axis=1
-        )
+    result = (
+        skrub.as_data_op(string_columns)
+        .skb.concat([skrub.as_data_op(string_columns)], axis=1)
+        .skb.eval()
+    )
+    assert result.shape == (2, 4)
 
-    # check that no warning is raised when concatenating vertically
-    with warnings.catch_warnings():
-        warnings.simplefilter("error")
-        skrub.as_data_op(int_columns).skb.concat(
-            [skrub.as_data_op(int_columns)], axis=0
-        )
+    result = (
+        skrub.as_data_op(int_columns)
+        .skb.concat([skrub.as_data_op(int_columns)], axis=0)
+        .skb.eval()
+    )
+    assert result.shape == (4, 2)
+    assert list(result.columns) == [0, 1]
+
+    result = (
+        skrub.as_data_op(string_columns)
+        .skb.concat([skrub.as_data_op(string_columns)], axis=0)
+        .skb.eval()
+    )
+    assert result.shape == (4, 2)
+    assert list(result.columns) == ["0", "1"]
 
 
 def test_concat_numpy_arrays():
@@ -928,6 +936,12 @@ def test_concat_numpy_arrays():
     np.testing.assert_array_equal(out, expected)
 
 
+def test_int_column_names():
+    assert list(
+        skrub.X(pd.DataFrame({0: [1, 2]})).skb.apply("passthrough").skb.eval().columns
+    ) == ["0"]
+
+
 def test_get_vars():
     a = skrub.var("a")
     b = skrub.var("b")
diff --git a/skrub/_data_ops/tests/test_errors.py b/skrub/_data_ops/tests/test_errors.py
@@ -3,7 +3,6 @@
 import traceback
 
 import numpy as np
-import pandas as pd
 import pytest
 from sklearn.datasets import make_classification
 from sklearn.dummy import DummyClassifier
@@ -638,11 +637,6 @@ def test_unhashable():
         {skrub.choose_bool(name="b").if_else(0, 1)}
 
 
-def test_int_column_names():
-    with pytest.warns(match="Some dataframe column names are not strings"):
-        skrub.X(pd.DataFrame({0: [1, 2]})).skb.apply("passthrough")
-
-
 def test_mark_as_X_missing_cv():
     with pytest.raises(TypeError, match=".*you must also provide a splitter"):
         skrub.var("a").skb.mark_as_X(split_kwargs={"groups": None})
diff --git a/skrub/_fast_hash.py b/skrub/_fast_hash.py
@@ -82,7 +82,10 @@ def ngram_min_hash(
 
     max_hash = MININT32
     min_hash = MAXINT32
-    for atom_len in range(ngram_range[0], ngram_range[1]):
+    # The upper bound is inclusive: all n-gram sizes such that
+    # ``min_n <= n <= max_n`` are used, matching the documented behavior and
+    # the ``murmur`` hashing path (see ``get_unique_ngrams``).
+    for atom_len in range(ngram_range[0], ngram_range[1] + 1):
         atom = gen_atom(atom_len, seed=seed)
         # np.correlate is faster than np.convolve
         # the convolution gives a hash for each ngram
diff --git a/skrub/_minhash_encoder.py b/skrub/_minhash_encoder.py
@@ -107,9 +107,9 @@ class MinHashEncoder(TransformerMixin, SingleColumnTransformer):
 
     >>> enc.transform(X)
              city_0        city_1        city_2        city_3        city_4
-    0 -1.783375e+09 -1.588270e+09 -1.663592e+09 -1.819887e+09 -1.962594e+09
-    1 -8.480470e+08 -1.766579e+09 -1.558912e+09 -1.485745e+09 -1.687299e+09
-    2 -1.975829e+09 -2.095000e+09 -1.596521e+09 -1.817594e+09 -2.095693e+09
+    0 -2.127555e+09 -2.111535e+09 -1.925126e+09 -1.819887e+09 -1.962594e+09
+    1 -2.127555e+09 -2.111535e+09 -1.718267e+09 -1.485745e+09 -1.687299e+09
+    2 -1.975829e+09 -2.095000e+09 -1.659302e+09 -1.817594e+09 -2.095693e+09
     3 -1.975829e+09 -2.095000e+09 -1.530721e+09 -1.459183e+09 -1.580988e+09
     """
 
diff --git a/skrub/_reporting/js_tests/package-lock.json b/skrub/_reporting/js_tests/package-lock.json
diff --git a/skrub/selectors/_selectors.py b/skrub/selectors/_selectors.py
@@ -15,6 +15,7 @@
     "any_date",
     "categorical",
     "string",
+    "object",
     "boolean",
     "cardinality_below",
     "has_nulls",
@@ -520,6 +521,49 @@ def string():
     return Filter(sbd.is_string, name="string")
 
 
+def object():
+    """
+    Select columns whose dtype is ``object`` (pandas) or ``pl.Object`` (polars).
+
+    Notes
+    -----
+    Before pandas 3.0, columns containing only strings have the ``object``
+    dtype and are selected. From pandas 3.0 onwards they have the ``string``
+    dtype and are not. Use :func:`~skrub.selectors.string` for
+    selecting strings.
+
+    See Also
+    --------
+    string :
+        Select columns that have a String data type.
+    has_dtype :
+        Select columns whose dtype matches one of the provided dtypes.
+
+    Examples
+    --------
+    >>> from skrub import selectors as s
+    >>> import pandas as pd
+    >>> df = pd.DataFrame(
+    ...     dict(
+    ...         mixed=pd.Series(['A', 10]),
+    ...         numeric=pd.Series([1, 2]),
+    ...         string=pd.Series(['A', 'B']).convert_dtypes(),
+    ...     )
+    ... )
+    >>> df.dtypes
+    mixed       object
+    numeric      int64
+    string         ...
+    dtype: object
+
+    >>> s.select(df, s.object())
+      mixed
+    0     A
+    1    10
+    """
+    return Filter(sbd.is_object, name="object")
+
+
 def boolean():
     """
     Select columns that have a Boolean data type.
diff --git a/skrub/selectors/tests/test_selectors.py b/skrub/selectors/tests/test_selectors.py
@@ -75,10 +75,12 @@ def test_dtype_selectors(df_module):
     assert s.categorical().expand(df) == ["cat-col"]
     if df_module.name == "polars":
         assert s.any_date().expand(df) == ["datetime-col", "date-col"]
+        assert s.object().expand(df) == []
     else:
         # pandas doesn't have a 'date' dtype, only datetime
         assert df_module.name == "pandas"
         assert s.any_date().expand(df) == ["datetime-col"]
+        assert s.object().expand(df) == df.dtypes[df.dtypes == object].index.tolist()
 
 
 def test_has_dtype(df_module):
@@ -101,10 +103,33 @@ def test_has_dtype(df_module):
 
 
 def test_dtype_pandas_object():
-    # Testing for behavior with object and string columns
+    # Behaviour of `string()` and `object()` on object and string columns.
     df = pd.DataFrame({"string-object": ["foo", "bar"], "object-object": ["baz", 42]})
 
     assert s.string().expand(df) == ["string-object"]
+    assert s.object().expand(df) == df.dtypes[df.dtypes == object].index.tolist()
+
+
+def test_object_selector_pandas_string_extension():
+    # Pandas extension-dtype string columns are not `object`.
+    df = pd.DataFrame(
+        {
+            "ext-string": pd.Series(["a", "b"]).convert_dtypes(),
+            "mixed": pd.Series(["a", 1]),
+        }
+    )
+    assert s.object().expand(df) == ["mixed"]
+
+
+def test_object_selector_polars():
+    pl = pytest.importorskip("polars")
+    df = pl.DataFrame(
+        {
+            "str-col": pl.Series(["a", "b"], dtype=pl.String),
+            "obj-col": pl.Series([object(), object()], dtype=pl.Object),
+        }
+    )
+    assert s.object().expand(df) == ["obj-col"]
 
 
 def test_cardinality_below(df_module, monkeypatch):
diff --git a/skrub/tests/test_check_input.py b/skrub/tests/test_check_input.py
@@ -53,9 +53,8 @@ def test_column_names_to_unique_strings():
     df = pd.DataFrame(np.ones((2, 4)), columns=["a", 0, "0", "a"])
     assert df.columns.tolist() == ["a", 0, "0", "a"]
     check = CheckInputDataFrame()
-    with pytest.warns(UserWarning, match="Some dataframe column names are not strings"):
-        with pytest.warns(UserWarning, match="Found duplicated column names"):
-            out = check.fit_transform(df)
+    with pytest.warns(UserWarning, match="Found duplicated column names"):
+        out = check.fit_transform(df)
     assert out.shape == (2, 4)
     out_cols = out.columns.tolist()
     assert out_cols[:2] == ["a", "0"]
diff --git a/skrub/tests/test_fast_hash.py b/skrub/tests/test_fast_hash.py
