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()
@@ -1921,17 +1941,8 @@ def partial_selection(key, indexer=None):
                                 return partial_selection(key, indexer)
 
                             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)
-
                     else:
                         return partial_selection(key)
                 else:

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,23 @@ 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
+
+        result = df['A']
+        assert isinstance(result, DataFrame)
+        del df['A']
+
+        assert len(df.columns) == 2
+
+        with pytest.raises(KeyError):
+            del df[('A',)]
+
+        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]])
+        self.assertTrue('A' in midx)
+        self.assertFalse('A' in midx._engine)
+
     def test_contains_with_nat(self):
         # MI with a NaT
         mi = MultiIndex(levels=[['C'],