more concise testing

let Categoricals accept Index
let equals work symetrically between Index / CategoricalIndex
allow dtype='category' to coerce to CategoricalIndex on creation of Index

Author: jreback

pandas/core/categorical.py

@@ -242,7 +242,8 @@ def __init__(self, values, categories=None, ordered=False, name=None, fastpath=F
             values = values.__array__()
 
         elif isinstance(values, Index):
-            pass
+            values = np.array(values)
+            ordered = True
 
         else:
 

pandas/core/index.py

@@ -143,7 +143,7 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None, fastpath=False,
                 return Float64Index(data, copy=copy, dtype=dtype, name=name)
             elif issubclass(data.dtype.type, np.bool) or is_bool_dtype(data):
                 subarr = data.astype('object')
-            elif is_categorical_dtype(data):
+            elif is_categorical_dtype(data) or is_categorical_dtype(dtype):
                 return CategoricalIndex(data, copy=copy, name=name, **kwargs)
             else:
                 subarr = com._asarray_tuplesafe(data, dtype=object)
@@ -153,7 +153,7 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None, fastpath=False,
             if copy:
                 subarr = subarr.copy()
 
-        elif is_categorical_dtype(data):
+        elif is_categorical_dtype(data) or is_categorical_dtype(dtype):
             return CategoricalIndex(data, copy=copy, name=name, **kwargs)
         elif hasattr(data, '__array__'):
             return Index(np.asarray(data), dtype=dtype, copy=copy, name=name,
@@ -2611,13 +2611,21 @@ def equals(self, other):
         if self.is_(other):
             return True
 
-        if not isinstance(other, CategoricalIndex):
-            return False
-
         try:
-            return (self._data == other._data).all()
+            if is_categorical_dtype(other):
+                if not self.categories.equals(other.categories):
+                    return False
+            else:
+                from pandas import Categorical
+                other = Categorical(other, categories=self.categories, ordered=True)
+                if isnull(other).any():
+                    return False
+
+            return (self._data == other).all()
         except:
-            return False
+            pass
+
+        return False
 
     @property
     def inferred_type(self):

pandas/tests/test_categorical.py

@@ -221,11 +221,14 @@ def f():
             c_old2 = Categorical([0, 1, 2, 0, 1, 2], [1, 2, 3])
             cat = Categorical([1,2], categories=[1,2,3])
 
-    def test_constructor_with_categorical_index(self):
+    def test_constructor_with_index(self):
 
         ci = CategoricalIndex(list('aabbca'),categories=list('cab'))
         self.assertTrue(ci.values.equals(Categorical(ci)))
 
+        ci = CategoricalIndex(list('aabbca'),categories=list('cab'))
+        self.assertTrue(ci.values.equals(Categorical(ci.astype(object),categories=ci.categories)))
+
     def test_constructor_with_generator(self):
         # This was raising an Error in isnull(single_val).any() because isnull returned a scalar
         # for a generator

pandas/tests/test_index.py

@@ -1330,10 +1330,10 @@ def test_construction(self):
         idx = self.create_index()
 
         result = Index(idx)
-        self.assertTrue(result.equals(idx))
+        tm.assert_index_equal(result,idx,exact=True)
 
         result = Index(idx.values)
-        self.assertTrue(result.equals(idx))
+        tm.assert_index_equal(result,idx,exact=True)
 
         # empty
         result = CategoricalIndex(categories=categories)
@@ -1371,22 +1371,29 @@ def test_construction(self):
         self.assertIsInstance(result, Index)
         self.assertNotIsInstance(result, CategoricalIndex)
 
+        # specify dtype
+        result = Index(np.array(idx), dtype='category')
+        tm.assert_index_equal(result,idx,exact=True)
+
+        result = Index(np.array(idx).tolist(), dtype='category')
+        tm.assert_index_equal(result,idx,exact=True)
+
     def test_append(self):
 
         categories = list('cab')
         ci = CategoricalIndex(list('aabbca'), categories=categories)
 
         # append cats with the same categories
         result = ci[:3].append(ci[3:])
-        self.assertTrue(result.equals(ci))
+        tm.assert_index_equal(result,ci,exact=True)
 
         foos = [ci[:1], ci[1:3], ci[3:]]
         result = foos[0].append(foos[1:])
-        self.assertTrue(result.equals(ci))
+        tm.assert_index_equal(result,ci,exact=True)
 
         # empty
         result = ci.append([])
-        self.assertTrue(result.equals(ci))
+        tm.assert_index_equal(result,ci,exact=True)
 
         # appending with different categories or reoreded is not ok
         self.assertRaises(TypeError, lambda : ci.append(ci.values.set_categories(list('abcd'))))
@@ -1395,7 +1402,7 @@ def test_append(self):
         # with objects
         result = ci.append(['c','a'])
         expected = CategoricalIndex(list('aabbcaca'), categories=categories)
-        self.assertTrue(result.equals(expected))
+        tm.assert_index_equal(result,expected,exact=True)
 
         # invalid objects
         self.assertRaises(TypeError, lambda : ci.append(['a','d']))
@@ -1408,17 +1415,17 @@ def test_insert(self):
         #test 0th element
         result = ci.insert(0, 'a')
         expected = CategoricalIndex(list('aaabbca'),categories=categories)
-        self.assertTrue(result.equals(expected))
+        tm.assert_index_equal(result,expected,exact=True)
 
         #test Nth element that follows Python list behavior
         result = ci.insert(-1, 'a')
         expected = CategoricalIndex(list('aabbcaa'),categories=categories)
-        self.assertTrue(result.equals(expected))
+        tm.assert_index_equal(result,expected,exact=True)
 
         #test empty
         result = CategoricalIndex(categories=categories).insert(0, 'a')
         expected = CategoricalIndex(['a'],categories=categories)
-        self.assertTrue(result.equals(expected))
+        tm.assert_index_equal(result,expected,exact=True)
 
         # invalid
         self.assertRaises(ValueError, lambda : ci.insert(0,'d'))
@@ -1430,11 +1437,11 @@ def test_delete(self):
 
         result = ci.delete(0)
         expected = CategoricalIndex(list('abbca'),categories=categories)
-        self.assertTrue(result.equals(expected))
+        tm.assert_index_equal(result,expected,exact=True)
 
         result = ci.delete(-1)
         expected = CategoricalIndex(list('aabbc'),categories=categories)
-        self.assertTrue(result.equals(expected))
+        tm.assert_index_equal(result,expected,exact=True)
 
         with tm.assertRaises((IndexError, ValueError)):
             # either depeidnig on numpy version
@@ -1444,10 +1451,13 @@ def test_astype(self):
 
         idx = self.create_index()
         result = idx.astype('category')
-        self.assertTrue(result.equals(idx))
+        tm.assert_index_equal(result,idx,exact=True)
 
         result = idx.astype(object)
         self.assertTrue(result.equals(Index(np.array(idx))))
+
+        # this IS equal, but not the same class
+        self.assertTrue(result.equals(idx))
         self.assertIsInstance(result, Index)
         self.assertNotIsInstance(result, CategoricalIndex)
 
@@ -1487,6 +1497,9 @@ def test_equals(self):
 
         self.assertTrue(ci1.equals(ci1))
         self.assertFalse(ci1.equals(ci2))
+        self.assertTrue(ci1.equals(ci1.astype(object)))
+        self.assertTrue(ci1.astype(object).equals(ci1))
+
         self.assertTrue((ci1 == ci1).all())
         self.assertFalse((ci1 != ci1).all())
         self.assertFalse((ci1 > ci1).all())

pandas/util/testing.py

@@ -531,16 +531,14 @@ def assert_equal(a, b, msg=""):
     assert a == b, "%s: %r != %r" % (msg.format(a,b), a, b)
 
 
-def assert_index_equal(left, right):
+def assert_index_equal(left, right, exact=False):
     assert_isinstance(left, Index, '[index] ')
     assert_isinstance(right, Index, '[index] ')
-    if not left.equals(right):
+    if not left.equals(right) or (exact and type(left) != type(right)):
         raise AssertionError("[index] left [{0} {1}], right [{2} {3}]".format(left.dtype,
                                                                               left,
                                                                               right,
                                                                               right.dtype))
-
-
 def assert_attr_equal(attr, left, right):
     """checks attributes are equal. Both objects must have attribute."""
     left_attr = getattr(left, attr)