merge with issue-TM

Author: xaris96

.gitignore

@@ -168,7 +168,7 @@ def test_query_duplicate_column_name(self, engine, parser):
             }
         ).rename(columns={"B": "A"})
 
-        res = df.query('C == 1', engine=engine, parser=parser)
+        res = df.query("C == 1", engine=engine, parser=parser)
 
         expect = DataFrame(
             [[1, 1, 1]],
@@ -1411,7 +1411,7 @@ def test_expr_with_column_name_with_backtick_and_hash(self):
     def test_expr_with_column_name_with_backtick(self):
         # GH 59285
         df = DataFrame({"a`b": (1, 2, 3), "ab": (4, 5, 6)})
-        result = df.query("`a``b` < 2")  # noqa
+        result = df.query("`a``b` < 2")
         # Note: Formatting checks may wrongly consider the above ``inline code``.
         expected = df[df["a`b"] < 2]
         tm.assert_frame_equal(result, expected)

pandas/tests/frame/test_query_eval.py

@@ -439,23 +439,43 @@ def test_hasnans_isnans(self, index_flat):
 
 @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
 @pytest.mark.parametrize("na_position", [None, "middle"])
+@pytest.mark.xfail(
+    reason="Sorting fails due to heterogeneous types in index (int vs str)"
+)
 def test_sort_values_invalid_na_position(index_with_missing, na_position):
+<<<<<<< HEAD
     if len({type(x) for x in index_with_missing if pd.notna(x)}) > 1:
         index_with_missing = index_with_missing.map(str)
+=======
+    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.mark.xfail(
+            reason="Sorting fails due to heterogeneous types in index (int vs str)"
+        )
+>>>>>>> origin/main
 
     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"])
+@pytest.mark.xfail(
+    reason="Sorting fails due to heterogeneous types in index (int vs str)"
+)
 def test_sort_values_with_missing(index_with_missing, na_position, request):
     # GH 35584. Test that sort_values works with missing values,
     # sort non-missing and place missing according to 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:
+<<<<<<< HEAD
         index_with_missing = index_with_missing.map(str)
+=======
+        pytest.mark.xfail(
+            reason="Sorting fails due to heterogeneous types in index (int vs str)"
+        )
+>>>>>>> origin/main
 
     if isinstance(index_with_missing, CategoricalIndex):
         request.applymarker(

pandas/tests/indexes/test_common.py

@@ -155,15 +155,27 @@ def test_numpy_ufuncs_reductions(index, func, request):
     # TODO: overlap with tests.series.test_ufunc.test_reductions
     if len(index) == 0:
         pytest.skip("Test doesn't make sense for empty index.")
+<<<<<<< HEAD
     has_str = any(isinstance(x, str) for x in index)
     has_int = any(isinstance(x, int) for x in index)
     if has_str and has_int:
         request.applymarker(
             pytest.mark.xfail(
                 reason="Cannot compare mixed types (int and str) in ufunc reductions"
+=======
+
+    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"
+                    " and should raise a TypeError"
+                )
+>>>>>>> origin/main
             )
         )
-
     if isinstance(index, CategoricalIndex) and index.dtype.ordered is False:
         with pytest.raises(TypeError, match="is not ordered for"):
             func.reduce(index)

pandas/tests/indexes/test_numpy_compat.py

@@ -13,6 +13,7 @@
 
 from pandas.core.dtypes.cast import find_common_type
 
+import pandas as pd
 from pandas import (
     CategoricalDtype,
     CategoricalIndex,
@@ -75,9 +76,17 @@ def test_union_same_types(index):
 def test_union_different_types(index_flat, index_flat2, request):
     idx1 = index_flat
     idx2 = index_flat2
+<<<<<<< HEAD
     # mixed int string
     target_index = Index([0, "a", 1, "b", 2, "c"])
     if idx1.equals(target_index) or idx2.equals(target_index):
+=======
+
+    # Special handling for mixed int-string types
+    if idx1.equals(pd.Index([0, "a", 1, "b", 2, "c"])) or idx2.equals(
+        pd.Index([0, "a", 1, "b", 2, "c"])
+    ):
+>>>>>>> origin/main
         idx1 = idx1.astype(str)
         idx2 = idx2.astype(str)
 
@@ -926,9 +935,16 @@ def has_mixed_types(level):
         for idx in [index1, index2]:
             for lvl in range(idx.nlevels):
                 if has_mixed_types(idx.get_level_values(lvl)):
+<<<<<<< HEAD
                     pytest.skip(
                         f"Mixed types in MultiIndex level {lvl} are not orderable"
                     )
+=======
+                    skip_message = (
+                        f"Mixed types in MultiIndex level {lvl} are not orderable"
+                    )
+                    pytest.skip(skip_message)
+>>>>>>> origin/main
 
         result = index1.symmetric_difference(index2, sort=sort)
         expected = MultiIndex.from_tuples([("bar", 2), ("baz", 3), ("bar", 3)])

pandas/tests/indexes/test_setops.py

@@ -74,10 +74,18 @@ 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:
+<<<<<<< HEAD
             pytest.skip(
                 "Skipping test for mixed-int-string due "
                 "to unsupported comparison between str and int"
             )
+=======
+            skip_message = (
+                "Skipping test for mixed-int-string due to unsupported comparison "
+                "between str and int"
+            )
+            pytest.skip(skip_message)
+>>>>>>> origin/main
 
         result_codes, result_uniques = obj.factorize(sort=sort)
 

pandas/tests/test_algos.py

@@ -60,7 +60,7 @@ def test_object(self):
         )
 
     def test_default(self):
-        assert com.random_state() is np.random
+        assert com.random_state(None) is np.random
 
     def test_array_like(self):
         state = np.random.default_rng(None).integers(0, 2**31, size=624, dtype="uint32")
@@ -81,7 +81,7 @@ def test_bit_generators(self):
             == np.random.RandomState(np.random.PCG64(seed)).uniform()
         )
 
-    @pytest.mark.parametrize("state", ["test", 5.5])
+    @pytest.mark.parametrize("state", ["invalid_string", 3.5, [], {}])
     def test_error(self, state):
         msg = (
             "random_state must be an integer, array-like, a BitGenerator, Generator, "

pandas/tests/test_common.py

@@ -0,0 +1,45 @@
+/*********************************************************************
+  Blosc - Blocked Shuffling and Compression Library
+
+  Author: Francesc Alted <[email protected]>
+
+  See LICENSE.txt for details about copyright and rights to use.
+**********************************************************************/
+#ifndef BLOSC_EXPORT_H
+#define BLOSC_EXPORT_H
+
+/* Macros for specifying exported symbols.
+   BLOSC_EXPORT is used to decorate symbols that should be
+   exported by the blosc shared library.
+   BLOSC_NO_EXPORT is used to decorate symbols that should NOT
+   be exported by the blosc shared library.
+*/
+#if defined(BLOSC_SHARED_LIBRARY)
+  #if defined(_MSC_VER)
+    #define BLOSC_EXPORT __declspec(dllexport)
+  #elif (defined(__GNUC__) && __GNUC__ >= 4) || defined(__clang__)
+    #if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
+      #define BLOSC_EXPORT __attribute__((dllexport))
+    #else
+      #define BLOSC_EXPORT __attribute__((visibility("default")))
+    #endif  /* defined(_WIN32) || defined(__CYGWIN__) */
+  #else
+    #error Cannot determine how to define BLOSC_EXPORT for this compiler.
+  #endif
+#else
+  #define BLOSC_EXPORT
+#endif  /* defined(BLOSC_SHARED_LIBRARY) */
+
+#if defined(__GNUC__) || defined(__clang__)
+  #define BLOSC_NO_EXPORT __attribute__((visibility("hidden")))
+#else
+  #define BLOSC_NO_EXPORT
+#endif  /* defined(__GNUC__) || defined(__clang__) */
+
+/* When testing, export everything to make it easier to implement tests. */
+#if defined(BLOSC_TESTING)
+  #undef BLOSC_NO_EXPORT
+  #define BLOSC_NO_EXPORT BLOSC_EXPORT
+#endif  /* defined(BLOSC_TESTING) */
+
+#endif  /* BLOSC_EXPORT_H */