MultiIndex.set_labels -> set_codes

Author: topper-123

pandas/core/indexes/multi.py

@@ -42,6 +42,7 @@
     _index_shared_docs)
 from pandas.core.indexes.frozen import FrozenList, _ensure_frozen
 import pandas.core.indexes.base as ibase
+from pandas.util._decorators import deprecate_kwarg
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 _index_doc_kwargs.update(
     dict(klass='MultiIndex',
@@ -264,8 +265,8 @@ def _verify_integrity(self, codes=None, levels=None):
         Raises
         ------
         ValueError
-            If length of levels and codes don't match, if any code would
-            exceed level bounds, or there are any duplicate levels.
+            If length of levels and codes don't match, if the codes for any
+            level would exceed level bounds, or there are any duplicate levels.
         """
         # NOTE: Currently does not check, among other things, that cached
         # nlevels matches nor that sortorder matches actually sortorder.
@@ -453,14 +454,23 @@ def _set_codes(self, codes, level=None, copy=False, validate=True,
 
     def set_labels(self, labels, level=None, inplace=False,
                    verify_integrity=True):
+        warnings.warn(("set_labels was deprecated in version 0.24.0."
+                       "Use set_codes instead."),
+                      FutureWarning, stacklevel=2)
+        return self.set_codes(labels, level=level, inplace=inplace,
+                              verify_integrity=verify_integrity)
+
+    @deprecate_kwarg(old_arg_name='labels', new_arg_name='codes')
+    def set_codes(self, codes, level=None, inplace=False,
+                  verify_integrity=True):
         """
-        Set new labels on MultiIndex. Defaults to returning
+        Set new codes on MultiIndex. Defaults to returning
         new index.
 
         Parameters
         ----------
-        labels : sequence or list of sequence
-            new labels to apply
+        codes : sequence or list of sequence
+            new codes to apply
         level : int, level name, or sequence of int/level names (default None)
             level(s) to set (None for all levels)
         inplace : bool
@@ -495,22 +505,22 @@ def set_labels(self, labels, level=None, inplace=False,
                    names=[u'foo', u'bar'])
         """
         if level is not None and not is_list_like(level):
-            if not is_list_like(labels):
-                raise TypeError("Labels must be list-like")
-            if is_list_like(labels[0]):
-                raise TypeError("Labels must be list-like")
+            if not is_list_like(codes):
+                raise TypeError("Codes must be list-like")
+            if is_list_like(codes[0]):
+                raise TypeError("Codes must be list-like")
             level = [level]
-            labels = [labels]
+            codes = [codes]
         elif level is None or is_list_like(level):
-            if not is_list_like(labels) or not is_list_like(labels[0]):
-                raise TypeError("Labels must be list of lists-like")
+            if not is_list_like(codes) or not is_list_like(codes[0]):
+                raise TypeError("Codes must be list of lists-like")
 
         if inplace:
             idx = self
         else:
             idx = self._shallow_copy()
         idx._reset_identity()
-        idx._set_codes(labels, level=level, verify_integrity=verify_integrity)
+        idx._set_codes(codes, level=level, verify_integrity=verify_integrity)
         if not inplace:
             return idx
 

pandas/tests/indexes/multi/test_compat.py

@@ -92,7 +92,7 @@ def test_inplace_mutation_resets_values():
 
     # Must be 1d array of tuples
     assert exp_values.shape == (6,)
-    new_values = mi2.set_labels(labels2).values
+    new_values = mi2.set_codes(labels2).values
 
     # Not inplace shouldn't change
     tm.assert_almost_equal(mi2._tuples, vals2)
@@ -101,7 +101,7 @@ def test_inplace_mutation_resets_values():
     tm.assert_almost_equal(exp_values, new_values)
 
     # ...and again setting inplace should kill _tuples, etc
-    mi2.set_labels(labels2, inplace=True)
+    mi2.set_codes(labels2, inplace=True)
     tm.assert_almost_equal(mi2.values, new_values)
 
 

pandas/tests/indexes/multi/test_constructor.py

@@ -82,7 +82,7 @@ def test_constructor_mismatched_label_levels(idx):
         idx.copy().set_levels([['a'], ['b']])
 
     with pytest.raises(ValueError, match=label_error):
-        idx.copy().set_labels([[0, 0, 0, 0], [0, 0]])
+        idx.copy().set_codes([[0, 0, 0, 0], [0, 0]])
 
 
 def test_copy_in_constructor():

pandas/tests/indexes/multi/test_get_set.py

@@ -171,7 +171,7 @@ def test_set_levels_labels_directly(idx):
 
 
 def test_set_levels(idx):
-    # side note - you probably wouldn't want to use levels and labels
+    # side note - you probably wouldn't want to use levels and codes
     # directly like this - but it is possible.
     levels = idx.levels
     new_levels = [[lev + 'a' for lev in level] for level in levels]
@@ -231,9 +231,15 @@ def test_set_levels(idx):
         assert_matching(idx.levels, original_index.levels,
                         check_dtype=True)
 
+<<<<<<< HEAD
         with pytest.raises(ValueError, match="^On"):
             idx.set_labels([0, 1, 2, 3, 4, 5], level=0,
                            inplace=inplace)
+=======
+        with tm.assert_raises_regex(ValueError, "^On"):
+            idx.set_codes([0, 1, 2, 3, 4, 5], level=0,
+                          inplace=inplace)
+>>>>>>> MultiIndex.set_labels -> set_codes
         assert_matching(idx.labels, original_index.labels,
                         check_dtype=True)
 
@@ -242,92 +248,118 @@ def test_set_levels(idx):
         assert_matching(idx.levels, original_index.levels,
                         check_dtype=True)
 
+<<<<<<< HEAD
         with pytest.raises(TypeError, match="^Labels"):
             idx.set_labels(1, level=0, inplace=inplace)
+=======
+        with tm.assert_raises_regex(TypeError, "^Codes"):
+            idx.set_codes(1, level=0, inplace=inplace)
+>>>>>>> MultiIndex.set_labels -> set_codes
         assert_matching(idx.labels, original_index.labels,
                         check_dtype=True)
 
 
-def test_set_labels(idx):
-    # side note - you probably wouldn't want to use levels and labels
+def test_set_codes(idx):
+    # side note - you probably wouldn't want to use levels and codes
     # directly like this - but it is possible.
-    labels = idx.labels
-    major_labels, minor_labels = labels
-    major_labels = [(x + 1) % 3 for x in major_labels]
-    minor_labels = [(x + 1) % 1 for x in minor_labels]
-    new_labels = [major_labels, minor_labels]
-
-    # label changing [w/o mutation]
-    ind2 = idx.set_labels(new_labels)
-    assert_matching(ind2.labels, new_labels)
-    assert_matching(idx.labels, labels)
-
-    # label changing [w/ mutation]
+    codes = idx.labels
+    major_codes, minor_codes = codes
+    major_codes = [(x + 1) % 3 for x in major_codes]
+    minor_codes = [(x + 1) % 1 for x in minor_codes]
+    new_codes = [major_codes, minor_codes]
+
+    # changing codes w/o mutation
+    ind2 = idx.set_codes(new_codes)
+    assert_matching(ind2.labels, new_codes)
+    assert_matching(idx.labels, codes)
+
+    # changing label w/ mutation
     ind2 = idx.copy()
-    inplace_return = ind2.set_labels(new_labels, inplace=True)
+    inplace_return = ind2.set_codes(new_codes, inplace=True)
     assert inplace_return is None
-    assert_matching(ind2.labels, new_labels)
+    assert_matching(ind2.labels, new_codes)
 
-    # label changing specific level [w/o mutation]
-    ind2 = idx.set_labels(new_labels[0], level=0)
-    assert_matching(ind2.labels, [new_labels[0], labels[1]])
-    assert_matching(idx.labels, labels)
+    # codes changing specific level w/o mutation
+    ind2 = idx.set_codes(new_codes[0], level=0)
+    assert_matching(ind2.labels, [new_codes[0], codes[1]])
+    assert_matching(idx.labels, codes)
 
-    ind2 = idx.set_labels(new_labels[1], level=1)
-    assert_matching(ind2.labels, [labels[0], new_labels[1]])
-    assert_matching(idx.labels, labels)
+    ind2 = idx.set_codes(new_codes[1], level=1)
+    assert_matching(ind2.labels, [codes[0], new_codes[1]])
+    assert_matching(idx.labels, codes)
 
-    # label changing multiple levels [w/o mutation]
-    ind2 = idx.set_labels(new_labels, level=[0, 1])
-    assert_matching(ind2.labels, new_labels)
-    assert_matching(idx.labels, labels)
+    # codes changing multiple levels w/o mutation
+    ind2 = idx.set_codes(new_codes, level=[0, 1])
+    assert_matching(ind2.labels, new_codes)
+    assert_matching(idx.labels, codes)
 
-    # label changing specific level [w/ mutation]
+    # label changing specific level w/ mutation
     ind2 = idx.copy()
-    inplace_return = ind2.set_labels(new_labels[0], level=0, inplace=True)
+    inplace_return = ind2.set_codes(new_codes[0], level=0, inplace=True)
     assert inplace_return is None
-    assert_matching(ind2.labels, [new_labels[0], labels[1]])
-    assert_matching(idx.labels, labels)
+    assert_matching(ind2.labels, [new_codes[0], codes[1]])
+    assert_matching(idx.labels, codes)
 
     ind2 = idx.copy()
-    inplace_return = ind2.set_labels(new_labels[1], level=1, inplace=True)
+    inplace_return = ind2.set_codes(new_codes[1], level=1, inplace=True)
     assert inplace_return is None
-    assert_matching(ind2.labels, [labels[0], new_labels[1]])
-    assert_matching(idx.labels, labels)
+    assert_matching(ind2.labels, [codes[0], new_codes[1]])
+    assert_matching(idx.labels, codes)
 
-    # label changing multiple levels [w/ mutation]
+    # codes changing multiple levels [w/ mutation]
     ind2 = idx.copy()
-    inplace_return = ind2.set_labels(new_labels, level=[0, 1],
-                                     inplace=True)
+    inplace_return = ind2.set_codes(new_codes, level=[0, 1],
+                                    inplace=True)
     assert inplace_return is None
-    assert_matching(ind2.labels, new_labels)
-    assert_matching(idx.labels, labels)
+    assert_matching(ind2.labels, new_codes)
+    assert_matching(idx.labels, codes)
 
     # label changing for levels of different magnitude of categories
+    ind = pd.MultiIndex.from_tuples([(0, i) for i in range(130)])
+    new_codes = range(129, -1, -1)
+    expected = pd.MultiIndex.from_tuples(
+        [(0, i) for i in new_codes])
+
+    # [w/o mutation]
+    result = ind.set_codes(codes=new_codes, level=1)
+    assert result.equals(expected)
+
+    # [w/ mutation]
+    result = ind.copy()
+    result.set_codes(codes=new_codes, level=1, inplace=True)
+    assert result.equals(expected)
+
+    with tm.assert_produces_warning(FutureWarning):
+        ind.set_codes(labels=new_codes, level=1)
+
+
+def test_set_labels_deprecated():
     ind = pd.MultiIndex.from_tuples([(0, i) for i in range(130)])
     new_labels = range(129, -1, -1)
     expected = pd.MultiIndex.from_tuples(
         [(0, i) for i in new_labels])
 
     # [w/o mutation]
-    result = ind.set_labels(labels=new_labels, level=1)
+    with tm.assert_produces_warning(FutureWarning):
+        result = ind.set_labels(labels=new_labels, level=1)
     assert result.equals(expected)
 
     # [w/ mutation]
     result = ind.copy()
-    result.set_labels(labels=new_labels, level=1, inplace=True)
+    with tm.assert_produces_warning(FutureWarning):
+        result.set_labels(labels=new_labels, level=1, inplace=True)
     assert result.equals(expected)
 
 
-def test_set_levels_labels_names_bad_input(idx):
-    levels, labels = idx.levels, idx.labels
+def test_set_levels_codes_names_bad_input(idx):
+    levels, codes = idx.levels, idx.labels
     names = idx.names
 
     with pytest.raises(ValueError, match='Length of levels'):
         idx.set_levels([levels[0]])
 
-    with pytest.raises(ValueError, match='Length of labels'):
-        idx.set_labels([labels[0]])
+    with tm.assert_raises_regex(ValueError, 'Length of codes'):
+        idx.set_codes([codes[0]])
 
     with pytest.raises(ValueError, match='Length of names'):
         idx.set_names([names[0]])
@@ -337,8 +369,13 @@ def test_set_levels_labels_names_bad_input(idx):
         idx.set_levels(levels[0])
 
     # shouldn't scalar data error, instead should demand list-like
+<<<<<<< HEAD
     with pytest.raises(TypeError, match='list of lists-like'):
         idx.set_labels(labels[0])
+=======
+    with tm.assert_raises_regex(TypeError, 'list of lists-like'):
+        idx.set_codes(codes[0])
+>>>>>>> MultiIndex.set_labels -> set_codes
 
     # shouldn't scalar data error, instead should demand list-like
     with pytest.raises(TypeError, match='list-like'):
@@ -352,11 +389,19 @@ def test_set_levels_labels_names_bad_input(idx):
         idx.set_levels(levels, level=0)
 
     # should have equal lengths
+<<<<<<< HEAD
     with pytest.raises(TypeError, match='list of lists-like'):
         idx.set_labels(labels[0], level=[0, 1])
 
     with pytest.raises(TypeError, match='list-like'):
         idx.set_labels(labels, level=0)
+=======
+    with tm.assert_raises_regex(TypeError, 'list of lists-like'):
+        idx.set_codes(codes[0], level=[0, 1])
+
+    with tm.assert_raises_regex(TypeError, 'list-like'):
+        idx.set_codes(codes, level=0)
+>>>>>>> MultiIndex.set_labels -> set_codes
 
     # should have equal lengths
     with pytest.raises(ValueError, match='Length of names'):

pandas/tests/test_multilevel.py

@@ -2596,7 +2596,7 @@ def test_frame_getitem_not_sorted2(self):
         df2_original = df2.copy()
 
         df2.index.set_levels(['b', 'd', 'a'], level='col1', inplace=True)
-        df2.index.set_labels([0, 1, 0, 2], level='col1', inplace=True)
+        df2.index.set_codes([0, 1, 0, 2], level='col1', inplace=True)
         assert not df2.index.is_lexsorted()
         assert not df2.index.is_monotonic