simplify bool ops closures

Author: jbrockmendel

doc/source/whatsnew/v0.23.0.txt

@@ -866,3 +866,4 @@ Other
 ^^^^^
 
 - Improved error message when attempting to use a Python keyword as an identifier in a ``numexpr`` backed query (:issue:`18221`)
+- Boolean operations ``&, |, ^`` between a ``Series`` and an ``Index`` will no longer raise ``TypeError`` (:issue:`19792`)

pandas/core/ops.py

@@ -1058,69 +1058,76 @@ def _bool_method_SERIES(cls, op, special):
     Wrapper function for Series arithmetic operations, to avoid
     code duplication.
     """
+    name = _get_op_name(op, special)
 
     def na_op(x, y):
         try:
             result = op(x, y)
         except TypeError:
-            if isinstance(y, list):
-                y = construct_1d_object_array_from_listlike(y)
-
-            if isinstance(y, (np.ndarray, ABCSeries)):
-                if (is_bool_dtype(x.dtype) and is_bool_dtype(y.dtype)):
-                    result = op(x, y)  # when would this be hit?
-                else:
-                    x = _ensure_object(x)
-                    y = _ensure_object(y)
-                    result = lib.vec_binop(x, y, op)
+            assert not isinstance(y, (list, ABCSeries, pd.Index))
+            if isinstance(y, np.ndarray):
+                # This next assertion is here because there used to be
+                # a branch that specifically caught this case.
+                assert not (is_bool_dtype(x) and is_bool_dtype(y))
+                x = _ensure_object(x)
+                y = _ensure_object(y)
+                result = lib.vec_binop(x, y, op)
             else:
                 # let null fall thru
+                assert is_scalar(y)
                 if not isna(y):
                     y = bool(y)
                 try:
                     result = lib.scalar_binop(x, y, op)
                 except:
-                    msg = ("cannot compare a dtyped [{dtype}] array "
-                           "with a scalar of type [{type}]"
-                           ).format(dtype=x.dtype, type=type(y).__name__)
-                    raise TypeError(msg)
+                    raise TypeError("cannot compare a dtyped [{dtype}] array "
+                                    "with a scalar of type [{typ}]"
+                                    .format(dtype=x.dtype,
+                                            typ=type(y).__name__))
 
         return result
 
+    fill_int = lambda x: x.fillna(0)
+    fill_bool = lambda x: x.fillna(False).astype(bool)
+
     def wrapper(self, other):
         is_self_int_dtype = is_integer_dtype(self.dtype)
 
-        fill_int = lambda x: x.fillna(0)
-        fill_bool = lambda x: x.fillna(False).astype(bool)
-
         self, other = _align_method_SERIES(self, other, align_asobject=True)
 
+        res_name = _get_series_op_result_name(self, other)
+
         if isinstance(other, ABCDataFrame):
             # Defer to DataFrame implementation; fail early
             return NotImplemented
 
-        elif isinstance(other, ABCSeries):
-            name = com._maybe_match_name(self, other)
+        elif isinstance(other, (ABCSeries, pd.Index)):
             is_other_int_dtype = is_integer_dtype(other.dtype)
             other = fill_int(other) if is_other_int_dtype else fill_bool(other)
-
-            filler = (fill_int if is_self_int_dtype and is_other_int_dtype
-                      else fill_bool)
-
-            res_values = na_op(self.values, other.values)
-            unfilled = self._constructor(res_values,
-                                         index=self.index, name=name)
-            return filler(unfilled)
+            ovalues = other.values
 
         else:
             # scalars, list, tuple, np.array
-            filler = (fill_int if is_self_int_dtype and
-                      is_integer_dtype(np.asarray(other)) else fill_bool)
+            is_other_int_dtype = is_integer_dtype(np.asarray(other))
+            if isinstance(other, list):
+                # TODO: Can we do this before the is_integer_dtype check?
+                # could the is_integer_dtype check be checking the wrong
+                # thing?  e.g. other = [[0, 1], [2, 3], [4, 5]]?
+                other = construct_1d_object_array_from_listlike(other)
+            ovalues = other
 
-            res_values = na_op(self.values, other)
-            unfilled = self._constructor(res_values, index=self.index)
-            return filler(unfilled).__finalize__(self)
+        filler = (fill_int if is_self_int_dtype and is_other_int_dtype
+                  else fill_bool)
 
+        res_values = na_op(self.values, ovalues)
+        unfilled = self._constructor(res_values, index=self.index,
+                                     name=res_name)
+        result = filler(unfilled)
+        if not isinstance(other, ABCSeries):
+            result = result.__finalize__(self)
+        return result
+
+    wrapper.__name__ = name
     return wrapper
 
 

pandas/tests/series/test_operators.py

@@ -1853,6 +1853,17 @@ def test_operators_bitwise_int_series_with_float_series(self):
         result = s_0123 & Series([0.1, 4, -3.14, 2])
         assert_series_equal(result, s_ftft)
 
+    @pytest.mark.xfail(reason='GH#19792 Series op doesnt support categorical')
+    def test_operators_bitwise_with_int_categorical(self):
+        # GH#9016: support bitwise op for integer types
+        # GH#??? allow for operating with Index
+        s_0123 = Series(range(4), dtype='int64').astype('category')
+        s_3333 = Series([3] * 4).astype('category')
+
+        res = s_0123 & pd.Categorical(s_3333)
+        expected = Series(range(4), dtype='int64').astype('category')
+        assert_series_equal(res, expected)
+
     @pytest.mark.parametrize('box', [np.array, pd.Index, pd.Series])
     def test_operators_bitwise_with_int_arraylike(self, box):
         # GH#9016: support bitwise op for integer types