Split test multi

pandas/tests/indexes/multi/test_constructor.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+
+import re
+
+import numpy as np
+
+from pandas import (Index, MultiIndex)
+
+import pandas.util.testing as tm
+
+from pandas.tests.indexes.common import Base
+
+
+class TestConstructor(Base):
+    _holder = MultiIndex
+    _compat_props = ['shape', 'ndim', 'size', 'itemsize']
+
+    def setup_method(self, method):
+        major_axis = Index(['foo', 'bar', 'baz', 'qux'])
+        minor_axis = Index(['one', 'two'])
+
+        major_labels = np.array([0, 0, 1, 2, 3, 3])
+        minor_labels = np.array([0, 1, 0, 1, 0, 1])
+        self.index_names = ['first', 'second']
+        self.indices = dict(index=MultiIndex(levels=[major_axis, minor_axis],
+                                             labels=[major_labels, minor_labels
+                                                     ], names=self.index_names,
+                                             verify_integrity=False))
+        self.setup_indices()
+
+    def create_index(self):
+        return self.index
+
+    def test_copy_in_constructor(self):
+        levels = np.array(["a", "b", "c"])
+        labels = np.array([1, 1, 2, 0, 0, 1, 1])
+        val = labels[0]
+        mi = MultiIndex(levels=[levels, levels], labels=[labels, labels],
+                        copy=True)
+        assert mi.labels[0][0] == val
+        labels[0] = 15
+        assert mi.labels[0][0] == val
+        val = levels[0]
+        levels[0] = "PANDA"
+        assert mi.levels[0][0] == val
+
+    def test_constructor_single_level(self):
+        result = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux']],
+                            labels=[[0, 1, 2, 3]], names=['first'])
+        assert isinstance(result, MultiIndex)
+        expected = Index(['foo', 'bar', 'baz', 'qux'], name='first')
+        tm.assert_index_equal(result.levels[0], expected)
+        assert result.names == ['first']
+
+    def test_constructor_no_levels(self):
+        tm.assert_raises_regex(ValueError, "non-zero number "
+                                           "of levels/labels",
+                               MultiIndex, levels=[], labels=[])
+        both_re = re.compile('Must pass both levels and labels')
+        with tm.assert_raises_regex(TypeError, both_re):
+            MultiIndex(levels=[])
+        with tm.assert_raises_regex(TypeError, both_re):
+            MultiIndex(labels=[])
+
+    def test_constructor_mismatched_label_levels(self):
+        labels = [np.array([1]), np.array([2]), np.array([3])]
+        levels = ["a"]
+        tm.assert_raises_regex(ValueError, "Length of levels and labels "
+                                           "must be the same", MultiIndex,
+                               levels=levels, labels=labels)
+        length_error = re.compile('>= length of level')
+        label_error = re.compile(r'Unequal label lengths: \[4, 2\]')
+
+        # important to check that it's looking at the right thing.
+        with tm.assert_raises_regex(ValueError, length_error):
+            MultiIndex(levels=[['a'], ['b']],
+                       labels=[[0, 1, 2, 3], [0, 3, 4, 1]])
+
+        with tm.assert_raises_regex(ValueError, label_error):
+            MultiIndex(levels=[['a'], ['b']], labels=[[0, 0, 0, 0], [0, 0]])
+
+        # external API
+        with tm.assert_raises_regex(ValueError, length_error):
+            self.index.copy().set_levels([['a'], ['b']])
+
+        with tm.assert_raises_regex(ValueError, label_error):
+            self.index.copy().set_labels([[0, 0, 0, 0], [0, 0]])

pandas/tests/indexes/multi/test_contains.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+
+import pandas as pd
+
+from pandas import (Index, MultiIndex)
+
+from pandas.tests.indexes.common import Base
+
+
+class TestContains(Base):
+    _holder = MultiIndex
+    _compat_props = ['shape', 'ndim', 'size', 'itemsize']
+
+    def setup_method(self, method):
+        major_axis = Index(['foo', 'bar', 'baz', 'qux'])
+        minor_axis = Index(['one', 'two'])
+
+        major_labels = np.array([0, 0, 1, 2, 3, 3])
+        minor_labels = np.array([0, 1, 0, 1, 0, 1])
+        self.index_names = ['first', 'second']
+        self.indices = dict(index=MultiIndex(levels=[major_axis, minor_axis],
+                                             labels=[major_labels, minor_labels
+                                                     ], names=self.index_names,
+                                             verify_integrity=False))
+        self.setup_indices()
+
+    def create_index(self):
+        return self.index
+
+    def test_contains(self):
+        assert ('foo', 'two') in self.index
+        assert ('bar', 'two') not in self.index
+        assert None not in 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'],
+                                pd.date_range('2012-01-01', periods=5)],
+                        labels=[[0, 0, 0, 0, 0, 0], [-1, 0, 1, 2, 3, 4]],
+                        names=[None, 'B'])
+        assert ('C', pd.Timestamp('2012-01-01')) in mi
+        for val in mi.values:
+            assert val in mi

pandas/tests/indexes/multi/test_drop.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+import numpy as np
+
+import pandas as pd
+
+from pandas import (Index, MultiIndex)
+from pandas.compat import lrange
+from pandas.errors import PerformanceWarning
+
+import pandas.util.testing as tm
+
+from pandas.tests.indexes.common import Base
+
+
+class TestDrop(Base):
+    _holder = MultiIndex
+    _compat_props = ['shape', 'ndim', 'size', 'itemsize']
+
+    def setup_method(self, method):
+        major_axis = Index(['foo', 'bar', 'baz', 'qux'])
+        minor_axis = Index(['one', 'two'])
+
+        major_labels = np.array([0, 0, 1, 2, 3, 3])
+        minor_labels = np.array([0, 1, 0, 1, 0, 1])
+        self.index_names = ['first', 'second']
+        self.indices = dict(index=MultiIndex(levels=[major_axis, minor_axis],
+                                             labels=[major_labels, minor_labels
+                                                     ], names=self.index_names,
+                                             verify_integrity=False))
+        self.setup_indices()
+
+    def create_index(self):
+        return self.index
+
+    def test_drop(self):
+        dropped = self.index.drop([('foo', 'two'), ('qux', 'one')])
+
+        index = MultiIndex.from_tuples([('foo', 'two'), ('qux', 'one')])
+        dropped2 = self.index.drop(index)
+
+        expected = self.index[[0, 2, 3, 5]]
+        tm.assert_index_equal(dropped, expected)
+        tm.assert_index_equal(dropped2, expected)
+
+        dropped = self.index.drop(['bar'])
+        expected = self.index[[0, 1, 3, 4, 5]]
+        tm.assert_index_equal(dropped, expected)
+
+        dropped = self.index.drop('foo')
+        expected = self.index[[2, 3, 4, 5]]
+        tm.assert_index_equal(dropped, expected)
+
+        index = MultiIndex.from_tuples([('bar', 'two')])
+        pytest.raises(KeyError, self.index.drop, [('bar', 'two')])
+        pytest.raises(KeyError, self.index.drop, index)
+        pytest.raises(KeyError, self.index.drop, ['foo', 'two'])
+
+        # partially correct argument
+        mixed_index = MultiIndex.from_tuples([('qux', 'one'), ('bar', 'two')])
+        pytest.raises(KeyError, self.index.drop, mixed_index)
+
+        # error='ignore'
+        dropped = self.index.drop(index, errors='ignore')
+        expected = self.index[[0, 1, 2, 3, 4, 5]]
+        tm.assert_index_equal(dropped, expected)
+
+        dropped = self.index.drop(mixed_index, errors='ignore')
+        expected = self.index[[0, 1, 2, 3, 5]]
+        tm.assert_index_equal(dropped, expected)
+
+        dropped = self.index.drop(['foo', 'two'], errors='ignore')
+        expected = self.index[[2, 3, 4, 5]]
+        tm.assert_index_equal(dropped, expected)
+
+        # mixed partial / full drop
+        dropped = self.index.drop(['foo', ('qux', 'one')])
+        expected = self.index[[2, 3, 5]]
+        tm.assert_index_equal(dropped, expected)
+
+        # mixed partial / full drop / error='ignore'
+        mixed_index = ['foo', ('qux', 'one'), 'two']
+        pytest.raises(KeyError, self.index.drop, mixed_index)
+        dropped = self.index.drop(mixed_index, errors='ignore')
+        expected = self.index[[2, 3, 5]]
+        tm.assert_index_equal(dropped, expected)
+
+    def test_droplevel_with_names(self):
+        index = self.index[self.index.get_loc('foo')]
+        dropped = index.droplevel(0)
+        assert dropped.name == 'second'
+
+        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])],
+            names=['one', 'two', 'three'])
+        dropped = index.droplevel(0)
+        assert dropped.names == ('two', 'three')
+
+        dropped = index.droplevel('two')
+        expected = index.droplevel(1)
+        assert dropped.equals(expected)
+
+    def test_droplevel_multiple(self):
+        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])],
+            names=['one', 'two', 'three'])
+
+        dropped = index[:2].droplevel(['three', 'one'])
+        expected = index[:2].droplevel(2).droplevel(0)
+        assert dropped.equals(expected)
+
+    def test_drop_not_lexsorted(self):
+        # GH 12078
+
+        # define the lexsorted version of the multi-index
+        tuples = [('a', ''), ('b1', 'c1'), ('b2', 'c2')]
+        lexsorted_mi = MultiIndex.from_tuples(tuples, names=['b', 'c'])
+        assert lexsorted_mi.is_lexsorted()
+
+        # and the not-lexsorted version
+        df = pd.DataFrame(columns=['a', 'b', 'c', 'd'],
+                          data=[[1, 'b1', 'c1', 3], [1, 'b2', 'c2', 4]])
+        df = df.pivot_table(index='a', columns=['b', 'c'], values='d')
+        df = df.reset_index()
+        not_lexsorted_mi = df.columns
+        assert not not_lexsorted_mi.is_lexsorted()
+
+        # compare the results
+        tm.assert_index_equal(lexsorted_mi, not_lexsorted_mi)
+        with tm.assert_produces_warning(PerformanceWarning):
+            tm.assert_index_equal(lexsorted_mi.drop('a'),
+                                  not_lexsorted_mi.drop('a'))