More plumbing and fixing

* took care of wrappers in datetimes and interval
* fix tolerance handling in extended dtype index construction
* fix unpickling of old pickles and a bug in numeric index unpickling
* fix tolerance for constructor delegation in `__new__`.

Author: WeatherGod

pandas/core/indexes/base.py

@@ -293,7 +293,7 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None,
             # coerce to the object dtype
             data = data.astype(object)
             return Index(data, dtype=object, copy=copy, name=name,
-                         **kwargs)
+                         tolerance=tolerance, **kwargs)
 
         # index-like
         elif isinstance(data, (np.ndarray, Index, ABCSeries)):
@@ -306,7 +306,8 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None,
                                        dtype=dtype, tolerance=tolerance,
                                        **kwargs)
                 if dtype is not None and is_dtype_equal(_o_dtype, dtype):
-                    return Index(result.to_pydatetime(), dtype=_o_dtype)
+                    return Index(result.to_pydatetime(), dtype=_o_dtype,
+                                 tolerance=tolerance)
                 else:
                     return result
 
@@ -316,7 +317,8 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None,
                 result = TimedeltaIndex(data, copy=copy, name=name,
                                         tolerance=tolerance, **kwargs)
                 if dtype is not None and _o_dtype == dtype:
-                    return Index(result.to_pytimedelta(), dtype=_o_dtype)
+                    return Index(result.to_pytimedelta(), dtype=_o_dtype,
+                                 tolerance=tolerance)
                 else:
                     return result
 
@@ -468,7 +470,8 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None,
                     # 10697
                     from .multi import MultiIndex
                     return MultiIndex.from_tuples(
-                        data, names=name or kwargs.get('names'))
+                        data, names=name or kwargs.get('names'),
+                        tolerance=tolerance)
             # other iterable of some kind
             subarr = com.asarray_tuplesafe(data, dtype=object)
             return Index(subarr, dtype=dtype, copy=copy, name=name,
@@ -1925,6 +1928,7 @@ def __setstate__(self, state):
 
         if isinstance(state, dict):
             self._data = state.pop('data')
+            self.tolerance = state.pop('tolerance', None)
             for k, v in compat.iteritems(state):
                 setattr(self, k, v)
 
@@ -1940,6 +1944,7 @@ def __setstate__(self, state):
                 data = np.empty(state)
                 np.ndarray.__setstate__(data, state)
 
+            self.tolerance = None
             self._data = data
             self._reset_identity()
         else:
@@ -2430,6 +2435,10 @@ def identical(self, other):
         """Similar to equals, but check that other comparable attributes are
         also equal
         """
+        # FIXME: Should two indexes with different tolerances but are
+        # otherwise identical be considered identical?
+        # FIXME: Should this equality check take into account tolerances,
+        # or should it be forced to be strict (tolerance=0)?
         return (self.equals(other) and
                 all((getattr(self, c, None) == getattr(other, c, None)
                      for c in self._comparables)) and
@@ -4563,7 +4572,7 @@ def unique(self, level=None):
         if level is not None:
             self._validate_index_level(level)
         result = super(Index, self).unique()
-        return self._shallow_copy(result)
+        return self._shallow_copy(result, tolerance=self.tolerance)
 
     def drop_duplicates(self, keep='first'):
         """

pandas/core/indexes/datetimes.py

@@ -64,7 +64,7 @@ def f(self):
         result = fget(self)
         if is_bool_dtype(result):
             return result
-        return Index(result, name=self.name)
+        return Index(result, name=self.name, tolerance=self.tolerance)
 
     f.__name__ = name
     f.__doc__ = fget.__doc__
@@ -76,7 +76,7 @@ def _wrap_in_index(name):
 
     def func(self, *args, **kwargs):
         result = meth(self, *args, **kwargs)
-        return Index(result, name=self.name)
+        return Index(result, name=self.name, tolerance=self.tolerance)
 
     func.__doc__ = meth.__doc__
     func.__name__ = name

pandas/core/indexes/interval.py

@@ -988,7 +988,7 @@ def equals(self, other, tolerance=None):
                 self.closed == other.closed)
 
     def _setop(op_name):
-        def func(self, other):
+        def func(self, other, tolerance=None):
             other = self._as_like_interval_index(other)
 
             # GH 19016: ensure set op will not return a prohibited dtype
@@ -999,8 +999,10 @@ def func(self, other):
                        'objects that have compatible dtypes')
                 raise TypeError(msg.format(op=op_name))
 
-            result = getattr(self._multiindex, op_name)(other._multiindex)
+            result = getattr(self._multiindex, op_name)(other._multiindex,
+                                                        tolerance=tolerance)
             result_name = self.name if self.name == other.name else None
+            result_tolerance = result.tolerance
 
             # GH 19101: ensure empty results have correct dtype
             if result.empty:
@@ -1009,7 +1011,8 @@ def func(self, other):
                 result = result.values
 
             return type(self).from_tuples(result, closed=self.closed,
-                                          name=result_name)
+                                          name=result_name,
+                                          tolerance=result_tolerance)
         return func
 
     union = _setop('union')

pandas/core/indexes/multi.py

@@ -1569,12 +1569,13 @@ def __setstate__(self, state):
 
             nd_state, own_state = state
             levels, labels, sortorder, names = own_state
+            tolerance = None
 
         self._set_levels([Index(x) for x in levels], validate=False)
         self._set_labels(labels)
         self._set_names(names)
         self.sortorder = sortorder
-        self.tolerance = None
+        self.tolerance = tolerance
         self._verify_integrity()
         self._reset_identity()
 

pandas/core/indexes/period.py

@@ -811,6 +811,7 @@ def __setstate__(self, state):
                 np.ndarray.__setstate__(self, state)
 
             self._data = data
+            self.tolerance = tolerance
 
         else:
             raise Exception("invalid pickle state")

pandas/core/indexes/range.py

@@ -17,7 +17,7 @@
 
 import pandas.core.common as com
 from pandas.core import ops
-from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.core.indexes.base import Index, _index_shared_docs, ensure_index
 from pandas.util._decorators import Appender, cache_readonly
 import pandas.core.dtypes.concat as _concat
 import pandas.core.indexes.base as ibase
@@ -80,7 +80,8 @@ def __new__(cls, start=None, stop=None, step=None,
             if name is None:
                 name = start.name
             return cls._simple_new(name=name,
-                                   **dict(start._get_data_as_items()))
+                                   **dict(start._get_data_as_items(),
+                                          tolerance=tolerance))
 
         # validate the arguments
         def ensure_int(value, field):
@@ -174,7 +175,8 @@ def _data(self):
 
     @cache_readonly
     def _int64index(self):
-        return Int64Index(self._data, name=self.name, fastpath=True)
+        return Int64Index(self._data, name=self.name, fastpath=True,
+                          tolerance=self.tolerance)
 
     def _get_data_as_items(self):
         """ return a list of tuples of start, stop, step """
@@ -321,6 +323,7 @@ def equals(self, other, tolerance=None):
         if isinstance(other, RangeIndex):
             ls = len(self)
             lo = len(other)
+            # FIXME: intolerant
             return (ls == lo == 0 or
                     ls == lo == 1 and
                     self._start == other._start or
@@ -428,13 +431,12 @@ def union(self, other, tolerance=None):
         union : Index
         """
         self._assert_can_do_setop(other)
+        other = ensure_index(other)
         tolerance = self._choose_tolerance([other], tolerance=tolerance)
         if len(other) == 0 or self.equals(other, tolerance=tolerance):
-            # FIXME: intolerant
-            return self
+            return self._shallow_copy(tolerance=tolerance)
         if len(self) == 0:
-            # FIXME: intolerant
-            return other
+            return other._shallow_copy(tolerance=tolerance)
         if isinstance(other, RangeIndex):
             # FIXME: intolerant (how should I implement this?)
             start_s, step_s = self._start, self._step