CLN: Implement multiindex handling for get_op_result_name (#38323)

* CLN: Implement multiindex handling for get_op_result_name * Change import order * Override method * Move import * Remove import * Fix merge issue * Move methods

Author: phofl

pandas/core/indexes/base.py

@@ -2580,7 +2580,6 @@ def __nonzero__(self):
  # --------------------------------------------------------------------
  # Set Operation Methods
 
- @final
  def _get_reconciled_name_object(self, other):
  """
  If the result of a set operation will be self,

pandas/core/indexes/multi.py

@@ -3593,6 +3593,34 @@ def _union(self, other, sort):
  def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
  return is_object_dtype(dtype)
 
+ def _get_reconciled_name_object(self, other):
+ """
+ If the result of a set operation will be self,
+ return self, unless the names change, in which
+ case make a shallow copy of self.
+ """
+ names = self._maybe_match_names(other)
+ if self.names != names:
+ return self.rename(names)
+ return self
+
+ def _maybe_match_names(self, other):
+ """
+ Try to find common names to attach to the result of an operation between
+ a and b. Return a consensus list of names if they match at least partly
+ or None if they have completely different names.
+ """
+ if len(self.names) != len(other.names):
+ return None
+ names = []
+ for a_name, b_name in zip(self.names, other.names):
+ if a_name == b_name:
+ names.append(a_name)
+ else:
+ # TODO: what if they both have np.nan for their names?
+ names.append(None)
+ return names
+
  def intersection(self, other, sort=False):
  """
  Form the intersection of two MultiIndex objects.
@@ -3616,12 +3644,12 @@ def intersection(self, other, sort=False):
  """
  self._validate_sort_keyword(sort)
  self._assert_can_do_setop(other)
- other, result_names = self._convert_can_do_setop(other)
+ other, _ = self._convert_can_do_setop(other)
 
  if self.equals(other):
  if self.has_duplicates:
- return self.unique().rename(result_names)
- return self.rename(result_names)
+ return self.unique()._get_reconciled_name_object(other)
+ return self._get_reconciled_name_object(other)
 
  return self._intersection(other, sort=sort)
 

pandas/core/ops/common.py

@@ -93,7 +93,7 @@ def _maybe_match_name(a, b):
  """
  Try to find a name to attach to the result of an operation between
  a and b. If only one of these has a `name` attribute, return that
- name. Otherwise return a consensus name if they match of None if
+ name. Otherwise return a consensus name if they match or None if
  they have different names.
 
  Parameters

pandas/tests/indexes/multi/test_setops.py

@@ -421,6 +421,29 @@ def test_intersect_with_duplicates(tuples, exp_tuples):
  tm.assert_index_equal(result, expected)
 
 
+@pytest.mark.parametrize(
+ "data, names, expected",
+ [
+ ((1,), None, None),
+ ((1,), ["a"], None),
+ ((1,), ["b"], None),
+ ((1, 2), ["c", "d"], [None, None]),
+ ((1, 2), ["b", "a"], [None, None]),
+ ((1, 2, 3), ["a", "b", "c"], None),
+ ((1, 2), ["a", "c"], ["a", None]),
+ ((1, 2), ["c", "b"], [None, "b"]),
+ ((1, 2), ["a", "b"], ["a", "b"]),
+ ((1, 2), [None, "b"], [None, "b"]),
+ ],
+)
+def test_maybe_match_names(data, names, expected):
+ # GH#38323
+ mi = pd.MultiIndex.from_tuples([], names=["a", "b"])
+ mi2 = pd.MultiIndex.from_tuples([data], names=names)
+ result = mi._maybe_match_names(mi2)
+ assert result == expected
+
+
 def test_intersection_equal_different_names():
  # GH#30302
  mi1 = MultiIndex.from_arrays([[1, 2], [3, 4]], names=["c", "b"])
@@ -429,3 +452,11 @@ def test_intersection_equal_different_names():
  result = mi1.intersection(mi2)
  expected = MultiIndex.from_arrays([[1, 2], [3, 4]], names=[None, "b"])
  tm.assert_index_equal(result, expected)
+
+
+def test_intersection_different_names():
+ # GH#38323
+ mi = MultiIndex.from_arrays([[1], [3]], names=["c", "b"])
+ mi2 = MultiIndex.from_arrays([[1], [3]])
+ result = mi.intersection(mi2)
+ tm.assert_index_equal(result, mi2)