CLN: Move to_period, to_perioddelta up to EA subclasses

pandas/core/arrays/datetimelike.py

@@ -13,6 +13,7 @@
 
 from pandas.errors import NullFrequencyError, PerformanceWarning
 from pandas import compat
+from pandas.compat.numpy import function as nv
 
 from pandas.tseries import frequencies
 from pandas.tseries.offsets import Tick, DateOffset
@@ -207,6 +208,24 @@ def astype(self, dtype, copy=True):
             return self._box_values(self.asi8)
         return super(DatetimeLikeArrayMixin, self).astype(dtype, copy)
 
+    def repeat(self, repeats, *args, **kwargs):
+        """
+        Analogous to ndarray.repeat
+        """
+        nv.validate_repeat(args, kwargs)
+        if is_period_dtype(self):
+            freq = self.freq
+        else:
+            freq = None
+        return self._shallow_copy(self.asi8.repeat(repeats),
+                                  freq=freq)
+
+    def tolist(self):
+        """
+        return a list of the underlying data
+        """
+        return list(self.astype(object))
+
     # ------------------------------------------------------------------
     # Null Handling
 

pandas/core/arrays/datetimes.py

@@ -829,6 +829,24 @@ def to_period(self, freq=None):
 
         return PeriodArrayMixin(self.values, freq=freq)
 
+    def to_perioddelta(self, freq):
+        """
+        Calculate TimedeltaArray of difference between index
+        values and index converted to PeriodArray at specified
+        freq. Used for vectorized offsets
+
+        Parameters
+        ----------
+        freq: Period frequency
+
+        Returns
+        -------
+        TimedeltaArray/Index
+        """
+        from pandas.core.arrays.timedeltas import TimedeltaArrayMixin
+        i8delta = self.asi8 - self.to_period(freq).to_timestamp().asi8
+        return TimedeltaArrayMixin(i8delta)
+
     # -----------------------------------------------------------------
     # Properties - Vectorized Timestamp Properties/Methods
 

pandas/core/indexes/datetimelike.py

@@ -415,12 +415,6 @@ def _convert_tolerance(self, tolerance, target):
                              'target index size')
         return tolerance
 
-    def tolist(self):
-        """
-        return a list of the underlying data
-        """
-        return list(self.astype(object))
-
     def min(self, axis=None, *args, **kwargs):
         """
         Return the minimum value of the Index or minimum along
@@ -613,18 +607,6 @@ def isin(self, values):
 
         return algorithms.isin(self.asi8, values.asi8)
 
-    def repeat(self, repeats, *args, **kwargs):
-        """
-        Analogous to ndarray.repeat
-        """
-        nv.validate_repeat(args, kwargs)
-        if is_period_dtype(self):
-            freq = self.freq
-        else:
-            freq = None
-        return self._shallow_copy(self.asi8.repeat(repeats),
-                                  freq=freq)
-
     @Appender(_index_shared_docs['where'] % _index_doc_kwargs)
     def where(self, cond, other=None):
         other = _ensure_datetimelike_to_i8(other, to_utc=True)

pandas/core/indexes/datetimes.py

@@ -42,7 +42,6 @@
 from pandas.tseries.offsets import (
     generate_range, CDay, prefix_mapping)
 
-from pandas.core.tools.timedeltas import to_timedelta
 from pandas.util._decorators import Appender, cache_readonly, Substitution
 import pandas.core.common as com
 import pandas.tseries.offsets as offsets
@@ -621,13 +620,6 @@ def to_series(self, keep_tz=False, index=None, name=None):
 
         return Series(values, index=index, name=name)
 
-    @Appender(DatetimeArrayMixin.to_period.__doc__)
-    def to_period(self, freq=None):
-        from pandas.core.indexes.period import PeriodIndex
-
-        result = DatetimeArrayMixin.to_period(self, freq=freq)
-        return PeriodIndex(result, name=self.name)
-
     def snap(self, freq='S'):
         """
         Snap time stamps to nearest occurring frequency
@@ -699,23 +691,6 @@ def union(self, other):
                     result.freq = to_offset(result.inferred_freq)
             return result
 
-    def to_perioddelta(self, freq):
-        """
-        Calculate TimedeltaIndex of difference between index
-        values and index converted to periodIndex at specified
-        freq. Used for vectorized offsets
-
-        Parameters
-        ----------
-        freq: Period frequency
-
-        Returns
-        -------
-        y: TimedeltaIndex
-        """
-        return to_timedelta(self.asi8 - self.to_period(freq)
-                            .to_timestamp().asi8)
-
     def union_many(self, others):
         """
         A bit of a hack to accelerate unioning a collection of indexes
@@ -1247,6 +1222,9 @@ def slice_indexer(self, start=None, end=None, step=None, kind=None):
     is_year_end = wrap_field_accessor(DatetimeArrayMixin.is_year_end)
     is_leap_year = wrap_field_accessor(DatetimeArrayMixin.is_leap_year)
 
+    to_perioddelta = wrap_array_method(DatetimeArrayMixin.to_perioddelta,
+                                       False)
+    to_period = wrap_array_method(DatetimeArrayMixin.to_period, True)
     normalize = wrap_array_method(DatetimeArrayMixin.normalize, True)
     to_julian_date = wrap_array_method(DatetimeArrayMixin.to_julian_date,
                                        False)

pandas/core/indexes/period.py

@@ -316,9 +316,9 @@ def __array_wrap__(self, result, context=None):
         """
         if isinstance(context, tuple) and len(context) > 0:
             func = context[0]
-            if (func is np.add):
+            if func is np.add:
                 pass
-            elif (func is np.subtract):
+            elif func is np.subtract:
                 name = self.name
                 left = context[1][0]
                 right = context[1][1]
@@ -339,7 +339,7 @@ def __array_wrap__(self, result, context=None):
             return result
         # the result is object dtype array of Period
         # cannot pass _simple_new as it is
-        return self._shallow_copy(result, freq=self.freq, name=self.name)
+        return type(self)(result, freq=self.freq, name=self.name)
 
     @property
     def size(self):

pandas/tests/arrays/test_datetimelike.py

@@ -67,6 +67,40 @@ def test_astype_object(self, tz_naive_fixture):
         assert asobj.dtype == 'O'
         assert list(asobj) == list(dti)
 
+    # TODO: share this between Datetime/Timedelta/Period Array tests
+    def test_repeat(self, datetime_index):
+        dti = datetime_index
+        arr = DatetimeArrayMixin(dti)
+
+        expected = dti.repeat(3)
+        result = arr.repeat(3)
+        assert isinstance(result, DatetimeArrayMixin)
+
+        # placeholder until these become actual EA subclasses and we can use
+        #  an EA-specific tm.assert_ function
+        tm.assert_index_equal(pd.Index(result), pd.Index(expected))
+
+    def test_tolist(self, datetime_index):
+        dti = datetime_index
+        arr = DatetimeArrayMixin(dti)
+
+        expected = dti.tolist()
+        result = arr.tolist()
+        assert expected == result
+
+    @pytest.mark.parametrize('freqstr', ['D', 'B', 'W', 'M', 'Q', 'Y'])
+    def test_to_perioddelta(self, datetime_index, freqstr):
+        dti = datetime_index
+        arr = DatetimeArrayMixin(dti)
+
+        expected = dti.to_perioddelta(freq=freqstr)
+        result = arr.to_perioddelta(freq=freqstr)
+        assert isinstance(result, TimedeltaArrayMixin)
+
+        # placeholder until these become actual EA subclasses and we can use
+        #  an EA-specific tm.assert_ function
+        tm.assert_index_equal(pd.Index(result), pd.Index(expected))
+
     @pytest.mark.parametrize('freqstr', ['D', 'B', 'W', 'M', 'Q', 'Y'])
     def test_to_period(self, datetime_index, freqstr):
         dti = datetime_index
@@ -156,6 +190,27 @@ def test_to_timestamp(self, how, period_index):
         #  an EA-specific tm.assert_ function
         tm.assert_index_equal(pd.Index(result), pd.Index(expected))
 
+    # TODO: share this between Datetime/Timedelta/Period Array tests
+    def test_repeat(self, period_index):
+        pi = period_index
+        arr = PeriodArrayMixin(pi)
+
+        expected = pi.repeat(3)
+        result = arr.repeat(3)
+        assert isinstance(result, PeriodArrayMixin)
+
+        # placeholder until these become actual EA subclasses and we can use
+        #  an EA-specific tm.assert_ function
+        tm.assert_index_equal(pd.Index(result), pd.Index(expected))
+
+    def test_tolist(self, period_index):
+        pi = period_index
+        arr = PeriodArrayMixin(pi)
+
+        expected = pi.tolist()
+        result = arr.tolist()
+        assert expected == result
+
     @pytest.mark.parametrize('propname', pd.PeriodIndex._bool_ops)
     def test_bool_properties(self, period_index, propname):
         # in this case _bool_ops is just `is_leap_year`