diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 3fa4f503d2dd5..daf2dcccd284b 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -124,8 +124,12 @@ def asi8(self):
         # do not cache or you'll create a memory leak
         return self._data.view('i8')
 
-    # ------------------------------------------------------------------
-    # Array-like Methods
+    # ----------------------------------------------------------------
+    # Array-Like / EA-Interface Methods
+
+    @property
+    def nbytes(self):
+        return self._data.nbytes
 
     @property
     def shape(self):
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index b0485cc82f07f..a6f688fb0cf7a 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -385,7 +385,7 @@ def _resolution(self):
         return libresolution.resolution(self.asi8, self.tz)
 
     # ----------------------------------------------------------------
-    # Array-like Methods
+    # Array-Like / EA-Interface Methods
 
     def __array__(self, dtype=None):
         if is_object_dtype(dtype):
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 482968fdb4766..b343d42ef3b7c 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -272,10 +272,6 @@ def _concat_same_type(cls, to_concat):
 
     # --------------------------------------------------------------------
     # Data / Attributes
-    @property
-    def nbytes(self):
-        # TODO(DatetimeArray): remove
-        return self._data.nbytes
 
     @cache_readonly
     def dtype(self):
@@ -286,10 +282,6 @@ def _ndarray_values(self):
         # Ordinals
         return self._data
 
-    @property
-    def asi8(self):
-        return self._data
-
     @property
     def freq(self):
         """Return the frequency object for this PeriodArray."""
@@ -330,6 +322,50 @@ def start_time(self):
     def end_time(self):
         return self.to_timestamp(how='end')
 
+    def to_timestamp(self, freq=None, how='start'):
+        """
+        Cast to DatetimeArray/Index.
+
+        Parameters
+        ----------
+        freq : string or DateOffset, optional
+            Target frequency. The default is 'D' for week or longer,
+            'S' otherwise
+        how : {'s', 'e', 'start', 'end'}
+
+        Returns
+        -------
+        DatetimeArray/Index
+        """
+        from pandas.core.arrays import DatetimeArrayMixin
+
+        how = libperiod._validate_end_alias(how)
+
+        end = how == 'E'
+        if end:
+            if freq == 'B':
+                # roll forward to ensure we land on B date
+                adjust = Timedelta(1, 'D') - Timedelta(1, 'ns')
+                return self.to_timestamp(how='start') + adjust
+            else:
+                adjust = Timedelta(1, 'ns')
+                return (self + self.freq).to_timestamp(how='start') - adjust
+
+        if freq is None:
+            base, mult = frequencies.get_freq_code(self.freq)
+            freq = frequencies.get_to_timestamp_base(base)
+        else:
+            freq = Period._maybe_convert_freq(freq)
+
+        base, mult = frequencies.get_freq_code(freq)
+        new_data = self.asfreq(freq, how=how)
+
+        new_data = libperiod.periodarr_to_dt64arr(new_data.asi8, base)
+        return DatetimeArrayMixin(new_data, freq='infer')
+
+    # --------------------------------------------------------------------
+    # Array-like / EA-Interface Methods
+
     def __repr__(self):
         return '<{}>\n{}\nLength: {}, dtype: {}'.format(
             self.__class__.__name__,
@@ -456,6 +492,8 @@ def value_counts(self, dropna=False):
                             name=result.index.name)
         return Series(result.values, index=index, name=result.name)
 
+    # --------------------------------------------------------------------
+
     def shift(self, periods=1):
         """
         Shift values by desired number.
@@ -567,49 +605,9 @@ def asfreq(self, freq=None, how='E'):
 
         return type(self)(new_data, freq=freq)
 
-    def to_timestamp(self, freq=None, how='start'):
-        """
-        Cast to DatetimeArray/Index
-
-        Parameters
-        ----------
-        freq : string or DateOffset, optional
-            Target frequency. The default is 'D' for week or longer,
-            'S' otherwise
-        how : {'s', 'e', 'start', 'end'}
-
-        Returns
-        -------
-        DatetimeArray/Index
-        """
-        from pandas.core.arrays import DatetimeArrayMixin
-
-        how = libperiod._validate_end_alias(how)
-
-        end = how == 'E'
-        if end:
-            if freq == 'B':
-                # roll forward to ensure we land on B date
-                adjust = Timedelta(1, 'D') - Timedelta(1, 'ns')
-                return self.to_timestamp(how='start') + adjust
-            else:
-                adjust = Timedelta(1, 'ns')
-                return (self + self.freq).to_timestamp(how='start') - adjust
-
-        if freq is None:
-            base, mult = frequencies.get_freq_code(self.freq)
-            freq = frequencies.get_to_timestamp_base(base)
-        else:
-            freq = Period._maybe_convert_freq(freq)
-
-        base, mult = frequencies.get_freq_code(freq)
-        new_data = self.asfreq(freq, how=how)
-
-        new_data = libperiod.periodarr_to_dt64arr(new_data.asi8, base)
-        return DatetimeArrayMixin(new_data, freq='infer')
-
     # ------------------------------------------------------------------
     # Formatting
+
     def _format_native_types(self, na_rep=u'NaT', date_format=None, **kwargs):
         """ actually format my specific types """
         # TODO(DatetimeArray): remove
@@ -630,9 +628,13 @@ def _format_native_types(self, na_rep=u'NaT', date_format=None, **kwargs):
             values = np.array([formatter(dt) for dt in values])
         return values
 
+    # Delegation...
+    def strftime(self, date_format):
+        return self._format_native_types(date_format=date_format)
+
     def repeat(self, repeats, *args, **kwargs):
         """
-        Repeat elements of a Categorical.
+        Repeat elements of a PeriodArray.
 
         See also
         --------
@@ -643,10 +645,6 @@ def repeat(self, repeats, *args, **kwargs):
         values = self._data.repeat(repeats)
         return type(self)(values, self.freq)
 
-    # Delegation...
-    def strftime(self, date_format):
-        return self._format_native_types(date_format=date_format)
-
     def astype(self, dtype, copy=True):
         # TODO: Figure out something better here...
         # We have DatetimeLikeArrayMixin ->
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 1f78e0c00bf00..9dbdd6ff8b562 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -190,6 +190,9 @@ def _generate_range(cls, start, end, periods, freq, closed=None):
 
         return cls._simple_new(index, freq=freq)
 
+    # ----------------------------------------------------------------
+    # Array-Like / EA-Interface Methods
+
     # ----------------------------------------------------------------
     # Arithmetic Methods
 
@@ -412,20 +415,25 @@ def sequence_to_td64ns(data, copy=False, unit="ns", errors="raise"):
     array : list-like
     copy : bool, default False
     unit : str, default "ns"
+        The timedelta unit to treat integers as multiples of.
     errors : {"raise", "coerce", "ignore"}, default "raise"
+        How to handle elements that cannot be converted to timedelta64[ns].
+        See ``pandas.to_timedelta`` for details.
 
     Returns
     -------
-    ndarray[timedelta64[ns]]
+    converted : numpy.ndarray
+        The sequence converted to a numpy array with dtype ``timedelta64[ns]``.
     inferred_freq : Tick or None
+        The inferred frequency of the sequence.
 
     Raises
     ------
-    ValueError : data cannot be converted to timedelta64[ns]
+    ValueError : Data cannot be converted to timedelta64[ns].
 
     Notes
     -----
-    Unlike `pandas.to_timedelta`, if setting `errors=ignore` will not cause
+    Unlike `pandas.to_timedelta`, if setting ``errors=ignore`` will not cause
     errors to be ignored; they are caught and subsequently ignored at a
     higher level.
     """
@@ -497,12 +505,13 @@ def ints_to_td64ns(data, unit="ns"):
 
     Parameters
     ----------
-    data : np.ndarray with integer-dtype
+    data : numpy.ndarray with integer-dtype
     unit : str, default "ns"
+        The timedelta unit to treat integers as multiples of.
 
     Returns
     -------
-    ndarray[timedelta64[ns]]
+    numpy.ndarray : timedelta64[ns] array converted from data
     bool : whether a copy was made
     """
     copy_made = False
@@ -538,15 +547,18 @@ def objects_to_td64ns(data, unit="ns", errors="raise"):
     ----------
     data : ndarray or Index
     unit : str, default "ns"
+        The timedelta unit to treat integers as multiples of.
     errors : {"raise", "coerce", "ignore"}, default "raise"
+        How to handle elements that cannot be converted to timedelta64[ns].
+        See ``pandas.to_timedelta`` for details.
 
     Returns
     -------
-    ndarray[timedelta64[ns]]
+    numpy.ndarray : timedelta64[ns] array converted from data
 
     Raises
     ------
-    ValueError : data cannot be converted to timedelta64[ns]
+    ValueError : Data cannot be converted to timedelta64[ns].
 
     Notes
     -----
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 59429488a7c2f..1d9d3b1d3bd16 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -4,44 +4,32 @@
 """
 import warnings
 
-from pandas import compat
-from pandas.compat.numpy import function as nv
-from pandas.core.tools.timedeltas import to_timedelta
-
 import numpy as np
 
-from pandas._libs import lib, iNaT, NaT
-from pandas._libs.tslibs.timestamps import round_nsint64, RoundTo
+from pandas._libs import NaT, iNaT, lib
+from pandas._libs.tslibs.timestamps import RoundTo, round_nsint64
+import pandas.compat as compat
+from pandas.compat.numpy import function as nv
+from pandas.util._decorators import Appender, cache_readonly
 
 from pandas.core.dtypes.common import (
-    ensure_int64,
-    is_dtype_equal,
-    is_float,
-    is_integer,
-    is_list_like,
-    is_scalar,
-    is_bool_dtype,
-    is_period_dtype,
-    is_categorical_dtype,
-    is_datetime_or_timedelta_dtype,
-    is_float_dtype,
-    is_integer_dtype,
-    is_object_dtype,
-    is_string_dtype)
-from pandas.core.dtypes.generic import (
-    ABCIndex, ABCSeries, ABCIndexClass)
+    ensure_int64, is_bool_dtype, is_categorical_dtype,
+    is_datetime_or_timedelta_dtype, is_dtype_equal, is_float, is_float_dtype,
+    is_integer, is_integer_dtype, is_list_like, is_object_dtype,
+    is_period_dtype, is_scalar, is_string_dtype)
+import pandas.core.dtypes.concat as _concat
+from pandas.core.dtypes.generic import ABCIndex, ABCIndexClass, ABCSeries
 from pandas.core.dtypes.missing import isna
-from pandas.core import common as com, algorithms, ops
-
-import pandas.io.formats.printing as printing
 
+from pandas.core import algorithms, common as com, ops
 from pandas.core.arrays import PeriodArray
 from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
+import pandas.core.indexes.base as ibase
 from pandas.core.indexes.base import Index, _index_shared_docs
-from pandas.util._decorators import Appender, cache_readonly
-import pandas.core.dtypes.concat as _concat
+from pandas.core.tools.timedeltas import to_timedelta
+
+import pandas.io.formats.printing as printing
 
-import pandas.core.indexes.base as ibase
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 
 
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index c82cff19573e3..b754b2705d034 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -1,57 +1,45 @@
 # pylint: disable=E1101
 from __future__ import division
+
+from datetime import datetime, time, timedelta
 import operator
 import warnings
-from datetime import time, datetime, timedelta
 
 import numpy as np
 from pytz import utc
 
-from pandas.core.base import _shared_docs
+from pandas._libs import (
+    Timestamp, index as libindex, join as libjoin, lib, tslib as libts)
+from pandas._libs.tslibs import (
+    ccalendar, conversion, fields, parsing, timezones)
+import pandas.compat as compat
+from pandas.util._decorators import Appender, Substitution, cache_readonly
 
 from pandas.core.dtypes.common import (
-    _INT64_DTYPE,
-    _NS_DTYPE,
-    is_datetime64_dtype,
-    is_datetimetz,
-    is_dtype_equal,
-    is_integer,
-    is_float,
-    is_integer_dtype,
-    is_datetime64_ns_dtype,
-    is_period_dtype,
-    is_string_like,
-    is_list_like,
-    is_scalar,
-    pandas_dtype,
-    ensure_int64)
+    _INT64_DTYPE, _NS_DTYPE, ensure_int64, is_datetime64_dtype,
+    is_datetime64_ns_dtype, is_datetimetz, is_dtype_equal, is_float,
+    is_integer, is_integer_dtype, is_list_like, is_period_dtype, is_scalar,
+    is_string_like, pandas_dtype)
+import pandas.core.dtypes.concat as _concat
 from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import isna
 
-import pandas.core.dtypes.concat as _concat
-from pandas.core.arrays.datetimes import DatetimeArrayMixin, _to_m8
 from pandas.core.arrays import datetimelike as dtl
-
+from pandas.core.arrays.datetimes import (
+    DatetimeArrayMixin as DatetimeArray, _to_m8)
+from pandas.core.base import _shared_docs
+import pandas.core.common as com
 from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.core.indexes.datetimelike import (
+    DatelikeOps, DatetimeIndexOpsMixin, TimelikeOps, wrap_array_method,
+    wrap_field_accessor)
 from pandas.core.indexes.numeric import Int64Index
 from pandas.core.ops import get_op_result_name
-import pandas.compat as compat
-from pandas.tseries.frequencies import to_offset, Resolution
-from pandas.core.indexes.datetimelike import (
-    DatelikeOps, TimelikeOps, DatetimeIndexOpsMixin,
-    wrap_field_accessor, wrap_array_method)
-from pandas.tseries.offsets import (
-    CDay, prefix_mapping)
-
-from pandas.util._decorators import Appender, cache_readonly, Substitution
-import pandas.core.common as com
-import pandas.tseries.offsets as offsets
 import pandas.core.tools.datetimes as tools
 
-from pandas._libs import (lib, index as libindex, tslib as libts,
-                          join as libjoin, Timestamp)
-from pandas._libs.tslibs import (timezones, conversion, fields, parsing,
-                                 ccalendar)
+from pandas.tseries import offsets
+from pandas.tseries.frequencies import Resolution, to_offset
+from pandas.tseries.offsets import CDay, prefix_mapping
 
 
 def _new_DatetimeIndex(cls, d):
@@ -68,7 +56,7 @@ def _new_DatetimeIndex(cls, d):
     return result
 
 
-class DatetimeIndex(DatetimeArrayMixin, DatelikeOps, TimelikeOps,
+class DatetimeIndex(DatetimeArray, DatelikeOps, TimelikeOps,
                     DatetimeIndexOpsMixin, Int64Index):
     """
     Immutable ndarray of datetime64 data, represented internally as int64, and
@@ -182,8 +170,6 @@ class DatetimeIndex(DatetimeArrayMixin, DatelikeOps, TimelikeOps,
     pandas.to_datetime : Convert argument to datetime
 
     """
-    _resolution = cache_readonly(DatetimeArrayMixin._resolution.fget)
-
     _typ = 'datetimeindex'
     _join_precedence = 10
 
@@ -227,8 +213,6 @@ def _join_i8_wrapper(joinf, **kwargs):
 
     _is_numeric_dtype = False
     _infer_as_myclass = True
-    _timezone = cache_readonly(DatetimeArrayMixin._timezone.fget)
-    is_normalized = cache_readonly(DatetimeArrayMixin.is_normalized.fget)
 
     # --------------------------------------------------------------------
     # Constructors
@@ -268,8 +252,7 @@ def __new__(cls, data=None,
         # if dtype has an embedded tz, capture it
         tz = dtl.validate_tz_from_dtype(dtype, tz)
 
-        if not isinstance(data, (np.ndarray, Index, ABCSeries,
-                                 DatetimeArrayMixin)):
+        if not isinstance(data, (np.ndarray, Index, ABCSeries, DatetimeArray)):
             # other iterable of some kind
             if not isinstance(data, (list, tuple)):
                 data = list(data)
@@ -283,7 +266,7 @@ def __new__(cls, data=None,
             data = tools.to_datetime(data, dayfirst=dayfirst,
                                      yearfirst=yearfirst)
 
-        if isinstance(data, DatetimeArrayMixin):
+        if isinstance(data, DatetimeArray):
             if tz is None:
                 tz = data.tz
             elif data.tz is None:
@@ -1125,43 +1108,47 @@ def slice_indexer(self, start=None, end=None, step=None, kind=None):
     # --------------------------------------------------------------------
     # Wrapping DatetimeArray
 
-    year = wrap_field_accessor(DatetimeArrayMixin.year)
-    month = wrap_field_accessor(DatetimeArrayMixin.month)
-    day = wrap_field_accessor(DatetimeArrayMixin.day)
-    hour = wrap_field_accessor(DatetimeArrayMixin.hour)
-    minute = wrap_field_accessor(DatetimeArrayMixin.minute)
-    second = wrap_field_accessor(DatetimeArrayMixin.second)
-    microsecond = wrap_field_accessor(DatetimeArrayMixin.microsecond)
-    nanosecond = wrap_field_accessor(DatetimeArrayMixin.nanosecond)
-    weekofyear = wrap_field_accessor(DatetimeArrayMixin.weekofyear)
+    _timezone = cache_readonly(DatetimeArray._timezone.fget)
+    is_normalized = cache_readonly(DatetimeArray.is_normalized.fget)
+    _resolution = cache_readonly(DatetimeArray._resolution.fget)
+
+    year = wrap_field_accessor(DatetimeArray.year)
+    month = wrap_field_accessor(DatetimeArray.month)
+    day = wrap_field_accessor(DatetimeArray.day)
+    hour = wrap_field_accessor(DatetimeArray.hour)
+    minute = wrap_field_accessor(DatetimeArray.minute)
+    second = wrap_field_accessor(DatetimeArray.second)
+    microsecond = wrap_field_accessor(DatetimeArray.microsecond)
+    nanosecond = wrap_field_accessor(DatetimeArray.nanosecond)
+    weekofyear = wrap_field_accessor(DatetimeArray.weekofyear)
     week = weekofyear
-    dayofweek = wrap_field_accessor(DatetimeArrayMixin.dayofweek)
+    dayofweek = wrap_field_accessor(DatetimeArray.dayofweek)
     weekday = dayofweek
 
-    weekday_name = wrap_field_accessor(DatetimeArrayMixin.weekday_name)
+    weekday_name = wrap_field_accessor(DatetimeArray.weekday_name)
 
-    dayofyear = wrap_field_accessor(DatetimeArrayMixin.dayofyear)
-    quarter = wrap_field_accessor(DatetimeArrayMixin.quarter)
-    days_in_month = wrap_field_accessor(DatetimeArrayMixin.days_in_month)
+    dayofyear = wrap_field_accessor(DatetimeArray.dayofyear)
+    quarter = wrap_field_accessor(DatetimeArray.quarter)
+    days_in_month = wrap_field_accessor(DatetimeArray.days_in_month)
     daysinmonth = days_in_month
-    is_month_start = wrap_field_accessor(DatetimeArrayMixin.is_month_start)
-    is_month_end = wrap_field_accessor(DatetimeArrayMixin.is_month_end)
-    is_quarter_start = wrap_field_accessor(DatetimeArrayMixin.is_quarter_start)
-    is_quarter_end = wrap_field_accessor(DatetimeArrayMixin.is_quarter_end)
-    is_year_start = wrap_field_accessor(DatetimeArrayMixin.is_year_start)
-    is_year_end = wrap_field_accessor(DatetimeArrayMixin.is_year_end)
-    is_leap_year = wrap_field_accessor(DatetimeArrayMixin.is_leap_year)
-
-    tz_localize = wrap_array_method(DatetimeArrayMixin.tz_localize, True)
-    tz_convert = wrap_array_method(DatetimeArrayMixin.tz_convert, True)
-    to_perioddelta = wrap_array_method(DatetimeArrayMixin.to_perioddelta,
+    is_month_start = wrap_field_accessor(DatetimeArray.is_month_start)
+    is_month_end = wrap_field_accessor(DatetimeArray.is_month_end)
+    is_quarter_start = wrap_field_accessor(DatetimeArray.is_quarter_start)
+    is_quarter_end = wrap_field_accessor(DatetimeArray.is_quarter_end)
+    is_year_start = wrap_field_accessor(DatetimeArray.is_year_start)
+    is_year_end = wrap_field_accessor(DatetimeArray.is_year_end)
+    is_leap_year = wrap_field_accessor(DatetimeArray.is_leap_year)
+
+    tz_localize = wrap_array_method(DatetimeArray.tz_localize, True)
+    tz_convert = wrap_array_method(DatetimeArray.tz_convert, True)
+    to_perioddelta = wrap_array_method(DatetimeArray.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,
+    to_period = wrap_array_method(DatetimeArray.to_period, True)
+    normalize = wrap_array_method(DatetimeArray.normalize, True)
+    to_julian_date = wrap_array_method(DatetimeArray.to_julian_date,
                                        False)
-    month_name = wrap_array_method(DatetimeArrayMixin.month_name, True)
-    day_name = wrap_array_method(DatetimeArrayMixin.day_name, True)
+    month_name = wrap_array_method(DatetimeArray.month_name, True)
+    day_name = wrap_array_method(DatetimeArray.day_name, True)
 
     # --------------------------------------------------------------------
 
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 128068959ebd3..7890f03a1eba7 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -256,8 +256,12 @@ def _simple_new(cls, values, name=None, freq=None, **kwargs):
         result._reset_identity()
         return result
 
+    # ------------------------------------------------------------------------
+    # Wrapping PeriodArray
+
     # ------------------------------------------------------------------------
     # Data
+
     @property
     def _ndarray_values(self):
         return self._data._ndarray_values
@@ -361,13 +365,6 @@ def asfreq(self, freq=None, how='E'):
         result = self._data.asfreq(freq=freq, how=how)
         return self._simple_new(result, name=self.name)
 
-    def _nat_new(self, box=True):
-        # TODO(DatetimeArray): remove this
-        result = self._data._nat_new(box=box)
-        if box:
-            result = self._simple_new(result, name=self.name)
-        return result
-
     def to_timestamp(self, freq=None, how='start'):
         from pandas import DatetimeIndex
         result = self._data.to_timestamp(freq=freq, how=how)
@@ -425,6 +422,7 @@ def _maybe_convert_timedelta(self, other):
 
     # ------------------------------------------------------------------------
     # Indexing
+
     @cache_readonly
     def _engine(self):
         return self._engine_type(lambda: self, len(self))
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 35e17c7400892..d9625d38b85de 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -2,44 +2,36 @@
 from datetime import datetime
 
 import numpy as np
+
+from pandas._libs import (
+    NaT, Timedelta, index as libindex, join as libjoin, lib)
+import pandas.compat as compat
+from pandas.util._decorators import Appender, Substitution
+
 from pandas.core.dtypes.common import (
-    _TD_DTYPE,
-    is_integer,
-    is_float,
-    is_list_like,
-    is_scalar,
-    is_timedelta64_dtype,
-    is_timedelta64_ns_dtype,
-    pandas_dtype,
-    ensure_int64)
+    _TD_DTYPE, ensure_int64, is_float, is_integer, is_list_like, is_scalar,
+    is_timedelta64_dtype, is_timedelta64_ns_dtype, pandas_dtype)
+import pandas.core.dtypes.concat as _concat
 from pandas.core.dtypes.missing import isna
 
+from pandas.core.arrays import datetimelike as dtl
 from pandas.core.arrays.timedeltas import (
-    TimedeltaArrayMixin, _is_convertible_to_td, _to_m8,
+    TimedeltaArrayMixin as TimedeltaArray, _is_convertible_to_td, _to_m8,
     sequence_to_td64ns)
-from pandas.core.arrays import datetimelike as dtl
-
-from pandas.core.indexes.base import Index
-from pandas.core.indexes.numeric import Int64Index
-import pandas.compat as compat
-
-from pandas.tseries.frequencies import to_offset
 from pandas.core.base import _shared_docs
-from pandas.core.indexes.base import _index_shared_docs
 import pandas.core.common as com
-from pandas.core.ops import get_op_result_name
-import pandas.core.dtypes.concat as _concat
-from pandas.util._decorators import Appender, Substitution
+from pandas.core.indexes.base import Index, _index_shared_docs
 from pandas.core.indexes.datetimelike import (
-    TimelikeOps, DatetimeIndexOpsMixin, wrap_arithmetic_op,
-    wrap_array_method, wrap_field_accessor)
-from pandas.core.tools.timedeltas import (
-    _coerce_scalar_to_timedelta_type)
-from pandas._libs import (lib, index as libindex,
-                          join as libjoin, Timedelta, NaT)
+    DatetimeIndexOpsMixin, TimelikeOps, wrap_arithmetic_op, wrap_array_method,
+    wrap_field_accessor)
+from pandas.core.indexes.numeric import Int64Index
+from pandas.core.ops import get_op_result_name
+from pandas.core.tools.timedeltas import _coerce_scalar_to_timedelta_type
+
+from pandas.tseries.frequencies import to_offset
 
 
-class TimedeltaIndex(TimedeltaArrayMixin, DatetimeIndexOpsMixin,
+class TimedeltaIndex(TimedeltaArray, DatetimeIndexOpsMixin,
                      TimelikeOps, Int64Index):
     """
     Immutable ndarray of timedelta64 data, represented internally as int64, and
@@ -223,8 +215,7 @@ def _maybe_update_attributes(self, attrs):
         return attrs
 
     def _evaluate_with_timedelta_like(self, other, op):
-        result = TimedeltaArrayMixin._evaluate_with_timedelta_like(self, other,
-                                                                   op)
+        result = TimedeltaArray._evaluate_with_timedelta_like(self, other, op)
         return wrap_arithmetic_op(self, other, result)
 
     def _format_native_types(self, na_rep=u'NaT', date_format=None, **kwargs):
@@ -236,12 +227,12 @@ def _format_native_types(self, na_rep=u'NaT', date_format=None, **kwargs):
     # -------------------------------------------------------------------
     # Wrapping TimedeltaArray
 
-    days = wrap_field_accessor(TimedeltaArrayMixin.days)
-    seconds = wrap_field_accessor(TimedeltaArrayMixin.seconds)
-    microseconds = wrap_field_accessor(TimedeltaArrayMixin.microseconds)
-    nanoseconds = wrap_field_accessor(TimedeltaArrayMixin.nanoseconds)
+    days = wrap_field_accessor(TimedeltaArray.days)
+    seconds = wrap_field_accessor(TimedeltaArray.seconds)
+    microseconds = wrap_field_accessor(TimedeltaArray.microseconds)
+    nanoseconds = wrap_field_accessor(TimedeltaArray.nanoseconds)
 
-    total_seconds = wrap_array_method(TimedeltaArrayMixin.total_seconds, True)
+    total_seconds = wrap_array_method(TimedeltaArray.total_seconds, True)
 
     # -------------------------------------------------------------------
 
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 5ba99a48e34ad..bb4022c9cac9a 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -4,7 +4,8 @@
 
 import pandas as pd
 from pandas.core.arrays import (
-    DatetimeArrayMixin, PeriodArray, TimedeltaArrayMixin)
+    DatetimeArrayMixin as DatetimeArray, PeriodArray,
+    TimedeltaArrayMixin as TimedeltaArray)
 import pandas.util.testing as tm
 
 
@@ -61,7 +62,7 @@ def test_array_object_dtype(self, tz_naive_fixture):
         # GH#23524
         tz = tz_naive_fixture
         dti = pd.date_range('2016-01-01', periods=3, tz=tz)
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
 
         expected = np.array(list(dti))
 
@@ -76,7 +77,7 @@ def test_array(self, tz_naive_fixture):
         # GH#23524
         tz = tz_naive_fixture
         dti = pd.date_range('2016-01-01', periods=3, tz=tz)
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
 
         expected = dti.asi8.view('M8[ns]')
         result = np.array(arr)
@@ -91,7 +92,7 @@ def test_array_i8_dtype(self, tz_naive_fixture):
         # GH#23524
         tz = tz_naive_fixture
         dti = pd.date_range('2016-01-01', periods=3, tz=tz)
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
 
         expected = dti.asi8
         result = np.array(arr, dtype='i8')
@@ -108,7 +109,7 @@ def test_array_i8_dtype(self, tz_naive_fixture):
     def test_from_dti(self, tz_naive_fixture):
         tz = tz_naive_fixture
         dti = pd.date_range('2016-01-01', periods=3, tz=tz)
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
         assert list(dti) == list(arr)
 
         # Check that Index.__new__ knows what to do with DatetimeArray
@@ -119,7 +120,7 @@ def test_from_dti(self, tz_naive_fixture):
     def test_astype_object(self, tz_naive_fixture):
         tz = tz_naive_fixture
         dti = pd.date_range('2016-01-01', periods=3, tz=tz)
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
         asobj = arr.astype('O')
         assert isinstance(asobj, np.ndarray)
         assert asobj.dtype == 'O'
@@ -129,11 +130,11 @@ def test_astype_object(self, tz_naive_fixture):
     def test_to_perioddelta(self, datetime_index, freqstr):
         # GH#23113
         dti = datetime_index
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
 
         expected = dti.to_perioddelta(freq=freqstr)
         result = arr.to_perioddelta(freq=freqstr)
-        assert isinstance(result, TimedeltaArrayMixin)
+        assert isinstance(result, TimedeltaArray)
 
         # placeholder until these become actual EA subclasses and we can use
         #  an EA-specific tm.assert_ function
@@ -142,7 +143,7 @@ def test_to_perioddelta(self, datetime_index, freqstr):
     @pytest.mark.parametrize('freqstr', ['D', 'B', 'W', 'M', 'Q', 'Y'])
     def test_to_period(self, datetime_index, freqstr):
         dti = datetime_index
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
 
         expected = dti.to_period(freq=freqstr)
         result = arr.to_period(freq=freqstr)
@@ -156,7 +157,7 @@ def test_to_period(self, datetime_index, freqstr):
     def test_bool_properties(self, datetime_index, propname):
         # in this case _bool_ops is just `is_leap_year`
         dti = datetime_index
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
         assert dti.freq == arr.freq
 
         result = getattr(arr, propname)
@@ -167,7 +168,7 @@ def test_bool_properties(self, datetime_index, propname):
     @pytest.mark.parametrize('propname', pd.DatetimeIndex._field_ops)
     def test_int_properties(self, datetime_index, propname):
         dti = datetime_index
-        arr = DatetimeArrayMixin(dti)
+        arr = DatetimeArray(dti)
 
         result = getattr(arr, propname)
         expected = np.array(getattr(dti, propname), dtype=result.dtype)
@@ -178,7 +179,7 @@ def test_int_properties(self, datetime_index, propname):
 class TestTimedeltaArray(object):
     def test_from_tdi(self):
         tdi = pd.TimedeltaIndex(['1 Day', '3 Hours'])
-        arr = TimedeltaArrayMixin(tdi)
+        arr = TimedeltaArray(tdi)
         assert list(arr) == list(tdi)
 
         # Check that Index.__new__ knows what to do with TimedeltaArray
@@ -188,7 +189,7 @@ def test_from_tdi(self):
 
     def test_astype_object(self):
         tdi = pd.TimedeltaIndex(['1 Day', '3 Hours'])
-        arr = TimedeltaArrayMixin(tdi)
+        arr = TimedeltaArray(tdi)
         asobj = arr.astype('O')
         assert isinstance(asobj, np.ndarray)
         assert asobj.dtype == 'O'
@@ -196,7 +197,7 @@ def test_astype_object(self):
 
     def test_to_pytimedelta(self, timedelta_index):
         tdi = timedelta_index
-        arr = TimedeltaArrayMixin(tdi)
+        arr = TimedeltaArray(tdi)
 
         expected = tdi.to_pytimedelta()
         result = arr.to_pytimedelta()
@@ -205,7 +206,7 @@ def test_to_pytimedelta(self, timedelta_index):
 
     def test_total_seconds(self, timedelta_index):
         tdi = timedelta_index
-        arr = TimedeltaArrayMixin(tdi)
+        arr = TimedeltaArray(tdi)
 
         expected = tdi.total_seconds()
         result = arr.total_seconds()
@@ -215,7 +216,7 @@ def test_total_seconds(self, timedelta_index):
     @pytest.mark.parametrize('propname', pd.TimedeltaIndex._field_ops)
     def test_int_properties(self, timedelta_index, propname):
         tdi = timedelta_index
-        arr = TimedeltaArrayMixin(tdi)
+        arr = TimedeltaArray(tdi)
 
         result = getattr(arr, propname)
         expected = np.array(getattr(tdi, propname), dtype=result.dtype)
@@ -248,9 +249,9 @@ def test_to_timestamp(self, how, period_index):
         pi = period_index
         arr = PeriodArray(pi)
 
-        expected = DatetimeArrayMixin(pi.to_timestamp(how=how))
+        expected = DatetimeArray(pi.to_timestamp(how=how))
         result = arr.to_timestamp(how=how)
-        assert isinstance(result, DatetimeArrayMixin)
+        assert isinstance(result, DatetimeArray)
 
         # placeholder until these become actual EA subclasses and we can use
         #  an EA-specific tm.assert_ function
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index a15295cfbd81a..2b630b98b69a2 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """
 Tests for DatetimeArray
 """
diff --git a/pandas/tests/arrays/test_period.py b/pandas/tests/arrays/test_period.py
index 95a1d1781456c..63b34db13705e 100644
--- a/pandas/tests/arrays/test_period.py
+++ b/pandas/tests/arrays/test_period.py
@@ -190,7 +190,7 @@ def test_setitem_raises_type():
 # ----------------------------------------------------------------------------
 # Ops
 
-def tet_sub_period():
+def test_sub_period():
     arr = period_array(['2000', '2001'], freq='D')
     other = pd.Period("2000", freq="M")
     with pytest.raises(IncompatibleFrequency, match="freq"):
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
new file mode 100644
index 0000000000000..3ff807daeeab9
--- /dev/null
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+
+class TestTimedeltaArray(object):
+    pass
diff --git a/setup.cfg b/setup.cfg
index 2e07182196d5b..9f5384170a245 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -120,9 +120,6 @@ skip=
     pandas/core/indexes/numeric.py,
     pandas/core/indexes/interval.py,
     pandas/core/indexes/multi.py,
-    pandas/core/indexes/timedeltas.py,
-    pandas/core/indexes/datetimelike.py,
-    pandas/core/indexes/datetimes.py,
     pandas/core/indexes/base.py,
     pandas/core/indexes/accessors.py,
     pandas/core/indexes/period.py,