moved tests according to feedback

test_nlevels -> test_integrity.py
unsort tests -> test_sorting.py
duplicates and unique test -> test_unqi_dups.py

Author: elmq0022

pandas/tests/indexes/multi/test_equivalence.py

@@ -232,3 +232,21 @@ def test_nulls(named_index):
                 result = isna(index)
                 tm.assert_numpy_array_equal(index.isna(), result)
                 tm.assert_numpy_array_equal(index.notna(), ~result)
+
+
+def test_multiindex_compare():
+        # GH 21149
+        # Ensure comparison operations for MultiIndex with nlevels == 1
+        # behave consistently with those for MultiIndex with nlevels > 1
+
+    midx = pd.MultiIndex.from_product([[0, 1]])
+
+    # Equality self-test: MultiIndex object vs self
+    expected = pd.Series([True, True])
+    result = pd.Series(midx == midx)
+    tm.assert_series_equal(result, expected)
+
+    # Greater than comparison: MultiIndex object vs self
+    expected = pd.Series([False, False])
+    result = pd.Series(midx > midx)
+    tm.assert_series_equal(result, expected)

pandas/tests/indexes/multi/test_integrity.py

@@ -10,7 +10,6 @@
                     RangeIndex, compat, date_range)
 from pandas.compat import lrange, range
 from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
-from pandas.errors import PerformanceWarning, UnsortedIndexError
 
 
 def test_labels_dtypes():
@@ -361,53 +360,6 @@ def test_rangeindex_fallback_coercion_bug():
     tm.assert_index_equal(result, expected)
 
 
-def test_unsortedindex():
-    # GH 11897
-    mi = pd.MultiIndex.from_tuples([('z', 'a'), ('x', 'a'), ('y', 'b'),
-                                    ('x', 'b'), ('y', 'a'), ('z', 'b')],
-                                   names=['one', 'two'])
-    df = pd.DataFrame([[i, 10 * i] for i in lrange(6)], index=mi,
-                      columns=['one', 'two'])
-
-    # GH 16734: not sorted, but no real slicing
-    result = df.loc(axis=0)['z', 'a']
-    expected = df.iloc[0]
-    tm.assert_series_equal(result, expected)
-
-    with pytest.raises(UnsortedIndexError):
-        df.loc(axis=0)['z', slice('a')]
-    df.sort_index(inplace=True)
-    assert len(df.loc(axis=0)['z', :]) == 2
-
-    with pytest.raises(KeyError):
-        df.loc(axis=0)['q', :]
-
-
-def test_unsortedindex_doc_examples():
-    # http://pandas.pydata.org/pandas-docs/stable/advanced.html#sorting-a-multiindex  # noqa
-    dfm = DataFrame({'jim': [0, 0, 1, 1],
-                     'joe': ['x', 'x', 'z', 'y'],
-                     'jolie': np.random.rand(4)})
-
-    dfm = dfm.set_index(['jim', 'joe'])
-    with tm.assert_produces_warning(PerformanceWarning):
-        dfm.loc[(1, 'z')]
-
-    with pytest.raises(UnsortedIndexError):
-        dfm.loc[(0, 'y'):(1, 'z')]
-
-    assert not dfm.index.is_lexsorted()
-    assert dfm.index.lexsort_depth == 1
-
-    # sort it
-    dfm = dfm.sort_index()
-    dfm.loc[(1, 'z')]
-    dfm.loc[(0, 'y'):(1, 'z')]
-
-    assert dfm.index.is_lexsorted()
-    assert dfm.index.lexsort_depth == 2
-
-
 def test_hash_error(indices):
     index = indices
     tm.assert_raises_regex(TypeError, "unhashable type: %r" %
@@ -446,3 +398,7 @@ def test_memory_usage(named_index):
 
             # we report 0 for no-length
             assert result == 0
+
+
+def test_nlevels(idx):
+    assert idx.nlevels == 2

pandas/tests/indexes/multi/test_operations.py

@@ -1,16 +1,13 @@
 # -*- coding: utf-8 -*-
 
-import warnings
-from itertools import product
-
 import numpy as np
 import pandas as pd
 import pandas.util.testing as tm
 import pytest
 from pandas import (DataFrame, DatetimeIndex, Float64Index, Index, Int64Index,
                     MultiIndex, PeriodIndex, TimedeltaIndex, UInt64Index,
                     compat, date_range, period_range)
-from pandas.compat import lrange, range, u
+from pandas.compat import lrange, range
 from pandas.core.dtypes.dtypes import CategoricalDtype
 from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
 from pandas.util.testing import assert_copy
@@ -385,10 +382,6 @@ def test_sub(idx):
         first.tolist() - idx[-3:]
 
 
-def test_nlevels(idx):
-    assert idx.nlevels == 2
-
-
 def test_argsort(idx):
     result = idx.argsort()
     expected = idx.values.argsort()
@@ -410,249 +403,6 @@ def test_remove_unused_nan(level0, level1):
         assert('unused' not in result.levels[level])
 
 
-@pytest.mark.parametrize('names', [None, ['first', 'second']])
-def test_unique(names):
-    mi = pd.MultiIndex.from_arrays([[1, 2, 1, 2], [1, 1, 1, 2]],
-                                   names=names)
-
-    res = mi.unique()
-    exp = pd.MultiIndex.from_arrays([[1, 2, 2], [1, 1, 2]], names=mi.names)
-    tm.assert_index_equal(res, exp)
-
-    mi = pd.MultiIndex.from_arrays([list('aaaa'), list('abab')],
-                                   names=names)
-    res = mi.unique()
-    exp = pd.MultiIndex.from_arrays([list('aa'), list('ab')],
-                                    names=mi.names)
-    tm.assert_index_equal(res, exp)
-
-    mi = pd.MultiIndex.from_arrays([list('aaaa'), list('aaaa')],
-                                   names=names)
-    res = mi.unique()
-    exp = pd.MultiIndex.from_arrays([['a'], ['a']], names=mi.names)
-    tm.assert_index_equal(res, exp)
-
-    # GH #20568 - empty MI
-    mi = pd.MultiIndex.from_arrays([[], []], names=names)
-    res = mi.unique()
-    tm.assert_index_equal(mi, res)
-
-
-def test_unique_datetimelike():
-    idx1 = pd.DatetimeIndex(['2015-01-01', '2015-01-01', '2015-01-01',
-                             '2015-01-01', 'NaT', 'NaT'])
-    idx2 = pd.DatetimeIndex(['2015-01-01', '2015-01-01', '2015-01-02',
-                             '2015-01-02', 'NaT', '2015-01-01'],
-                            tz='Asia/Tokyo')
-    result = pd.MultiIndex.from_arrays([idx1, idx2]).unique()
-
-    eidx1 = pd.DatetimeIndex(['2015-01-01', '2015-01-01', 'NaT', 'NaT'])
-    eidx2 = pd.DatetimeIndex(['2015-01-01', '2015-01-02',
-                              'NaT', '2015-01-01'],
-                             tz='Asia/Tokyo')
-    exp = pd.MultiIndex.from_arrays([eidx1, eidx2])
-    tm.assert_index_equal(result, exp)
-
-
-@pytest.mark.parametrize('level', [0, 'first', 1, 'second'])
-def test_unique_level(idx, level):
-    # GH #17896 - with level= argument
-    result = idx.unique(level=level)
-    expected = idx.get_level_values(level).unique()
-    tm.assert_index_equal(result, expected)
-
-    # With already unique level
-    mi = pd.MultiIndex.from_arrays([[1, 3, 2, 4], [1, 3, 2, 5]],
-                                   names=['first', 'second'])
-    result = mi.unique(level=level)
-    expected = mi.get_level_values(level)
-    tm.assert_index_equal(result, expected)
-
-    # With empty MI
-    mi = pd.MultiIndex.from_arrays([[], []], names=['first', 'second'])
-    result = mi.unique(level=level)
-    expected = mi.get_level_values(level)
-
-
-def test_multiindex_compare():
-        # GH 21149
-        # Ensure comparison operations for MultiIndex with nlevels == 1
-        # behave consistently with those for MultiIndex with nlevels > 1
-
-    midx = pd.MultiIndex.from_product([[0, 1]])
-
-    # Equality self-test: MultiIndex object vs self
-    expected = pd.Series([True, True])
-    result = pd.Series(midx == midx)
-    tm.assert_series_equal(result, expected)
-
-    # Greater than comparison: MultiIndex object vs self
-    expected = pd.Series([False, False])
-    result = pd.Series(midx > midx)
-    tm.assert_series_equal(result, expected)
-
-
-def test_duplicate_multiindex_labels():
-    # GH 17464
-    # Make sure that a MultiIndex with duplicate levels throws a ValueError
-    with pytest.raises(ValueError):
-        ind = pd.MultiIndex([['A'] * 10, range(10)], [[0] * 10, range(10)])
-
-    # And that using set_levels with duplicate levels fails
-    ind = MultiIndex.from_arrays([['A', 'A', 'B', 'B', 'B'],
-                                  [1, 2, 1, 2, 3]])
-    with pytest.raises(ValueError):
-        ind.set_levels([['A', 'B', 'A', 'A', 'B'], [2, 1, 3, -2, 5]],
-                       inplace=True)
-
-
-@pytest.mark.parametrize('names', [['a', 'b', 'a'], ['1', '1', '2'],
-                                   ['1', 'a', '1']])
-def test_duplicate_level_names(names):
-    # GH18872
-    pytest.raises(ValueError, pd.MultiIndex.from_product,
-                  [[0, 1]] * 3, names=names)
-
-    # With .rename()
-    mi = pd.MultiIndex.from_product([[0, 1]] * 3)
-    tm.assert_raises_regex(ValueError, "Duplicated level name:",
-                           mi.rename, names)
-
-    # With .rename(., level=)
-    mi.rename(names[0], level=1, inplace=True)
-    tm.assert_raises_regex(ValueError, "Duplicated level name:",
-                           mi.rename, names[:2], level=[0, 2])
-
-
-def test_duplicate_meta_data():
-    # GH 10115
-    index = MultiIndex(
-        levels=[[0, 1], [0, 1, 2]],
-        labels=[[0, 0, 0, 0, 1, 1, 1],
-                [0, 1, 2, 0, 0, 1, 2]])
-
-    for idx in [index,
-                index.set_names([None, None]),
-                index.set_names([None, 'Num']),
-                index.set_names(['Upper', 'Num']), ]:
-        assert idx.has_duplicates
-        assert idx.drop_duplicates().names == idx.names
-
-
-def test_duplicates(idx):
-    assert not idx.has_duplicates
-    assert idx.append(idx).has_duplicates
-
-    index = MultiIndex(levels=[[0, 1], [0, 1, 2]], labels=[
-        [0, 0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 0, 1, 2]])
-    assert index.has_duplicates
-
-    # GH 9075
-    t = [(u('x'), u('out'), u('z'), 5, u('y'), u('in'), u('z'), 169),
-         (u('x'), u('out'), u('z'), 7, u('y'), u('in'), u('z'), 119),
-         (u('x'), u('out'), u('z'), 9, u('y'), u('in'), u('z'), 135),
-         (u('x'), u('out'), u('z'), 13, u('y'), u('in'), u('z'), 145),
-         (u('x'), u('out'), u('z'), 14, u('y'), u('in'), u('z'), 158),
-         (u('x'), u('out'), u('z'), 16, u('y'), u('in'), u('z'), 122),
-         (u('x'), u('out'), u('z'), 17, u('y'), u('in'), u('z'), 160),
-         (u('x'), u('out'), u('z'), 18, u('y'), u('in'), u('z'), 180),
-         (u('x'), u('out'), u('z'), 20, u('y'), u('in'), u('z'), 143),
-         (u('x'), u('out'), u('z'), 21, u('y'), u('in'), u('z'), 128),
-         (u('x'), u('out'), u('z'), 22, u('y'), u('in'), u('z'), 129),
-         (u('x'), u('out'), u('z'), 25, u('y'), u('in'), u('z'), 111),
-         (u('x'), u('out'), u('z'), 28, u('y'), u('in'), u('z'), 114),
-         (u('x'), u('out'), u('z'), 29, u('y'), u('in'), u('z'), 121),
-         (u('x'), u('out'), u('z'), 31, u('y'), u('in'), u('z'), 126),
-         (u('x'), u('out'), u('z'), 32, u('y'), u('in'), u('z'), 155),
-         (u('x'), u('out'), u('z'), 33, u('y'), u('in'), u('z'), 123),
-         (u('x'), u('out'), u('z'), 12, u('y'), u('in'), u('z'), 144)]
-
-    index = pd.MultiIndex.from_tuples(t)
-    assert not index.has_duplicates
-
-    # handle int64 overflow if possible
-    def check(nlevels, with_nulls):
-        labels = np.tile(np.arange(500), 2)
-        level = np.arange(500)
-
-        if with_nulls:  # inject some null values
-            labels[500] = -1  # common nan value
-            labels = [labels.copy() for i in range(nlevels)]
-            for i in range(nlevels):
-                labels[i][500 + i - nlevels // 2] = -1
-
-            labels += [np.array([-1, 1]).repeat(500)]
-        else:
-            labels = [labels] * nlevels + [np.arange(2).repeat(500)]
-
-        levels = [level] * nlevels + [[0, 1]]
-
-        # no dups
-        index = MultiIndex(levels=levels, labels=labels)
-        assert not index.has_duplicates
-
-        # with a dup
-        if with_nulls:
-            def f(a):
-                return np.insert(a, 1000, a[0])
-            labels = list(map(f, labels))
-            index = MultiIndex(levels=levels, labels=labels)
-        else:
-            values = index.values.tolist()
-            index = MultiIndex.from_tuples(values + [values[0]])
-
-        assert index.has_duplicates
-
-    # no overflow
-    check(4, False)
-    check(4, True)
-
-    # overflow possible
-    check(8, False)
-    check(8, True)
-
-    # GH 9125
-    n, k = 200, 5000
-    levels = [np.arange(n), tm.makeStringIndex(n), 1000 + np.arange(n)]
-    labels = [np.random.choice(n, k * n) for lev in levels]
-    mi = MultiIndex(levels=levels, labels=labels)
-
-    for keep in ['first', 'last', False]:
-        left = mi.duplicated(keep=keep)
-        right = pd._libs.hashtable.duplicated_object(mi.values, keep=keep)
-        tm.assert_numpy_array_equal(left, right)
-
-    # GH5873
-    for a in [101, 102]:
-        mi = MultiIndex.from_arrays([[101, a], [3.5, np.nan]])
-        assert not mi.has_duplicates
-
-        with warnings.catch_warnings(record=True):
-            # Deprecated - see GH20239
-            assert mi.get_duplicates().equals(MultiIndex.from_arrays(
-                [[], []]))
-
-        tm.assert_numpy_array_equal(mi.duplicated(), np.zeros(
-            2, dtype='bool'))
-
-    for n in range(1, 6):  # 1st level shape
-        for m in range(1, 5):  # 2nd level shape
-            # all possible unique combinations, including nan
-            lab = product(range(-1, n), range(-1, m))
-            mi = MultiIndex(levels=[list('abcde')[:n], list('WXYZ')[:m]],
-                            labels=np.random.permutation(list(lab)).T)
-            assert len(mi) == (n + 1) * (m + 1)
-            assert not mi.has_duplicates
-
-            with warnings.catch_warnings(record=True):
-                # Deprecated - see GH20239
-                assert mi.get_duplicates().equals(MultiIndex.from_arrays(
-                    [[], []]))
-
-            tm.assert_numpy_array_equal(mi.duplicated(), np.zeros(
-                len(mi), dtype='bool'))
-
-
 def test_map(idx):
     # callable
     index = idx