Merge branch 'main' into enforce-ruff-rule-b905-conftest

Author: natianyudi

doc/source/whatsnew/v3.0.0.rst

@@ -1013,6 +1013,7 @@ Strings
 ^^^^^^^
 - Bug in :meth:`Series.str.zfill` raising ``AttributeError`` for :class:`ArrowDtype` (:issue:`61485`)
 - Bug in :meth:`Series.value_counts` would not respect ``sort=False`` for series having ``string`` dtype (:issue:`55224`)
+- Bug in multiplication with a :class:`StringDtype` incorrectly allowing multiplying by bools; explicitly cast to integers instead (:issue:`62595`)
 
 Interval
 ^^^^^^^^

pandas/core/arrays/string_.py

@@ -1113,6 +1113,16 @@ def _cmp_method(self, other, op):
                 other = np.asarray(other)
             other = other[valid]
 
+        other_dtype = getattr(other, "dtype", None)
+        if op.__name__.strip("_") in ["mul", "rmul"] and (
+            lib.is_bool(other) or lib.is_np_dtype(other_dtype, "b")
+        ):
+            # GH#62595
+            raise TypeError(
+                "Cannot multiply StringArray by bools. "
+                "Explicitly cast to integers instead."
+            )
+
         if op.__name__ in ops.ARITHMETIC_BINOPS:
             result = np.empty_like(self._ndarray, dtype="object")
             result[mask] = self.dtype.na_value

pandas/tests/arithmetic/test_string.py

@@ -112,3 +112,25 @@ def test_pyarrow_numpy_string_invalid():
 
     with pytest.raises(TypeError, match="Invalid comparison"):
         ser > ser4
+
+
+def test_mul_bool_invalid(any_string_dtype):
+    # GH#62595
+    dtype = any_string_dtype
+    ser = Series(["a", "b", "c"], dtype=dtype)
+
+    if dtype == object:
+        pytest.skip("This is not expect to raise")
+    elif dtype.storage == "python":
+        msg = "Cannot multiply StringArray by bools. Explicitly cast to integers"
+    else:
+        msg = "Can only string multiply by an integer"
+
+    with pytest.raises(TypeError, match=msg):
+        False * ser
+    with pytest.raises(TypeError, match=msg):
+        ser * True
+    with pytest.raises(TypeError, match=msg):
+        ser * np.array([True, False, True], dtype=bool)
+    with pytest.raises(TypeError, match=msg):
+        np.array([True, False, True], dtype=bool) * ser

pandas/tests/io/pytables/test_round_trip.py

@@ -11,6 +11,7 @@
 from pandas import (
     DataFrame,
     DatetimeIndex,
+    HDFStore,
     Index,
     Series,
     _testing as tm,
@@ -20,7 +21,6 @@
 )
 from pandas.tests.io.pytables.common import (
     _maybe_remove,
-    ensure_clean_store,
 )
 from pandas.util import _test_decorators as td
 
@@ -54,12 +54,12 @@ def roundtrip(key, obj, **kwargs):
     tm.assert_frame_equal(df[df.index > 2], result)
 
 
-def test_long_strings(setup_path):
+def test_long_strings(temp_file):
     # GH6166
     data = ["a" * 50] * 10
     df = DataFrame({"a": data}, index=data)
 
-    with ensure_clean_store(setup_path) as store:
+    with HDFStore(temp_file) as store:
         store.append("df", df, data_columns=["a"])
 
         result = store.select("df")
@@ -96,8 +96,8 @@ def test_api_append(tmp_path, setup_path):
     tm.assert_frame_equal(read_hdf(path, "df"), df)
 
 
-def test_api_2(tmp_path, setup_path):
-    path = tmp_path / setup_path
+def test_api_2(tmp_path, temp_file):
+    path = tmp_path / temp_file
 
     df = DataFrame(range(20))
     df.to_hdf(path, key="df", append=False, format="fixed")
@@ -112,7 +112,7 @@ def test_api_2(tmp_path, setup_path):
     df.to_hdf(path, key="df")
     tm.assert_frame_equal(read_hdf(path, "df"), df)
 
-    with ensure_clean_store(setup_path) as store:
+    with HDFStore(temp_file) as store:
         df = DataFrame(range(20))
 
         _maybe_remove(store, "df")
@@ -171,8 +171,8 @@ def test_api_invalid(tmp_path, setup_path):
         read_hdf(path, "df")
 
 
-def test_get(setup_path):
-    with ensure_clean_store(setup_path) as store:
+def test_get(temp_file):
+    with HDFStore(temp_file) as store:
         store["a"] = Series(
             np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
         )
@@ -194,8 +194,8 @@ def test_put_integer(setup_path):
     _check_roundtrip(df, tm.assert_frame_equal, setup_path)
 
 
-def test_table_values_dtypes_roundtrip(setup_path, using_infer_string):
-    with ensure_clean_store(setup_path) as store:
+def test_table_values_dtypes_roundtrip(temp_file, using_infer_string):
+    with HDFStore(temp_file) as store:
         df1 = DataFrame({"a": [1, 2, 3]}, dtype="f8")
         store.append("df_f8", df1)
         tm.assert_series_equal(df1.dtypes, store["df_f8"].dtypes)
@@ -361,7 +361,7 @@ def test_timeseries_preepoch(setup_path, request):
 @pytest.mark.parametrize(
     "compression", [False, pytest.param(True, marks=td.skip_if_windows)]
 )
-def test_frame(compression, setup_path):
+def test_frame(compression, temp_file):
     df = DataFrame(
         1.1 * np.arange(120).reshape((30, 4)),
         columns=Index(list("ABCD")),
@@ -373,22 +373,20 @@ def test_frame(compression, setup_path):
     df.iloc[5, 3] = np.nan
 
     _check_roundtrip_table(
-        df, tm.assert_frame_equal, path=setup_path, compression=compression
-    )
-    _check_roundtrip(
-        df, tm.assert_frame_equal, path=setup_path, compression=compression
+        df, tm.assert_frame_equal, path=temp_file, compression=compression
     )
+    _check_roundtrip(df, tm.assert_frame_equal, path=temp_file, compression=compression)
 
     tdf = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=Index(list("ABCD")),
         index=date_range("2000-01-01", periods=10, freq="B"),
     )
     _check_roundtrip(
-        tdf, tm.assert_frame_equal, path=setup_path, compression=compression
+        tdf, tm.assert_frame_equal, path=temp_file, compression=compression
     )
 
-    with ensure_clean_store(setup_path) as store:
+    with HDFStore(temp_file) as store:
         # not consolidated
         df["foo"] = np.random.default_rng(2).standard_normal(len(df))
         store["df"] = df
@@ -399,7 +397,7 @@ def test_frame(compression, setup_path):
     df2 = df[:0]
     # Prevent df2 from having index with inferred_type as string
     df2.index = Index([])
-    _check_roundtrip(df2[:0], tm.assert_frame_equal, path=setup_path)
+    _check_roundtrip(df2[:0], tm.assert_frame_equal, path=temp_file)
 
 
 def test_empty_series_frame(setup_path):
@@ -432,22 +430,22 @@ def test_can_serialize_dates(setup_path):
 
 
 def test_store_hierarchical(
-    setup_path, using_infer_string, multiindex_dataframe_random_data
+    temp_file, using_infer_string, multiindex_dataframe_random_data
 ):
     frame = multiindex_dataframe_random_data
 
     if using_infer_string:
         # TODO(infer_string) make this work for string dtype
         msg = "Saving a MultiIndex with an extension dtype is not supported."
         with pytest.raises(NotImplementedError, match=msg):
-            _check_roundtrip(frame, tm.assert_frame_equal, path=setup_path)
+            _check_roundtrip(frame, tm.assert_frame_equal, path=temp_file)
         return
-    _check_roundtrip(frame, tm.assert_frame_equal, path=setup_path)
-    _check_roundtrip(frame.T, tm.assert_frame_equal, path=setup_path)
-    _check_roundtrip(frame["A"], tm.assert_series_equal, path=setup_path)
+    _check_roundtrip(frame, tm.assert_frame_equal, path=temp_file)
+    _check_roundtrip(frame.T, tm.assert_frame_equal, path=temp_file)
+    _check_roundtrip(frame["A"], tm.assert_series_equal, path=temp_file)
 
     # check that the names are stored
-    with ensure_clean_store(setup_path) as store:
+    with HDFStore(temp_file) as store:
         store["frame"] = frame
         recons = store["frame"]
         tm.assert_frame_equal(recons, frame)
@@ -456,7 +454,7 @@ def test_store_hierarchical(
 @pytest.mark.parametrize(
     "compression", [False, pytest.param(True, marks=td.skip_if_windows)]
 )
-def test_store_mixed(compression, setup_path):
+def test_store_mixed(compression, temp_file):
     def _make_one():
         df = DataFrame(
             1.1 * np.arange(120).reshape((30, 4)),
@@ -474,10 +472,10 @@ def _make_one():
     df1 = _make_one()
     df2 = _make_one()
 
-    _check_roundtrip(df1, tm.assert_frame_equal, path=setup_path)
-    _check_roundtrip(df2, tm.assert_frame_equal, path=setup_path)
+    _check_roundtrip(df1, tm.assert_frame_equal, path=temp_file)
+    _check_roundtrip(df2, tm.assert_frame_equal, path=temp_file)
 
-    with ensure_clean_store(setup_path) as store:
+    with HDFStore(temp_file) as store:
         store["obj"] = df1
         tm.assert_frame_equal(store["obj"], df1)
         store["obj"] = df2
@@ -487,19 +485,19 @@ def _make_one():
     _check_roundtrip(
         df1["obj1"],
         tm.assert_series_equal,
-        path=setup_path,
+        path=temp_file,
         compression=compression,
     )
     _check_roundtrip(
         df1["bool1"],
         tm.assert_series_equal,
-        path=setup_path,
+        path=temp_file,
         compression=compression,
     )
     _check_roundtrip(
         df1["int1"],
         tm.assert_series_equal,
-        path=setup_path,
+        path=temp_file,
         compression=compression,
     )
 
@@ -509,7 +507,7 @@ def _check_roundtrip(obj, comparator, path, compression=False, **kwargs):
     if compression:
         options["complib"] = "blosc"
 
-    with ensure_clean_store(path, "w", **options) as store:
+    with HDFStore(path, "w", **options) as store:
         store["obj"] = obj
         retrieved = store["obj"]
         comparator(retrieved, obj, **kwargs)
@@ -520,7 +518,7 @@ def _check_roundtrip_table(obj, comparator, path, compression=False):
     if compression:
         options["complib"] = "blosc"
 
-    with ensure_clean_store(path, "w", **options) as store:
+    with HDFStore(path, "w", **options) as store:
         store.put("obj", obj, format="table")
         retrieved = store["obj"]
 
@@ -537,17 +535,17 @@ def test_unicode_index(setup_path):
     _check_roundtrip(s, tm.assert_series_equal, path=setup_path)
 
 
-def test_unicode_longer_encoded(setup_path):
+def test_unicode_longer_encoded(temp_file):
     # GH 11234
     char = "\u0394"
     df = DataFrame({"A": [char]})
-    with ensure_clean_store(setup_path) as store:
+    with HDFStore(temp_file) as store:
         store.put("df", df, format="table", encoding="utf-8")
         result = store.get("df")
         tm.assert_frame_equal(result, df)
 
     df = DataFrame({"A": ["a", char], "B": ["b", "b"]})
-    with ensure_clean_store(setup_path) as store:
+    with HDFStore(temp_file) as store:
         store.put("df", df, format="table", encoding="utf-8")
         result = store.get("df")
         tm.assert_frame_equal(result, df)

pandas/tests/util/test_assert_frame_equal.py

@@ -1,3 +1,4 @@
+import numpy as np
 import pytest
 
 from pandas.errors import Pandas4Warning
@@ -413,3 +414,12 @@ def test_datetimelike_compat_deprecated():
         tm.assert_series_equal(df["a"], df["a"], check_datetimelike_compat=True)
     with tm.assert_produces_warning(Pandas4Warning, match=msg):
         tm.assert_series_equal(df["a"], df["a"], check_datetimelike_compat=False)
+
+
+@pytest.mark.parametrize("na_value", [pd.NA, np.nan, None])
+def test_assert_frame_equal_nested_df_na(na_value):
+    # GH#43022
+    inner = DataFrame({"a": [1, na_value]})
+    df1 = DataFrame({"df": [inner]})
+    df2 = DataFrame({"df": [inner]})
+    tm.assert_frame_equal(df1, df2)