warn for categorical

Author: TomAugspurger

pandas/core/arrays/categorical.py

@@ -1,5 +1,6 @@
 # pylint: disable=E1101,W0232
 
+import reprlib
 import textwrap
 from warnings import warn
 
@@ -1909,20 +1910,34 @@ def take_nd(self, indexer, allow_fill=None, fill_value=None):
     def where(self, cond, other):
         # n.b. this now preserves the type
         codes = self._codes
+        object_msg = (
+            "Implicitly converting categorical to object-dtype ndarray. "
+            "The values `{}' are not present in this categorical's "
+            "categories. A future version of pandas will raise a ValueError "
+            "when 'other' contains different categories.\n\n"
+            "To preserve the current behavior, add the new categories to "
+            "the categorical before calling 'where', or convert the "
+            "categorical to a different dtype."
+        )
 
         if is_scalar(other) and isna(other):
             other = -1
         elif is_scalar(other):
             item = self.categories.get_indexer([other]).item()
 
             if item == -1:
-                raise ValueError("The value '{}' is not present in "
-                                 "this Categorical's categories".format(other))
+                # note: when removing this, also remove CategoricalBlock.where
+                warn(object_msg.format(other), FutureWarning, stacklevel=2)
+                return np.where(cond, self, other)
+
             other = item
 
         elif is_categorical_dtype(other):
             if not is_dtype_equal(self, other):
-                raise TypeError("The type of 'other' does not match.")
+                extra = list(other.categories.difference(self.categories))
+                warn(object_msg.format(reprlib.repr(extra)), FutureWarning,
+                     stacklevel=2)
+                return np.where(cond, self, other)
             other = _get_codes_for_values(other, self.categories)
             # get the codes from other that match our categories
             pass

pandas/core/internals/blocks.py

@@ -2671,6 +2671,17 @@ def concat_same_type(self, to_concat, placement=None):
             values, placement=placement or slice(0, len(values), 1),
             ndim=self.ndim)
 
+    def where(self, other, cond, align=True, errors='raise',
+              try_cast=False, axis=0, transpose=False):
+        result = super(CategoricalBlock, self).where(
+            other, cond, align, errors, try_cast, axis, transpose
+        )
+        if result.values.dtype != self.values.dtype:
+            # For backwards compatability, we allow upcasting to object.
+            # This fallback will be removed in the future.
+            result = result.astype(object)
+        return result
+
 
 class DatetimeBlock(DatetimeLikeBlockMixin, Block):
     __slots__ = ()

pandas/tests/arrays/categorical/test_indexing.py

@@ -122,11 +122,6 @@ def test_get_indexer_non_unique(self, idx_values, key_values, key_class):
             tm.assert_numpy_array_equal(expected, result)
             tm.assert_numpy_array_equal(exp_miss, res_miss)
 
-    def test_where_raises(self):
-        arr = Categorical(['a', 'b', 'c'])
-        with pytest.raises(ValueError, match="The value 'd'"):
-            arr.where([True, False, True], 'd')
-
     def test_where_unobserved_categories(self):
         arr = Categorical(['a', 'b', 'c'], categories=['d', 'c', 'b', 'a'])
         result = arr.where([True, True, False], other='b')
@@ -140,13 +135,24 @@ def test_where_other_categorical(self):
         expected = Categorical(['a', 'c', 'c'], dtype=arr.dtype)
         tm.assert_categorical_equal(result, expected)
 
+    def test_where_warns(self):
+        arr = Categorical(['a', 'b', 'c'])
+        with tm.assert_produces_warning(FutureWarning):
+            result = arr.where([True, False, True], 'd')
+
+        expected = np.array(['a', 'd', 'c'], dtype='object')
+        tm.assert_numpy_array_equal(result, expected)
+
     def test_where_ordered_differs_rasies(self):
         arr = Categorical(['a', 'b', 'c'], categories=['d', 'c', 'b', 'a'],
                           ordered=True)
         other = Categorical(['b', 'c', 'a'], categories=['a', 'c', 'b', 'd'],
                             ordered=True)
-        with pytest.raises(TypeError, match="The type of"):
-            arr.where([True, False, True], other)
+        with tm.assert_produces_warning(FutureWarning):
+            result = arr.where([True, False, True], other)
+
+        expected = np.array(['a', 'c', 'c'], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
 
 
 @pytest.mark.parametrize("index", [True, False])