fixes

Author: jreback

pandas/index.pyx

@@ -556,7 +556,8 @@ cdef inline bint _is_utc(object tz):
 cdef class MultiIndexEngine(IndexEngine):
 
     def _call_monotonic(self, object mi):
-        return mi.is_lexsorted(), mi.is_monotonic, mi.is_unique
+        # defer these back to the mi iteself
+        return mi.is_monotonic_increasing, mi.is_monotonic_decreasing, mi.is_unique
 
     def get_backfill_indexer(self, other, limit=None):
         # we coerce to ndarray-of-tuples

pandas/indexes/multi.py

@@ -666,6 +666,18 @@ def _has_complex_internals(self):
 
     @cache_readonly
     def is_monotonic(self):
+        """
+        return if the index is monotonic increasing (only equal or
+        increasing) values.
+        """
+        return self.is_monotonic_increasing
+
+    @cache_readonly
+    def is_monotonic_increasing(self):
+        """
+        return if the index is monotonic increasing (only equal or
+        increasing) values.
+        """
 
         # reversed() because lexsort() wants the most significant key last.
         values = [self._get_level_values(i)
@@ -678,6 +690,14 @@ def is_monotonic(self):
             # we have mixed types and np.lexsort is not happy
             return Index(self.values).is_monotonic
 
+    @property
+    def is_monotonic_decreasing(self):
+        """
+        return if the index is monotonic decreasing (only equal or
+        decreasing) values.
+        """
+        return False
+
     @cache_readonly
     def is_unique(self):
         return not self.duplicated().any()
@@ -1922,15 +1942,8 @@ def partial_selection(key, indexer=None):
 
                             key = tuple(self[indexer].tolist()[0])
 
-                        try:
-                            return (self._engine.get_loc(
-                                _values_from_object(key)), None)
-                        except ValueError:
-                            # if we hae a very odd MultiIndex,
-                            # e.g. with embedded tuples, this might fail
-                            # TODO: should prob not allow construction of a MI
-                            # like this in the first place
-                            return Index(self.values).get_loc(key)
+                        return (self._engine.get_loc(
+                            _values_from_object(key)), None)
 
                     else:
                         return partial_selection(key)
@@ -2203,14 +2216,16 @@ def equals(self, other):
         if self.is_(other):
             return True
 
-        if not isinstance(other, Index):
-            if not isinstance(other, tuple):
+        if not isinstance(other, MultiIndex):
+            if isinstance(other, tuple):
+                other = [other]
+            if not is_list_like(other):
                 return False
-            other = Index([other])
 
-        if not isinstance(other, MultiIndex):
-            return array_equivalent(self._values,
-                                    _values_from_object(_ensure_index(other)))
+            try:
+                other = MultiIndex.from_tuples(other)
+            except:
+                return False
 
         if self.nlevels != other.nlevels:
             return False

pandas/src/hashtable_class_helper.pxi.in

@@ -881,7 +881,11 @@ cdef class MultiIndexHashTable(HashTable):
             khiter_t k
             uint64_t value
 
-        value = self.mi._hashed_indexing_key(key)
+        try:
+            value = self.mi._hashed_indexing_key(key)
+        except TypeError:
+            return False
+
         k = kh_get_uint64(self.table, value)
         if k != self.table.n_buckets:
             loc = self.table.vals[k]

pandas/tests/frame/test_mutate_columns.py

@@ -1,11 +1,11 @@
 # -*- coding: utf-8 -*-
 
 from __future__ import print_function
-
+import pytest
 from pandas.compat import range, lrange
 import numpy as np
 
-from pandas import DataFrame, Series, Index
+from pandas import DataFrame, Series, Index, MultiIndex
 
 from pandas.util.testing import (assert_series_equal,
                                  assert_frame_equal,
@@ -165,6 +165,29 @@ def test_delitem(self):
         del self.frame['A']
         self.assertNotIn('A', self.frame)
 
+    def test_delitem_multiindex(self):
+        midx = MultiIndex.from_product([['A', 'B'], [1, 2]])
+        df = DataFrame(np.random.randn(4, 4), columns=midx)
+        assert len(df.columns) == 4
+        assert ('A', ) in df.columns
+        assert 'A' in df.columns
+
+        result = df['A']
+        assert isinstance(result, DataFrame)
+        del df['A']
+
+        assert len(df.columns) == 2
+
+        # A still in the levels, BUT get a KeyError if trying
+        # to delete
+        assert ('A', ) not in df.columns
+        with pytest.raises(KeyError):
+            del df[('A',)]
+
+        assert 'A' in df.columns
+        with pytest.raises(KeyError):
+            del df['A']
+
     def test_pop(self):
         self.frame.columns.name = 'baz'
 

pandas/tests/indexes/test_multi.py

@@ -1046,6 +1046,11 @@ def test_contains(self):
         self.assertNotIn(('bar', 'two'), self.index)
         self.assertNotIn(None, self.index)
 
+    def test_contains_top_level(self):
+        midx = MultiIndex.from_product([['A', 'B'], [1, 2]])
+        assert 'A' in midx
+        assert 'A' not in midx._engine
+
     def test_contains_with_nat(self):
         # MI with a NaT
         mi = MultiIndex(levels=[['C'],
@@ -1442,20 +1447,36 @@ def test_to_hierarchical(self):
     def test_bounds(self):
         self.index._bounds
 
+    def test_equals(self):
+
+        for name, idx in compat.iteritems(self.indices):
+            self.assertTrue(idx.equals(idx))
+            self.assertTrue(idx.equals(idx.copy()))
+            self.assertTrue(idx.equals(idx.astype(object)))
+            self.assertTrue(idx.equals(list(idx)))
+            self.assertTrue(idx.equals(np.array(idx)))
+
+            same_values = Index(idx, dtype=object)
+            self.assertTrue(idx.equals(same_values))
+            self.assertTrue(same_values.equals(idx))
+
     def test_equals_multi(self):
-        self.assertTrue(self.index.equals(self.index))
-        self.assertTrue(self.index.equal_levels(self.index))
+        assert self.index.equals(self.index)
+        assert self.index.equals(self.index.values)
+        assert self.index.equals(Index(self.index.values))
 
-        self.assertFalse(self.index.equals(self.index[:-1]))
+        assert self.index.equal_levels(self.index)
+        assert not self.index.equals(self.index[:-1])
+        assert not self.index.equals(self.index[-1])
 
         # different number of levels
         index = MultiIndex(levels=[Index(lrange(4)), Index(lrange(4)), Index(
             lrange(4))], labels=[np.array([0, 0, 1, 2, 2, 2, 3, 3]), np.array(
                 [0, 1, 0, 0, 0, 1, 0, 1]), np.array([1, 0, 1, 1, 0, 0, 1, 0])])
 
         index2 = MultiIndex(levels=index.levels[:-1], labels=index.labels[:-1])
-        self.assertFalse(index.equals(index2))
-        self.assertFalse(index.equal_levels(index2))
+        assert not index.equals(index2)
+        assert not index.equal_levels(index2)
 
         # levels are different
         major_axis = Index(lrange(4))
@@ -1466,8 +1487,8 @@ def test_equals_multi(self):
 
         index = MultiIndex(levels=[major_axis, minor_axis],
                            labels=[major_labels, minor_labels])
-        self.assertFalse(self.index.equals(index))
-        self.assertFalse(self.index.equal_levels(index))
+        assert not self.index.equals(index)
+        assert not self.index.equal_levels(index)
 
         # some of the labels are different
         major_axis = Index(['foo', 'bar', 'baz', 'qux'])
@@ -1478,7 +1499,7 @@ def test_equals_multi(self):
 
         index = MultiIndex(levels=[major_axis, minor_axis],
                            labels=[major_labels, minor_labels])
-        self.assertFalse(self.index.equals(index))
+        assert not self.index.equals(index)
 
     def test_equals_missing_values(self):
         # make sure take is not using -1