Reconcile union behavior with eval

Author: Dr-Irv

doc/source/whatsnew/v0.23.0.txt

@@ -796,7 +796,7 @@ Indexing
 - Bug in :func:`IntervalIndex.symmetric_difference` where the symmetric difference with a non-``IntervalIndex`` did not raise (:issue:`18475`)
 - Bug in :class:`IntervalIndex` where set operations that returned an empty ``IntervalIndex`` had the wrong dtype (:issue:`19101`)
 - Bug in :meth:`DataFrame.drop_duplicates` where no ``KeyError`` is raised when passing in columns that don't exist on the ``DataFrame`` (issue:`19726`)
-- Bug in :func:`Index.union` where resulting names were not computed correrctly (:issue:`9943`, :issue:`9862`)
+- Bug in :func:`Index.union` where resulting names were not computed correctly (:issue:`9943`, :issue:`9862`)
 
 
 MultiIndex

pandas/core/indexes/base.py

@@ -1121,7 +1121,7 @@ def _convert_can_do_setop(self, other):
             other = Index(other, name=self.name)
             result_name = self.name
         else:
-            result_name = self._get_intersection_name(other)
+            result_name = self._get_setop_name(other)
         return other, result_name
 
     def _convert_for_op(self, value):
@@ -2190,33 +2190,22 @@ def __or__(self, other):
     def __xor__(self, other):
         return self.symmetric_difference(other)
 
-    def _get_union_name(self, other):
+    def _get_setop_name(self, other):
         # GH 9943 9862
         """
-        Given 2 indexes, give the union name meaning
-        we take the not None one, or None if the names differ.
+        Given 2 indexes, give the name appropriate for set
+        operations meaning we take the name if both names
+        are the same, or None if the names differ.
         """
-        if self.name != other.name:
-            if self.name is None or other.name is None:
-                name = self.name or other.name
-            else:
-                name = None
-        else:
-            name = self.name
-        return name
-
-    def _get_intersection_name(self, other):
-        # GH 9943 9862
         return self.name if self.name == other.name else None
 
-    def _get_consensus_name_object(self, other, name_converter):
+    def _get_setop_name_object(self, other):
         """
-        Given 2 indexes, give a consensus name meaning
-        we use the name converter (either _get_union_name or
-        get_intersection_name) to determine the name.
-        Return a new object if we are resetting the name
+        Given 2 indexes, give a setop name and object, meaning
+        we use _get_setop_name() to return the name, and then
+        return a new object if we are resetting the name
         """
-        name = name_converter(other)
+        name = self._get_setop_name(other)
         if self.name != name:
             return self._shallow_copy(name=name)
         return self
@@ -2246,12 +2235,10 @@ def union(self, other):
         other = _ensure_index(other)
 
         if len(other) == 0 or self.equals(other):
-            return self._get_consensus_name_object(other,
-                                                   self._get_union_name)
+            return self._get_setop_name_object(other)
 
         if len(self) == 0:
-            return other._get_consensus_name_object(self,
-                                                    other._get_union_name)
+            return other._get_setop_name_object(self)
 
         # TODO: is_dtype_union_equal is a hack around
         # 1. buggy set ops with duplicates (GH #13432)
@@ -2314,15 +2301,10 @@ def union(self, other):
                                   stacklevel=3)
 
         # for subclasses
-        return self._wrap_setop_result(other, result, self._get_union_name)
+        return self._wrap_setop_result(other, result)
 
-    def _wrap_setop_result(self, other, result, name_func):
-        # GH 9943 9862
-        """
-        name_func is either self._get_union_name or
-        self._get_intersection_name
-        """
-        return self.__class__(result, name=name_func(other))
+    def _wrap_setop_result(self, other, result):
+        return self.__class__(result, name=self._get_setop_name(other))
 
     def intersection(self, other):
         """
@@ -2352,8 +2334,7 @@ def intersection(self, other):
         other = _ensure_index(other)
 
         if self.equals(other):
-            return self._get_consensus_name_object(other,
-                                                   self._get_intersection_name)
+            return self._get_setop_name_object(other)
 
         if not is_dtype_equal(self.dtype, other.dtype):
             this = self.astype('O')
@@ -2373,8 +2354,7 @@ def intersection(self, other):
         if self.is_monotonic and other.is_monotonic:
             try:
                 result = self._inner_indexer(lvals, rvals)[0]
-                return self._wrap_setop_result(other, result,
-                                               self._get_intersection_name)
+                return self._wrap_setop_result(other, result)
             except TypeError:
                 pass
 
@@ -3503,7 +3483,7 @@ def _join_monotonic(self, other, how='left', return_indexers=False):
             return join_index
 
     def _wrap_joined_index(self, joined, other):
-        name = self._get_intersection_name(other)
+        name = self._get_setop_name(other)
         return Index(joined, name=name)
 
     def _get_string_slice(self, key, use_lhs=True, use_rhs=True):

pandas/core/indexes/datetimes.py

@@ -1245,7 +1245,7 @@ def _maybe_utc_convert(self, other):
         return this, other
 
     def _wrap_joined_index(self, joined, other):
-        name = self._get_intersection_name(other)
+        name = self._get_setop_name(other)
         if (isinstance(other, DatetimeIndex) and
                 self.offset == other.offset and
                 self._can_fast_union(other)):
@@ -1341,8 +1341,8 @@ def __iter__(self):
                                                  box="timestamp")
             return iter(converted)
 
-    def _wrap_setop_result(self, other, result, name_func):
-        name = name_func(other)
+    def _wrap_setop_result(self, other, result):
+        name = self._get_setop_name(other)
         if not timezones.tz_compare(self.tz, other.tz):
             raise ValueError('Passed item and index have different timezone')
         return self._simple_new(result, name=name, freq=None, tz=self.tz)

pandas/core/indexes/interval.py

@@ -1351,10 +1351,7 @@ def func(self, other):
                 raise TypeError(msg.format(op=op_name))
 
             result = getattr(self._multiindex, op_name)(other._multiindex)
-            if op_name == 'union':
-                result_name = self._get_union_name(other)
-            else:
-                result_name = self._get_intersection_name(other)
+            result_name = self._get_setop_name(other)
 
             # GH 19101: ensure empty results have correct dtype
             if result.empty:

pandas/core/indexes/numeric.py

@@ -187,7 +187,7 @@ def _convert_scalar_indexer(self, key, kind=None):
                 ._convert_scalar_indexer(key, kind=kind))
 
     def _wrap_joined_index(self, joined, other):
-        name = self._get_intersection_name(other)
+        name = self._get_setop_name(other)
         return Int64Index(joined, name=name)
 
     @classmethod
@@ -264,7 +264,7 @@ def _convert_index_indexer(self, keyarr):
         return keyarr
 
     def _wrap_joined_index(self, joined, other):
-        name = self._get_intersection_name(other)
+        name = self._get_setop_name(other)
         return UInt64Index(joined, name=name)
 
     @classmethod

pandas/core/indexes/period.py

@@ -998,8 +998,8 @@ def _assert_can_do_setop(self, other):
             msg = _DIFFERENT_FREQ_INDEX.format(self.freqstr, other.freqstr)
             raise IncompatibleFrequency(msg)
 
-    def _wrap_setop_result(self, other, result, name_func):
-        name = name_func(other)
+    def _wrap_setop_result(self, other, result):
+        name = self._get_setop_name(other)
         result = self._apply_meta(result)
         result.name = name
         return result

pandas/core/indexes/timedeltas.py

@@ -586,7 +586,7 @@ def join(self, other, how='left', level=None, return_indexers=False,
                           sort=sort)
 
     def _wrap_joined_index(self, joined, other):
-        name = self._get_intersection_name(other)
+        name = self._get_setop_name(other)
         if (isinstance(other, TimedeltaIndex) and self.freq == other.freq and
                 self._can_fast_union(other)):
             joined = self._shallow_copy(joined, name=name)
@@ -646,8 +646,8 @@ def _fast_union(self, other):
         else:
             return left
 
-    def _wrap_setop_result(self, other, result, name_func):
-        name = name_func(other)
+    def _wrap_setop_result(self, other, result):
+        name = self._get_setop_name(other)
         return self._simple_new(result, name=name, freq=None)
 
     def intersection(self, other):

pandas/tests/indexes/test_base.py

@@ -729,7 +729,15 @@ def test_union(self):
         union = Index([]).union(first)
         assert union is first
 
-        # preserve names
+        # preserve names when they are the same
+        # GH 9943 9862
+
+        first = Index(list('ab'), name='A')
+        second = Index(list('abc'), name='A')
+        union = first.union(second)
+        expected = Index(list('abc'), name='A')
+        tm.assert_index_equal(union, expected)
+
         first = Index(list('ab'), name='A')
         second = Index(list('ab'), name='B')
         union = first.union(second)
@@ -751,51 +759,66 @@ def test_union(self):
         first = Index(list('ab'))
         second = Index(list('ab'), name='B')
         union = first.union(second)
-        expected = Index(list('ab'), name='B')
+        expected = Index(list('ab'), name=None)
         tm.assert_index_equal(union, expected)
 
         # GH 9943 9862
         first = Index(list('abc'))
         second = Index(list('ab'), name='B')
         union = first.union(second)
-        expected = Index(list('abc'), name='B')
+        expected = Index(list('abc'), name=None)
         tm.assert_index_equal(union, expected)
 
         first = Index([])
         second = Index(list('ab'), name='B')
         union = first.union(second)
-        expected = Index(list('ab'), name='B')
+        expected = Index(list('ab'), name=None)
         tm.assert_index_equal(union, expected)
 
         first = Index(list('ab'))
         second = Index([], name='B')
         union = first.union(second)
-        expected = Index(list('ab'), name='B')
+        expected = Index(list('ab'), name=None)
         tm.assert_index_equal(union, expected)
 
         first = Index(list('ab'), name='A')
         second = Index(list('ab'))
         union = first.union(second)
-        expected = Index(list('ab'), name='A')
+        expected = Index(list('ab'), name=None)
         tm.assert_index_equal(union, expected)
 
         # GH 9943 9862
         first = Index(list('ab'), name='A')
         second = Index(list('abc'))
         union = first.union(second)
-        expected = Index(list('abc'), name='A')
+        expected = Index(list('abc'), name=None)
         tm.assert_index_equal(union, expected)
 
         first = Index(list('ab'), name='A')
         second = Index([])
         union = first.union(second)
-        expected = Index(list('ab'), name='A')
+        expected = Index(list('ab'), name=None)
         tm.assert_index_equal(union, expected)
 
         first = Index([], name='A')
         second = Index(list('ab'))
         union = first.union(second)
-        expected = Index(list('ab'), name='A')
+        expected = Index(list('ab'), name=None)
+        tm.assert_index_equal(union, expected)
+
+        # Chained unions handles names correctly
+        i1 = Index([1, 2], name='i1')
+        i2 = Index([3, 4], name='i2')
+        i3 = Index([5, 6], name='i3')
+        union = i1.union(i2.union(i3))
+        expected = i1.union(i2).union(i3)
+        tm.assert_index_equal(union, expected)
+
+        j1 = Index([1, 2], name='j1')
+        j2 = Index([], name='j2')
+        j3 = Index([], name='j3')
+        union = j1.union(j2.union(j3))
+        expected = j1.union(j2).union(j3)
         tm.assert_index_equal(union, expected)
 
         with tm.assert_produces_warning(RuntimeWarning):

pandas/tests/indexes/test_range.py

@@ -432,7 +432,7 @@ def test_join_outer(self):
         tm.assert_index_equal(res, noidx_res)
 
         eres = Int64Index([0, 2, 4, 6, 8, 10, 12, 14, 15, 16, 17, 18, 19, 20,
-                           21, 22, 23, 24, 25], name=self.index.name)
+                           21, 22, 23, 24, 25])
         elidx = np.array([0, 1, 2, 3, 4, 5, 6, 7, -1, 8, -1, 9,
                           -1, -1, -1, -1, -1, -1, -1], dtype=np.intp)
         eridx = np.array([-1, -1, -1, -1, -1, -1, -1, -1, 10, 9, 8, 7, 6,
@@ -667,13 +667,11 @@ def test_union_noncomparable(self):
         now = datetime.now()
         other = Index([now + timedelta(i) for i in range(4)], dtype=object)
         result = self.index.union(other)
-        expected = Index(np.concatenate((self.index, other)),
-                         name=self.index.name)
+        expected = Index(np.concatenate((self.index, other)))
         tm.assert_index_equal(result, expected)
 
         result = other.union(self.index)
-        expected = Index(np.concatenate((other, self.index)),
-                         name=self.index.name)
+        expected = Index(np.concatenate((other, self.index)))
         tm.assert_index_equal(result, expected)
 
     def test_union(self):