Changed a few test cases to align with kleene principle

Author: Tarun2605

pandas/core/ops/array_ops.py

@@ -390,6 +390,10 @@ def na_logical_op(x: np.ndarray, y, op):
 
 
 def is_nullable_bool(arr) -> bool:
+    if isinstance(arr, np.ndarray):
+        if arr.size == 0:
+            return True
+
     arr = np.asarray(arr, dtype=object).ravel()
     # isna works elementwise on object arrays
     na_mask = isna(arr)
@@ -550,10 +554,6 @@ def logical_op(left: ArrayLike, right: Any, op) -> ArrayLike:
     ndarray or ExtensionArray
     """
 
-    bothAreBoolArrays = is_nullable_bool(left) and is_nullable_bool(right)
-    if bothAreBoolArrays:
-        return alignOutputWithKleene(left, right, op)
-
     def fill_bool(x, left=None):
         # if `left` is specifically not-boolean, we do not cast to bool
         if x.dtype.kind in "cfO":
@@ -597,12 +597,15 @@ def fill_bool(x, left=None):
             is_other_int_dtype = lib.is_integer(rvalues)
 
         res_values = na_logical_op(lvalues, rvalues, op)
+        bothAreBoolArrays = is_nullable_bool(left) and is_nullable_bool(right)
+        # print("Yes both are bools", bothAreBoolArrays)
+        if bothAreBoolArrays:
+            return alignOutputWithKleene(left, right, op)
 
         # For int vs int `^`, `|`, `&` are bitwise operators and return
         #   integer dtypes.  Otherwise these are boolean ops
         if not (left.dtype.kind in "iu" and is_other_int_dtype):
             res_values = fill_bool(res_values)
-
     return res_values
 
 

pandas/tests/series/test_logical_ops.py

@@ -37,11 +37,12 @@ def test_logical_operators_bool_dtype_with_empty(self):
         index = list("bca")
 
         s_tft = Series([True, False, True], index=index)
-        s_fff = Series([False, False, False], index=index)
+        # s_fff = Series([False, False, False], index=index)
         s_empty = Series([], dtype=object)
 
         res = s_tft & s_empty
-        expected = s_fff.sort_index()
+        # changed the test case output to align with kleene principle
+        expected = Series([np.nan, False, np.nan], index=index).sort_index()
         tm.assert_series_equal(res, expected)
 
         res = s_tft | s_empty
@@ -180,8 +181,8 @@ def test_logical_ops_bool_dtype_with_ndarray(self):
             r"Logical ops \(and, or, xor\) between Pandas objects and "
             "dtype-less sequences"
         )
-
-        expected = Series([True, False, False, False, False])
+        # changed the test case output to align with kleene principle
+        expected = Series([True, False, np.nan, False, np.nan])
         with pytest.raises(TypeError, match=msg):
             left & right
         result = left & np.array(right)
@@ -200,8 +201,8 @@ def test_logical_ops_bool_dtype_with_ndarray(self):
         tm.assert_series_equal(result, expected)
         result = left | Series(right)
         tm.assert_series_equal(result, expected)
-
-        expected = Series([False, True, True, True, True])
+        # changed the test case output to align with kleene principle
+        expected = Series([False, True, np.nan, True, np.nan])
         with pytest.raises(TypeError, match=msg):
             left ^ right
         result = left ^ np.array(right)
@@ -368,12 +369,12 @@ def test_logical_ops_label_based(self, using_infer_string):
         # rhs is bigger
         a = Series([True, False, True], list("bca"))
         b = Series([False, True, False, True], list("abcd"))
-
-        expected = Series([False, True, False, False], list("abcd"))
+        # changed the test case output to align with kleene principle
+        expected = Series([False, True, False, np.nan], list("abcd"))
         result = a & b
         tm.assert_series_equal(result, expected)
-
-        expected = Series([True, True, False, False], list("abcd"))
+        # changed the test case output to align with kleene principle
+        expected = Series([True, True, False, True], list("abcd"))
         result = a | b
         tm.assert_series_equal(result, expected)
 
@@ -383,7 +384,8 @@ def test_logical_ops_label_based(self, using_infer_string):
         empty = Series([], dtype=object)
 
         result = a & empty
-        expected = Series([False, False, False], list("abc"))
+        # changed the test case output to align with kleene principle
+        expected = Series([np.nan, np.nan, False], list("abc"))
         tm.assert_series_equal(result, expected)
 
         result = a | empty
@@ -407,7 +409,9 @@ def test_logical_ops_label_based(self, using_infer_string):
             Series(np.nan, b.index),
             Series(np.nan, a.index),
         ]:
-            result = a[a | e]
+            result = a[(a | e).astype("boolean")]
+            # cast to boolean because object dtype with nan
+            # cannot be compared to True
             tm.assert_series_equal(result, a[a])
 
         for e in [Series(["z"])]:
@@ -459,16 +463,16 @@ def test_logical_ops_df_compat(self):
         # GH#1134
         s1 = Series([True, False, True], index=list("ABC"), name="x")
         s2 = Series([True, True, False], index=list("ABD"), name="x")
-
-        exp = Series([True, False, False, False], index=list("ABCD"), name="x")
+        # changed the test case output to align with kleene principle
+        exp = Series([True, False, np.nan, False], index=list("ABCD"), name="x")
         tm.assert_series_equal(s1 & s2, exp)
         tm.assert_series_equal(s2 & s1, exp)
 
         # True | np.nan => True
         exp_or1 = Series([True, True, True, False], index=list("ABCD"), name="x")
         tm.assert_series_equal(s1 | s2, exp_or1)
-        # np.nan | True => np.nan, filled with False
-        exp_or = Series([True, True, False, False], index=list("ABCD"), name="x")
+        # np.nan | True => True (should be)
+        exp_or = Series([True, True, True, False], index=list("ABCD"), name="x")
         tm.assert_series_equal(s2 | s1, exp_or)
 
         # DataFrame doesn't fill nan with False
@@ -482,13 +486,13 @@ def test_logical_ops_df_compat(self):
         # different length
         s3 = Series([True, False, True], index=list("ABC"), name="x")
         s4 = Series([True, True, True, True], index=list("ABCD"), name="x")
-
-        exp = Series([True, False, True, False], index=list("ABCD"), name="x")
+        # changed the test case output to align with kleene principle
+        exp = Series([True, False, True, np.nan], index=list("ABCD"), name="x")
         tm.assert_series_equal(s3 & s4, exp)
         tm.assert_series_equal(s4 & s3, exp)
 
         # np.nan | True => np.nan, filled with False
-        exp_or1 = Series([True, True, True, False], index=list("ABCD"), name="x")
+        exp_or1 = Series([True, True, True, True], index=list("ABCD"), name="x")
         tm.assert_series_equal(s3 | s4, exp_or1)
         # True | np.nan => True
         exp_or = Series([True, True, True, True], index=list("ABCD"), name="x")