TST: fix tests for mixed int string index

pandas/_testing/__init__.py

@@ -76,6 +76,7 @@
     assert_is_sorted,
     assert_is_valid_plot_return_object,
     assert_metadata_equivalent,
+    assert_mixed_int_string_entry,
     assert_numpy_array_equal,
     assert_period_array_equal,
     assert_series_equal,
@@ -987,6 +988,7 @@ def shares_memory(left, right) -> bool:
     "assert_produces_warning",
     "assert_series_equal",
     "assert_sp_array_equal",
+    "assert_mixed_int_string_entry",
     "assert_timedelta_array_equal",
     "assert_cow_warning",
     "at",

pandas/_testing/asserters.py

@@ -1382,3 +1382,20 @@ def assert_metadata_equivalent(
             assert val is None
         else:
             assert val == getattr(right, attr, None)
+
+
+def assert_mixed_int_string_entry(arr) -> bool:
+    """
+    Check that arr is mixed-int-string entry.
+    """
+    # we might have an entry [0, "a", 1, "b", 2, "c"] with duplicates
+    # or with None or without the first element
+    if len(arr) < 3:
+        return False
+    else:
+        if isinstance(arr[0], int):
+            return isinstance(arr[1], str)
+        elif isinstance(arr[0], str):
+            return isinstance(arr[1], int)
+        else:
+            return isinstance(arr[2], int) and isinstance(arr[3], str)

pandas/conftest.py

@@ -635,6 +635,7 @@ def _create_mi_with_dt64tz_level():
     "empty": Index([]),
     "tuples": MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3])),
     "mi-with-dt64tz-level": _create_mi_with_dt64tz_level(),
+    "mixed-int-string": Index([0, "a", 1, "b", 2, "c"]),
     "multi": _create_multiindex(),
     "repeats": Index([0, 0, 1, 1, 2, 2]),
     "nullable_int": Index(np.arange(100), dtype="Int64"),

pandas/core/sorting.py

@@ -436,7 +436,13 @@ def nargsort(
     if not ascending:
         non_nans = non_nans[::-1]
         non_nan_idx = non_nan_idx[::-1]
-    indexer = non_nan_idx[non_nans.argsort(kind=kind)]
+    # GH#54072
+    # argsort does not support mixed int/string Index
+    try:
+        indexer = non_nan_idx[non_nans.argsort(kind=kind)]
+    except TypeError as err:
+        msg = "'<' not supported between instances of 'int' and 'str'"
+        raise TypeError(msg) from err
     if not ascending:
         indexer = indexer[::-1]
     # Finally, place the NaNs at the end or the beginning according to

pandas/tests/base/test_misc.py

@@ -157,6 +157,15 @@ def test_searchsorted(request, index_or_series_obj):
         mark = pytest.mark.xfail(reason="complex objects are not comparable")
         request.applymarker(mark)
 
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(obj.values):
+        with pytest.raises(
+            TypeError, match="'>' not supported between instances of 'str' and 'int'"
+        ):
+            max_obj = max(obj, default=0)
+            index = np.searchsorted(obj, max_obj)
+        return
+
     max_obj = max(obj, default=0)
     index = np.searchsorted(obj, max_obj)
     assert 0 <= index <= len(obj)

pandas/tests/base/test_value_counts.py

@@ -47,12 +47,18 @@ def test_value_counts(index_or_series_obj):
             # i.e IntegerDtype
             expected = expected.astype("Int64")
 
-    # TODO(GH#32514): Order of entries with the same count is inconsistent
-    #  on CI (gh-32449)
-    if obj.duplicated().any():
-        result = result.sort_index()
-        expected = expected.sort_index()
-    tm.assert_series_equal(result, expected)
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(obj.values):
+        msg = "'<' not supported between instances of 'int' and 'str'"
+        with pytest.raises(TypeError, match=msg):
+            result.sort_index()
+    else:
+        # TODO(GH#32514): Order of entries with the same count is inco8nsistent
+        #  on CI (gh-32449)
+        if obj.duplicated().any():
+            result = result.sort_index()
+            expected = expected.sort_index()
+        tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize("null_obj", [np.nan, None])
@@ -67,6 +73,9 @@ def test_value_counts_null(null_obj, index_or_series_obj):
         pytest.skip("Test doesn't make sense on empty data")
     elif isinstance(orig, MultiIndex):
         pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(orig.values):
+        pytest.skip("'<' not supported between instances of 'str' and 'int'")
 
     values = obj._values
     values[0:2] = null_obj

pandas/tests/indexes/multi/test_setops.py

@@ -629,7 +629,11 @@ def test_union_duplicates(index, request):
     values = index.unique().values.tolist()
     mi1 = MultiIndex.from_arrays([values, [1] * len(values)])
     mi2 = MultiIndex.from_arrays([[values[0]] + values, [1] * (len(values) + 1)])
-    result = mi2.union(mi1)
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(index.values):
+        pytest.skip("'<' not supported between instances of 'str' and 'int'")
+    else:
+        result = mi2.union(mi1)
     expected = mi2.sort_values()
     tm.assert_index_equal(result, expected)
 

pandas/tests/indexes/test_common.py

@@ -448,8 +448,15 @@ def test_hasnans_isnans(self, index_flat):
 @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
 @pytest.mark.parametrize("na_position", [None, "middle"])
 def test_sort_values_invalid_na_position(index_with_missing, na_position):
-    with pytest.raises(ValueError, match=f"invalid na_position: {na_position}"):
-        index_with_missing.sort_values(na_position=na_position)
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(index_with_missing.values):
+        with pytest.raises(
+            TypeError, match="'<' not supported between instances of 'int' and 'str'"
+        ):
+            index_with_missing.sort_values(na_position=na_position)
+    else:
+        with pytest.raises(ValueError, match=f"invalid na_position: {na_position}"):
+            index_with_missing.sort_values(na_position=na_position)
 
 
 @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
@@ -467,17 +474,26 @@ def test_sort_values_with_missing(index_with_missing, na_position, request):
 
     missing_count = np.sum(index_with_missing.isna())
     not_na_vals = index_with_missing[index_with_missing.notna()].values
-    sorted_values = np.sort(not_na_vals)
-    if na_position == "first":
-        sorted_values = np.concatenate([[None] * missing_count, sorted_values])
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(index_with_missing.values):
+        with pytest.raises(
+            TypeError, match="'<' not supported between instances of 'int' and 'str'"
+        ):
+            np.sort(not_na_vals)
     else:
-        sorted_values = np.concatenate([sorted_values, [None] * missing_count])
+        sorted_values = np.sort(not_na_vals)
+        if na_position == "first":
+            sorted_values = np.concatenate([[None] * missing_count, sorted_values])
+        else:
+            sorted_values = np.concatenate([sorted_values, [None] * missing_count])
 
-    # Explicitly pass dtype needed for Index backed by EA e.g. IntegerArray
-    expected = type(index_with_missing)(sorted_values, dtype=index_with_missing.dtype)
+        # Explicitly pass dtype needed for Index backed by EA e.g. IntegerArray
+        expected = type(index_with_missing)(
+            sorted_values, dtype=index_with_missing.dtype
+        )
 
-    result = index_with_missing.sort_values(na_position=na_position)
-    tm.assert_index_equal(result, expected)
+        result = index_with_missing.sort_values(na_position=na_position)
+        tm.assert_index_equal(result, expected)
 
 
 def test_ndarray_compat_properties(index):

pandas/tests/indexes/test_numpy_compat.py

@@ -160,6 +160,13 @@ def test_numpy_ufuncs_reductions(index, func, request):
         with pytest.raises(TypeError, match="is not ordered for"):
             func.reduce(index)
         return
+    # This check is written for the mixed-int-string entry
+    elif tm.assert_mixed_int_string_entry(index.values):
+        with pytest.raises(
+            TypeError, match=".* not supported between instances of 'int' and 'str'"
+        ):
+            func.reduce(index)
+        return
     else:
         result = func.reduce(index)
 

pandas/tests/indexes/test_old_base.py

@@ -333,18 +333,34 @@ def test_argsort(self, index):
         if isinstance(index, CategoricalIndex):
             pytest.skip(f"{type(self).__name__} separately tested")
 
-        result = index.argsort()
-        expected = np.array(index).argsort()
-        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+        # This check is written for the mixed-int-string entry
+        if tm.assert_mixed_int_string_entry(index.values):
+            with pytest.raises(
+                TypeError,
+                match="'<' not supported between instances of 'str' and 'int'",
+            ):
+                index.argsort()
+        else:
+            result = index.argsort()
+            expected = np.array(index).argsort()
+            tm.assert_numpy_array_equal(result, expected, check_dtype=False)
 
     def test_numpy_argsort(self, index):
-        result = np.argsort(index)
-        expected = index.argsort()
-        tm.assert_numpy_array_equal(result, expected)
+        # This check is written for the mixed-int-string entry
+        if tm.assert_mixed_int_string_entry(index.values):
+            with pytest.raises(
+                TypeError,
+                match="'<' not supported between instances of 'str' and 'int'",
+            ):
+                np.argsort(index)
+        else:
+            result = np.argsort(index)
+            expected = index.argsort()
+            tm.assert_numpy_array_equal(result, expected)
 
-        result = np.argsort(index, kind="mergesort")
-        expected = index.argsort(kind="mergesort")
-        tm.assert_numpy_array_equal(result, expected)
+            result = np.argsort(index, kind="mergesort")
+            expected = index.argsort(kind="mergesort")
+            tm.assert_numpy_array_equal(result, expected)
 
         # these are the only two types that perform
         # pandas compatibility input validation - the

pandas/tests/indexes/test_setops.py

@@ -59,9 +59,16 @@ def any_dtype_for_small_pos_integer_indexes(request):
 def test_union_same_types(index):
     # Union with a non-unique, non-monotonic index raises error
     # Only needed for bool index factory
-    idx1 = index.sort_values()
-    idx2 = index.sort_values()
-    assert idx1.union(idx2).dtype == idx1.dtype
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(index.values):
+        with pytest.raises(
+            TypeError, match="'<' not supported between instances of 'int' and 'str'"
+        ):
+            index.sort_values()
+    else:
+        idx1 = index.sort_values()
+        idx2 = index.sort_values()
+        assert idx1.union(idx2).dtype == idx1.dtype
 
 
 def test_union_different_types(index_flat, index_flat2, request):
@@ -123,19 +130,28 @@ def test_union_different_types(index_flat, index_flat2, request):
 
     # Union with a non-unique, non-monotonic index raises error
     # This applies to the boolean index
-    idx1 = idx1.sort_values()
-    idx2 = idx2.sort_values()
-
-    with tm.assert_produces_warning(warn, match=msg):
-        res1 = idx1.union(idx2)
-        res2 = idx2.union(idx1)
-
-    if any_uint64 and (idx1_signed or idx2_signed):
-        assert res1.dtype == np.dtype("O")
-        assert res2.dtype == np.dtype("O")
+    # This check is written for the mixed-int-string entry
+    if tm.assert_mixed_int_string_entry(
+        idx1.values
+    ) or tm.assert_mixed_int_string_entry(idx2.values):
+        with pytest.raises(
+            TypeError, match="'<' not supported between instances of 'int' and 'str'"
+        ):
+            idx1.sort_values()
+            idx2.sort_values()
     else:
-        assert res1.dtype == common_dtype
-        assert res2.dtype == common_dtype
+        idx1 = idx1.sort_values()
+        idx2 = idx2.sort_values()
+        with tm.assert_produces_warning(warn, match=msg):
+            res1 = idx1.union(idx2)
+            res2 = idx2.union(idx1)
+
+        if any_uint64 and (idx1_signed or idx2_signed):
+            assert res1.dtype == np.dtype("O")
+            assert res2.dtype == np.dtype("O")
+        else:
+            assert res1.dtype == common_dtype
+            assert res2.dtype == common_dtype
 
 
 @pytest.mark.parametrize(
@@ -254,7 +270,15 @@ def test_union_base(self, index):
         everything = index
 
         union = first.union(second)
-        tm.assert_index_equal(union.sort_values(), everything.sort_values())
+        # This check is written for the mixed-int-string entry
+        if tm.assert_mixed_int_string_entry(index.values):
+            with pytest.raises(
+                TypeError,
+                match="'<' not supported between instances of 'int' and 'str'",
+            ):
+                tm.assert_index_equal(union.sort_values(), everything.sort_values())
+        else:
+            tm.assert_index_equal(union.sort_values(), everything.sort_values())
 
         if isinstance(index.dtype, DatetimeTZDtype):
             # The second.values below will drop tz, so the rest of this test
@@ -319,7 +343,15 @@ def test_symmetric_difference(self, index):
         second = index[:-1]
         answer = index[[0, -1]]
         result = first.symmetric_difference(second)
-        tm.assert_index_equal(result.sort_values(), answer.sort_values())
+        # This check is written for the mixed-int-string entry
+        if tm.assert_mixed_int_string_entry(index.values):
+            with pytest.raises(
+                TypeError,
+                match="'<' not supported between instances of 'int' and 'str'",
+            ):
+                tm.assert_index_equal(result.sort_values(), answer.sort_values())
+        else:
+            tm.assert_index_equal(result.sort_values(), answer.sort_values())
 
         # GH#10149
         cases = [second.to_numpy(), second.to_series(), second.to_list()]
@@ -398,9 +430,17 @@ def test_union_unequal(self, index_flat, fname, sname, expected_name):
         # test copy.union(subset) - need sort for unicode and string
         first = index.copy().set_names(fname)
         second = index[1:].set_names(sname)
-        union = first.union(second).sort_values()
-        expected = index.set_names(expected_name).sort_values()
-        tm.assert_index_equal(union, expected)
+        # This check is written for the mixed-int-string entry
+        if tm.assert_mixed_int_string_entry(second.values):
+            with pytest.raises(
+                TypeError,
+                match="'<' not supported between instances of 'int' and 'str'",
+            ):
+                first.union(second).sort_values()
+        else:
+            union = first.union(second).sort_values()
+            expected = index.set_names(expected_name).sort_values()
+            tm.assert_index_equal(union, expected)
 
     @pytest.mark.parametrize(
         "fname, sname, expected_name",
@@ -467,9 +507,16 @@ def test_intersect_unequal(self, index_flat, fname, sname, expected_name):
         # test copy.intersection(subset) - need sort for unicode and string
         first = index.copy().set_names(fname)
         second = index[1:].set_names(sname)
-        intersect = first.intersection(second).sort_values()
-        expected = index[1:].set_names(expected_name).sort_values()
-        tm.assert_index_equal(intersect, expected)
+        if tm.assert_mixed_int_string_entry(index.values):
+            with pytest.raises(
+                TypeError,
+                match="'<' not supported between instances of 'int' and 'str'",
+            ):
+                first.intersection(second).sort_values()
+        else:
+            intersect = first.intersection(second).sort_values()
+            expected = index[1:].set_names(expected_name).sort_values()
+            tm.assert_index_equal(intersect, expected)
 
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
     def test_intersection_name_retention_with_nameless(self, index):

pandas/tests/test_algos.py

@@ -83,6 +83,9 @@ def test_factorize(self, index_or_series_obj, sort):
             expected_uniques = expected_uniques.astype(object)
 
         if sort:
+            # This check is written for the mixed-int-string entry
+            if tm.assert_mixed_int_string_entry(expected_uniques.values):
+                pytest.skip("'<' not supported between instances of 'str' and 'int'")
             expected_uniques = expected_uniques.sort_values()
 
         # construct an integer ndarray so that