Changes fixture _index to fixture idx

Author: elmq0022

pandas/tests/indexes/multi/conftest.py

@@ -6,25 +6,25 @@
 
 
 @pytest.fixture
-def _index():
+def idx():
     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])
     index_names = ['first', 'second']
-    idx = MultiIndex(
+    index = MultiIndex(
         levels=[major_axis, minor_axis],
         labels=[major_labels, minor_labels],
         names=index_names,
         verify_integrity=False
     )
-    return idx
+    return index
 
 
 @pytest.fixture
-def named_index(_index):
-    return {'index': _index}
+def named_index(idx):
+    return {'index': idx}
 
 
 @pytest.fixture

pandas/tests/indexes/multi/test_compat.py

@@ -18,9 +18,7 @@
 
 
 
-def test_numeric_compat(_index):
-
-    idx = _index
+def test_numeric_compat(idx):
     tm.assert_raises_regex(TypeError, "cannot perform __mul__",
                            lambda: idx * 1)
     tm.assert_raises_regex(TypeError, "cannot perform __rmul__",
@@ -37,19 +35,16 @@ def test_numeric_compat(_index):
                            lambda: 1 // idx)
 
 
-def test_logical_compat(_index):
-    idx = _index
+def test_logical_compat(idx):
     tm.assert_raises_regex(TypeError, 'cannot perform all',
                            lambda: idx.all())
     tm.assert_raises_regex(TypeError, 'cannot perform any',
                            lambda: idx.any())
 
 
-def test_boolean_context_compat(_index):
+def test_boolean_context_compat(idx):
 
     # boolean context compat
-    idx = _index
-
     def f():
         if idx:
             pass
@@ -118,8 +113,7 @@ def test_inplace_mutation_resets_values():
     tm.assert_almost_equal(mi2.values, new_values)
 
 
-def test_ndarray_compat_properties(_index, _compat_props):
-    idx = _index
+def test_ndarray_compat_properties(idx, _compat_props):
     assert idx.T.equals(idx)
     assert idx.transpose().equals(idx)
 

pandas/tests/indexes/multi/test_constructor.py

@@ -52,7 +52,7 @@ def test_constructor_nonhashable_names():
     tm.assert_raises_regex(TypeError, message, mi.set_names, names=renamed)
 
 
-def test_constructor_mismatched_label_levels(_index):
+def test_constructor_mismatched_label_levels(idx):
     labels = [np.array([1]), np.array([2]), np.array([3])]
     levels = ["a"]
     tm.assert_raises_regex(ValueError, "Length of levels and labels "
@@ -71,10 +71,10 @@ def test_constructor_mismatched_label_levels(_index):
 
     # external API
     with tm.assert_raises_regex(ValueError, length_error):
-        _index.copy().set_levels([['a'], ['b']])
+        idx.copy().set_levels([['a'], ['b']])
 
     with tm.assert_raises_regex(ValueError, label_error):
-        _index.copy().set_labels([[0, 0, 0, 0], [0, 0]])
+        idx.copy().set_labels([[0, 0, 0, 0], [0, 0]])
 
 
 def test_copy_in_constructor():
@@ -167,14 +167,14 @@ def test_reconstruct_remove_unused():
     assert result2.is_(result)
 
 
-def test_from_arrays(_index):
+def test_from_arrays(idx):
     arrays = []
-    for lev, lab in zip(_index.levels, _index.labels):
+    for lev, lab in zip(idx.levels, idx.labels):
         arrays.append(np.asarray(lev).take(lab))
 
     # list of arrays as input
-    result = MultiIndex.from_arrays(arrays, names=_index.names)
-    tm.assert_index_equal(result, _index)
+    result = MultiIndex.from_arrays(arrays, names=idx.names)
+    tm.assert_index_equal(result, idx)
 
     # infer correctly
     result = MultiIndex.from_arrays([[pd.NaT, Timestamp('20130101')],
@@ -183,15 +183,15 @@ def test_from_arrays(_index):
     assert result.levels[1].equals(Index(['a', 'b']))
 
 
-def test_from_arrays_iterator(_index):
+def test_from_arrays_iterator(idx):
     # GH 18434
     arrays = []
-    for lev, lab in zip(_index.levels, _index.labels):
+    for lev, lab in zip(idx.levels, idx.labels):
         arrays.append(np.asarray(lev).take(lab))
 
     # iterator as input
-    result = MultiIndex.from_arrays(iter(arrays), names=_index.names)
-    tm.assert_index_equal(result, _index)
+    result = MultiIndex.from_arrays(iter(arrays), names=idx.names)
+    tm.assert_index_equal(result, idx)
 
     # invalid iterator input
     with tm.assert_raises_regex(
@@ -376,9 +376,9 @@ def test_from_tuples_empty():
     tm.assert_index_equal(result, expected)
 
 
-def test_from_tuples_index_values(_index):
-    result = MultiIndex.from_tuples(_index)
-    assert (result.values == _index.values).all()
+def test_from_tuples_index_values(idx):
+    result = MultiIndex.from_tuples(idx)
+    assert (result.values == idx.values).all()
 
 
 def test_from_product_empty():
@@ -478,11 +478,11 @@ def test_from_product_iterator():
         MultiIndex.from_product(0)
 
 
-def test_create_index_existing_name(_index):
+def test_create_index_existing_name(idx):
 
     # GH11193, when an existing index is passed, and a new name is not
     # specified, the new index should inherit the previous object name
-    index = _index
+    index = idx
     index.names = ['foo', 'bar']
     result = pd.Index(index)
     tm.assert_index_equal(

pandas/tests/indexes/multi/test_contains.py

@@ -25,10 +25,10 @@ def test_contains_with_nat():
         assert val in mi
 
 
-def test_contains(_index):
-    assert ('foo', 'two') in _index
-    assert ('bar', 'two') not in _index
-    assert None not in _index
+def test_contains(idx):
+    assert ('foo', 'two') in idx
+    assert ('bar', 'two') not in idx
+    assert None not in idx
 
 
 @pytest.mark.skipif(not PYPY, reason="tuples cmp recursively on PyPy")

pandas/tests/indexes/multi/test_conversion.py

@@ -10,9 +10,9 @@
 from pandas.util.testing import assert_almost_equal
 
 
-def test_tolist(_index):
-    result = _index.tolist()
-    exp = list(_index.values)
+def test_tolist(idx):
+    result = idx.tolist()
+    exp = list(idx.values)
     assert result == exp
 
 

pandas/tests/indexes/multi/test_copy.py

@@ -32,21 +32,21 @@ def assert_multiindex_copied(copy, original):
     assert copy.sortorder == original.sortorder
 
 
-def test_copy(_index):
-    i_copy = _index.copy()
+def test_copy(idx):
+    i_copy = idx.copy()
 
-    assert_multiindex_copied(i_copy, _index)
+    assert_multiindex_copied(i_copy, idx)
 
 
-def test_shallow_copy(_index):
-    i_copy = _index._shallow_copy()
+def test_shallow_copy(idx):
+    i_copy = idx._shallow_copy()
 
-    assert_multiindex_copied(i_copy, _index)
+    assert_multiindex_copied(i_copy, idx)
 
 
-def test_view(_index):
-    i_view = _index.view()
-    assert_multiindex_copied(i_view, _index)
+def test_view(idx):
+    i_view = idx.view()
+    assert_multiindex_copied(i_view, idx)
 
 
 def test_copy_name(named_index):

pandas/tests/indexes/multi/test_drop.py

@@ -10,61 +10,61 @@
 from pandas.errors import PerformanceWarning
 
 
-def test_drop(_index):
-    dropped = _index.drop([('foo', 'two'), ('qux', 'one')])
+def test_drop(idx):
+    dropped = idx.drop([('foo', 'two'), ('qux', 'one')])
 
     index = MultiIndex.from_tuples([('foo', 'two'), ('qux', 'one')])
-    dropped2 = _index.drop(index)
+    dropped2 = idx.drop(index)
 
-    expected = _index[[0, 2, 3, 5]]
+    expected = idx[[0, 2, 3, 5]]
     tm.assert_index_equal(dropped, expected)
     tm.assert_index_equal(dropped2, expected)
 
-    dropped = _index.drop(['bar'])
-    expected = _index[[0, 1, 3, 4, 5]]
+    dropped = idx.drop(['bar'])
+    expected = idx[[0, 1, 3, 4, 5]]
     tm.assert_index_equal(dropped, expected)
 
-    dropped = _index.drop('foo')
-    expected = _index[[2, 3, 4, 5]]
+    dropped = idx.drop('foo')
+    expected = idx[[2, 3, 4, 5]]
     tm.assert_index_equal(dropped, expected)
 
     index = MultiIndex.from_tuples([('bar', 'two')])
-    pytest.raises(KeyError, _index.drop, [('bar', 'two')])
-    pytest.raises(KeyError, _index.drop, index)
-    pytest.raises(KeyError, _index.drop, ['foo', 'two'])
+    pytest.raises(KeyError, idx.drop, [('bar', 'two')])
+    pytest.raises(KeyError, idx.drop, index)
+    pytest.raises(KeyError, idx.drop, ['foo', 'two'])
 
     # partially correct argument
     mixed_index = MultiIndex.from_tuples([('qux', 'one'), ('bar', 'two')])
-    pytest.raises(KeyError, _index.drop, mixed_index)
+    pytest.raises(KeyError, idx.drop, mixed_index)
 
     # error='ignore'
-    dropped = _index.drop(index, errors='ignore')
-    expected = _index[[0, 1, 2, 3, 4, 5]]
+    dropped = idx.drop(index, errors='ignore')
+    expected = idx[[0, 1, 2, 3, 4, 5]]
     tm.assert_index_equal(dropped, expected)
 
-    dropped = _index.drop(mixed_index, errors='ignore')
-    expected = _index[[0, 1, 2, 3, 5]]
+    dropped = idx.drop(mixed_index, errors='ignore')
+    expected = idx[[0, 1, 2, 3, 5]]
     tm.assert_index_equal(dropped, expected)
 
-    dropped = _index.drop(['foo', 'two'], errors='ignore')
-    expected = _index[[2, 3, 4, 5]]
+    dropped = idx.drop(['foo', 'two'], errors='ignore')
+    expected = idx[[2, 3, 4, 5]]
     tm.assert_index_equal(dropped, expected)
 
     # mixed partial / full drop
-    dropped = _index.drop(['foo', ('qux', 'one')])
-    expected = _index[[2, 3, 5]]
+    dropped = idx.drop(['foo', ('qux', 'one')])
+    expected = idx[[2, 3, 5]]
     tm.assert_index_equal(dropped, expected)
 
     # mixed partial / full drop / error='ignore'
     mixed_index = ['foo', ('qux', 'one'), 'two']
-    pytest.raises(KeyError, _index.drop, mixed_index)
-    dropped = _index.drop(mixed_index, errors='ignore')
-    expected = _index[[2, 3, 5]]
+    pytest.raises(KeyError, idx.drop, mixed_index)
+    dropped = idx.drop(mixed_index, errors='ignore')
+    expected = idx[[2, 3, 5]]
     tm.assert_index_equal(dropped, expected)
 
 
-def test_droplevel_with_names(_index):
-    index = _index[_index.get_loc('foo')]
+def test_droplevel_with_names(idx):
+    index = idx[idx.get_loc('foo')]
     dropped = index.droplevel(0)
     assert dropped.name == 'second'
 

pandas/tests/indexes/multi/test_equivalence.py

@@ -40,9 +40,9 @@ def test_equals(named_index):
             assert not idx.equals(pd.Series(idx))
 
 
-def test_equals_op(_index):
+def test_equals_op(idx):
     # GH9947, GH10637
-    index_a = _index
+    index_a = idx
     if isinstance(index_a, PeriodIndex):
         return
 
@@ -103,14 +103,14 @@ def test_equals_op(_index):
         tm.assert_series_equal(series_a == item, Series(expected3))
 
 
-def test_equals_multi(_index):
-    assert _index.equals(_index)
-    assert not _index.equals(_index.values)
-    assert _index.equals(Index(_index.values))
+def test_equals_multi(idx):
+    assert idx.equals(idx)
+    assert not idx.equals(idx.values)
+    assert idx.equals(Index(idx.values))
 
-    assert _index.equal_levels(_index)
-    assert not _index.equals(_index[:-1])
-    assert not _index.equals(_index[-1])
+    assert idx.equal_levels(idx)
+    assert not idx.equals(idx[:-1])
+    assert not idx.equals(idx[-1])
 
     # different number of levels
     index = MultiIndex(levels=[Index(lrange(4)), Index(lrange(4)), Index(
@@ -130,8 +130,8 @@ def test_equals_multi(_index):
 
     index = MultiIndex(levels=[major_axis, minor_axis],
                        labels=[major_labels, minor_labels])
-    assert not _index.equals(index)
-    assert not _index.equal_levels(index)
+    assert not idx.equals(index)
+    assert not idx.equal_levels(index)
 
     # some of the labels are different
     major_axis = Index(['foo', 'bar', 'baz', 'qux'])
@@ -142,12 +142,12 @@ def test_equals_multi(_index):
 
     index = MultiIndex(levels=[major_axis, minor_axis],
                        labels=[major_labels, minor_labels])
-    assert not _index.equals(index)
+    assert not idx.equals(index)
 
 
-def test_identical(_index):
-    mi = _index.copy()
-    mi2 = _index.copy()
+def test_identical(idx):
+    mi = idx.copy()
+    mi2 = idx.copy()
     assert mi.identical(mi2)
 
     mi = mi.set_names(['new1', 'new2'])
@@ -164,9 +164,9 @@ def test_identical(_index):
     assert mi.equals(mi4)
 
 
-def test_equals_operator(_index):
+def test_equals_operator(idx):
     # GH9785
-    assert (_index == _index).all()
+    assert (idx == idx).all()
 
 
 def test_equals_missing_values():
@@ -209,13 +209,13 @@ def test_is_():
     assert not mi5.is_(mi)
 
 
-def test_is_all_dates(_index):
-    assert not _index.is_all_dates
+def test_is_all_dates(idx):
+    assert not idx.is_all_dates
 
 
-def test_is_numeric(_index):
+def test_is_numeric(idx):
     # MultiIndex is never numeric
-    assert not _index.is_numeric()
+    assert not idx.is_numeric()
 
 
 def test_nulls(named_index):