changes for tests (lf, markxfail, ci)

Author: xaris96

pandas/conftest.py

@@ -706,7 +706,7 @@ def _create_mi_with_dt64tz_level():
     "string-python": Index(
         pd.array([f"pandas_{i}" for i in range(10)], dtype="string[python]")
     ),
-    "mixed-int-string": Index([0, "a", 1, "b", 2, "c"])
+    "mixed-int-string": Index([0, "a", 1, "b", 2, "c"]),
 }
 if has_pyarrow:
     idx = Index(pd.array([f"pandas_{i}" for i in range(10)], dtype="string[pyarrow]"))

pandas/tests/base/test_value_counts.py

@@ -63,10 +63,9 @@ def test_value_counts_null(null_obj, index_or_series_obj):
     elif isinstance(orig, MultiIndex):
         pytest.skip(f"MultiIndex can't hold '{null_obj}'")
 
-    if obj.dtype == 'object':
+    if obj.dtype == "object":
         obj = obj.astype(str)
 
-
     values = obj._values
     values[0:2] = null_obj
 

pandas/tests/indexes/test_common.py

@@ -436,18 +436,17 @@ def test_hasnans_isnans(self, index_flat):
         tm.assert_numpy_array_equal(idx._isnan, expected)
         assert idx.hasnans is True
 
-
 @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):
     non_na_values = [x for x in index_with_missing if pd.notna(x)]
     if len({type(x) for x in non_na_values}) > 1:
-        pytest.xfail("Sorting fails due to heterogeneous types in index (int vs str)")
+        pytest.mark.xfail(
+            reason="Sorting fails due to heterogeneous types in index (int vs str)")
 
     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")
 @pytest.mark.parametrize("na_position", ["first", "last"])
 def test_sort_values_with_missing(index_with_missing, na_position, request):
@@ -456,7 +455,8 @@ def test_sort_values_with_missing(index_with_missing, na_position, request):
 
     non_na_values = [x for x in index_with_missing if pd.notna(x)]
     if len({type(x) for x in non_na_values}) > 1:
-        pytest.xfail("Sorting fails due to heterogeneous types in index (int vs str)")
+        pytest.mark.xfail(
+            reason="Sorting fails due to heterogeneous types in index (int vs str)")
 
     if isinstance(index_with_missing, CategoricalIndex):
         request.applymarker(

pandas/tests/indexes/test_mixed_int_string.py

@@ -1,14 +1,16 @@
 import pytest
+
 import pandas as pd
 
+
 def test_mixed_int_string_index():
     idx = pd.Index([0, "a", 1, "b", 2, "c"])
-    
+
     # Check if the index is of type Index
     assert len(idx) == 6
     assert idx[1] == "a"
     assert idx[-1] == "c"
-    
+
     # Check if the index is sorted (it should not be)
     with pytest.raises(TypeError):
         idx.sort_values()

pandas/tests/indexes/test_numpy_compat.py

@@ -156,9 +156,13 @@ def test_numpy_ufuncs_reductions(index, func, request):
     if len(index) == 0:
         pytest.skip("Test doesn't make sense for empty index.")
 
-    if any(isinstance(x, str) for x in index) and any(isinstance(x, int) for x in index):
+    if any(isinstance(x, str) for x in index) and any(
+        isinstance(x, int) for x in index
+    ):
         request.applymarker(
-            pytest.mark.xfail(reason="Cannot compare mixed types (int and str) in ufunc reductions")
+            pytest.mark.xfail(
+                reason="Cannot compare mixed types (int and str) in ufunc reductions"
+            )
         )
 
     if isinstance(index, CategoricalIndex) and index.dtype.ordered is False:

pandas/tests/indexes/test_setops.py

@@ -5,14 +5,15 @@
 
 from datetime import datetime
 import operator
-import pandas as pd
+
 import numpy as np
 import pytest
 
 from pandas._libs import lib
 
 from pandas.core.dtypes.cast import find_common_type
 
+import pandas as pd
 from pandas import (
     CategoricalDtype,
     CategoricalIndex,
@@ -71,12 +72,15 @@ def test_union_same_types(index):
     idx2 = index.sort_values()
     assert idx1.union(idx2, sort=False).dtype == idx1.dtype
 
+
 def test_union_different_types(index_flat, index_flat2, request):
     idx1 = index_flat
     idx2 = index_flat2
 
-    # Ειδική μεταχείριση για mixed-int-string
-    if idx1.equals(pd.Index([0, "a", 1, "b", 2, "c"])) or idx2.equals(pd.Index([0, "a", 1, "b", 2, "c"])):
+    # mixed int string
+    if idx1.equals(pd.Index([0, "a", 1, "b", 2, "c"])) or idx2.equals(
+        pd.Index([0, "a", 1, "b", 2, "c"])
+    ):
         idx1 = idx1.astype(str)
         idx2 = idx2.astype(str)
 
@@ -129,6 +133,7 @@ def test_union_different_types(index_flat, index_flat2, request):
         assert res1.dtype == common_dtype
         assert res2.dtype == common_dtype
 
+
 @pytest.mark.parametrize(
     "idx1,idx2",
     [
@@ -233,7 +238,6 @@ def test_intersection_base(self, index):
 
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
     def test_union_base(self, index):
-
         if index.inferred_type in ["mixed", "mixed-integer"]:
             pytest.skip("Mixed-type Index not orderable; union fails")
 
@@ -295,7 +299,6 @@ def test_difference_base(self, sort, index):
 
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
     def test_symmetric_difference(self, index, using_infer_string, request):
-
         if (
             using_infer_string
             and index.dtype == "object"
@@ -392,7 +395,7 @@ def test_union_unequal(self, index_flat, fname, sname, expected_name):
         else:
             index = index_flat
 
-        if index.dtype == 'object':
+        if index.dtype == "object":
             index = index.astype(str)
 
         # test copy.union(subset) - need sort for unicode and string
@@ -464,7 +467,7 @@ def test_intersect_unequal(self, index_flat, fname, sname, expected_name):
         else:
             index = index_flat
 
-        if index.dtype == 'object':
+        if index.dtype == "object":
             index = index.astype(str)
         # test copy.intersection(subset) - need sort for unicode and string
         first = index.copy().set_names(fname)
@@ -919,12 +922,16 @@ def test_symmetric_difference_mi(self, sort):
         index2 = MultiIndex.from_tuples([("foo", 1), ("bar", 3)])
 
         def has_mixed_types(level):
-            return any(isinstance(x, str) for x in level) and any(isinstance(x, int) for x in level)
+            return any(isinstance(x, str) for x in level) and any(
+                isinstance(x, int) for x in level
+            )
 
         for idx in [index1, index2]:
             for lvl in range(idx.nlevels):
                 if has_mixed_types(idx.get_level_values(lvl)):
-                    pytest.skip(f"Mixed types in MultiIndex level {lvl} are not orderable")
+                    pytest.skip(
+                        f"Mixed types in MultiIndex level {lvl} are not orderable"
+                    )
 
         result = index1.symmetric_difference(index2, sort=sort)
         expected = MultiIndex.from_tuples([("bar", 2), ("baz", 3), ("bar", 3)])

pandas/tests/test_algos.py

@@ -63,12 +63,9 @@ def test_factorize_complex(self):
         expected_uniques = np.array([(1 + 0j), (2 + 0j), (2 + 1j)], dtype=complex)
         tm.assert_numpy_array_equal(uniques, expected_uniques)
 
-    @pytest.mark.parametrize("index_or_series_obj",
-                             [
-                             [1, 2, 3],
-                             ["a", "b", "c"],
-                             [0, "a", 1, "b", 2, "c"]
-                             ])
+    @pytest.mark.parametrize(
+        "index_or_series_obj", [[1, 2, 3], ["a", "b", "c"], [0, "a", 1, "b", 2, "c"]]
+    )
     @pytest.mark.parametrize("sort", [True, False])
     def test_factorize(self, index_or_series_obj, sort):
         obj = Index(index_or_series_obj)
@@ -77,8 +74,9 @@ def test_factorize(self, index_or_series_obj, sort):
             pytest.skip("Skipping test for empty Index")
 
         if obj.name == "mixed-int-string" or obj.name is None:
-            pytest.skip("Skipping test for mixed-int-string due to unsupported comparison between str and int")
-
+            pytest.skip(
+                "Skipping test for mixed-int-string due to unsupported comparison between str and int"
+            )
 
         result_codes, result_uniques = obj.factorize(sort=sort)
 
@@ -91,11 +89,9 @@ def test_factorize(self, index_or_series_obj, sort):
         if expected_uniques.dtype == bool and obj.dtype == object:
             expected_uniques = expected_uniques.astype(object)
 
-
         if sort:
             expected_uniques = expected_uniques.sort_values()
 
-
         # construct an integer ndarray so that
         # `expected_uniques.take(expected_codes)` is equal to `obj`
         expected_uniques_list = list(expected_uniques)