BUG: lexsort_depth now return sortorder if sortorder is not set to None

This fix issue pandas-dev#28518, where the label of the merge index where invalid
due to inconsistent lexsort_depth property of the intersection of the
indexes

Author: nrebena

pandas/core/indexes/multi.py

@@ -365,6 +365,15 @@ def _verify_integrity(self, codes=None, levels=None):
                     "Level values must be unique: {values} on "
                     "level {level}".format(values=[value for value in level], level=i)
                 )
+        if self.sortorder is not None:
+            if int(self.sortorder) > self._lexsort_depth():
+                raise ValueError(
+                    "Value for sortorder must be inferior or equal "
+                    "to actual lexsort_depth: "
+                    "sortorder {sortorder} with lexsort_depth {lexsort_depth}".format(
+                        sortorder=self.sortorder, lexsort_depth=self._lexsort_depth()
+                    )
+                )
 
         codes = [
             self._validate_codes(level, code) for level, code in zip(levels, codes)
@@ -1783,16 +1792,15 @@ def is_lexsorted(self):
     @cache_readonly
     def lexsort_depth(self):
         if self.sortorder is not None:
-            if self.sortorder == 0:
-                return self.nlevels
-            else:
-                return 0
+            return int(self.sortorder)
+
+        return self._lexsort_depth()
 
+    def _lexsort_depth(self):
         int64_codes = [ensure_int64(level_codes) for level_codes in self.codes]
         for k in range(self.nlevels, 0, -1):
             if libalgos.is_lexsorted(int64_codes[:k]):
                 return k
-
         return 0
 
     def _sort_levels_monotonic(self):

pandas/tests/reshape/merge/test_merge.py

@@ -2095,13 +2095,14 @@ def test_merge_equal_cat_dtypes2():
     # Categorical is unordered, so don't check ordering.
     tm.assert_frame_equal(result, expected, check_categorical=False)
 
+
 def test_merge_multiindex_columns():
     # Issue #28518
     # Verify that merging two dataframes give the expected labels
     # The original cause of this issue come from a bug lexsort_depth and is tested in
     # test_lexsort_depth
-    
-    index_tuples=[]
+
+    index_tuples = []
     letters = ["a", "b", "c", "d"]
     numbers = ["1", "2", "3"]
 
@@ -2111,14 +2112,14 @@ def test_merge_multiindex_columns():
 
     index = pd.MultiIndex.from_tuples(index_tuples, names=["outer", "inner"])
 
-    frame_x = pd.DataFrame(columns = index)
-    frame_x["id"]=""
+    frame_x = pd.DataFrame(columns=index)
+    frame_x["id"] = ""
 
-    frame_y = pd.DataFrame(columns = index)
-    frame_y["id"]=""
+    frame_y = pd.DataFrame(columns=index)
+    frame_y["id"] = ""
 
-    l_suf = '_x'
-    r_suf = '_y'
+    l_suf = "_x"
+    r_suf = "_y"
     expected_labels = sum(([l + l_suf, l + r_suf] for l in letters), [])
     merged_frame = frame_x.merge(frame_y, on="id", suffixes=((l_suf, r_suf))).columns
     for label in expected_labels:

pandas/tests/test_multilevel.py

@@ -2063,44 +2063,43 @@ def test_raise_invalid_sortorder(self):
         levels = [[0, 1], [0, 1, 2]]
 
         # Correct sortorder
-        index = MultiIndex(
-            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]],
-            sortorder=2,
+        MultiIndex(
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]], sortorder=2
         )
 
         with pytest.raises(ValueError, match=r".* sortorder 2 with lexsort_depth 1.*"):
-            index = MultiIndex(
-                levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]],
+            MultiIndex(
+                levels=levels,
+                codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]],
                 sortorder=2,
             )
 
         with pytest.raises(ValueError, match=r".* sortorder 1 with lexsort_depth 0.*"):
-            index = MultiIndex(
-                levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]],
+            MultiIndex(
+                levels=levels,
+                codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]],
                 sortorder=1,
-            ) 
+            )
 
     def test_lexsort_depth(self):
-        # Test that lexsort_depth return the  correct sortorder when it was given to the MultiIndex const.
+        # Test that lexsort_depth return the  correct sortorder
+        # when it was given to the MultiIndex const.
         # Issue #28518
 
         levels = [[0, 1], [0, 1, 2]]
 
         index = MultiIndex(
-            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]],
-            sortorder=2,
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]], sortorder=2
         )
         assert index.lexsort_depth == 2
 
         index = MultiIndex(
-            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]],
-            sortorder=1,
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]], sortorder=1
         )
         assert index.lexsort_depth == 1
 
         index = MultiIndex(
-            levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]],
-            sortorder=0,
+            levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]], sortorder=0
         )
         assert index.lexsort_depth == 0