dont inherit from DatetimeArray

pandas-dev · TomAugspurger · Dec 29, 2018 · Dec 21, 2018 · Dec 21, 2018 · Dec 21, 2018
commit ea3965d6406757aae714baf2d35c0d048635eed0
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
@@ -88,8 +88,7 @@ class DatelikeOps(object):
 
     def strftime(self, date_format):
         from pandas import Index
-        return Index(self.format(date_format=date_format),
-                     dtype=compat.text_type)
+        return Index(self._format_native_types(date_format=date_format))
     strftime.__doc__ = """
     Convert to Index using specified date_format.
 
@@ -1263,7 +1262,8 @@ def _ensure_datetimelike_to_i8(other, to_utc=False):
 
     if lib.is_scalar(other) and isna(other):
         return iNaT
-    elif isinstance(other, (PeriodArray, ABCIndexClass)):
+    elif isinstance(other, (PeriodArray, ABCIndexClass,
+                            DatetimeLikeArrayMixin)):
         # convert tz if needed
         if getattr(other, 'tz', None) is not None:
             if to_utc:

diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
@@ -18,7 +18,7 @@
     is_datetime64tz_dtype, is_extension_type, is_float_dtype, is_int64_dtype,
     is_object_dtype, is_period_dtype, is_string_dtype, is_timedelta64_dtype)
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
-from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries
+from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries, ABCDataFrame
 from pandas.core.dtypes.missing import isna
 
 from pandas.core import ops
@@ -113,6 +113,8 @@ def wrapper(self, other):
         elif lib.is_scalar(other):
             return ops.invalid_comparison(self, other, op)
         else:
+            # TODO: figure out why the is_object_dtpye check is needed,
+            #  without we fail to raise on tzawareness_compat
             if isinstance(other, list) or is_object_dtype(other):
                 try:
                     other = type(self)(other)
@@ -471,6 +473,18 @@ def _validate_fill_value(self, fill_value):
                              "Got '{got}'.".format(got=fill_value))
         return fill_value
 
+    # -----------------------------------------------------------------
+    # Rendering Methods
+
+    def _format_native_types(self, na_rep=u'NaT', date_format=None, **kwargs):
+        from pandas.io.formats.format import _get_format_datetime64_from_values
+        fmt = _get_format_datetime64_from_values(self, date_forma
10000
t)
+
+        return tslib.format_array_from_datetime(self.asi8,
+                                                tz=self.tz,
+                                                format=fmt,
+                                                na_rep=na_rep)
+
     # -----------------------------------------------------------------
     # Comparison Methods
 

diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
@@ -75,6 +75,7 @@ def _td_array_cmp(cls, op):
     meth = getattr(dtl.DatetimeLikeArrayMixin, opname)
 
     def wrapper(self, other):
+
         if _is_convertible_to_td(other) or other is NaT:
             try:
                 other = _to_m8(other)

diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
@@ -20,6 +20,7 @@
 import pandas.core.dtypes.concat as _concat
 from pandas.core.dtypes.missing import isna
 
+from pandas.core.arrays import ExtensionOpsMixin
 from pandas.core.arrays.datetimes import (
     DatetimeArrayMixin as DatetimeArray, _to_m8)
 from pandas.core.base import _shared_docs
@@ -61,7 +62,7 @@ def _new_DatetimeIndex(cls, d):
     return result
 
 
-class DatetimeIndex(DatetimeArray, DatetimeIndexOpsMixin, Int64Index):
+class DatetimeIndex(DatetimeIndexOpsMixin, Int64Index, ExtensionOpsMixin):
     """
     Immutable ndarray of datetime64 data, represented internally as int64, and
     which can be boxed to Timestamp objects that are subclasses of datetime and
@@ -205,6 +206,7 @@ def _join_i8_wrapper(joinf, **kwargs):
     _object_ops = DatetimeArray._object_ops
     _field_ops = DatetimeArray._field_ops
     _datetimelike_ops = DatetimeArray._datetimelike_ops
+    _datetimelike_methods = DatetimeArray._datetimelike_methods
 
     # --------------------------------------------------------------------
     # Constructors
@@ -227,11 +229,12 @@ def __new__(cls, data=None,
                           "endpoints is deprecated.  Use "
                           "`pandas.date_range` instead.",
                           FutureWarning, stacklevel=2)
-            result = cls._generate_range(start, end, periods,
-                                         freq=freq, tz=tz, normalize=normalize,
-                                         closed=closed, ambiguous=ambiguous)
-            result.name = name
-            return result
+            dtarr = DatetimeArray._generate_range(
+                start, end, periods,
+                freq=freq, tz=tz, normalize=normalize,
+                closed=closed, ambiguous=ambiguous)
+            return cls._simple_new(
+                dtarr._data, freq=dtarr.freq, tz=dtarr.tz, name=name)
 
         if is_scalar(data):
             raise TypeError("{cls}() must be called with a "
@@ -267,7 +270,11 @@ def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
         # DatetimeArray._simple_new will accept either i8 or M8[ns] dtypes
         assert isinstance(values, np.ndarray), type(values)
 
-        result = super(DatetimeIndex, cls)._simple_new(values, freq, tz)
+        dtarr = DatetimeArray._simple_new(values, freq=freq, tz=tz)
+        result = object.__new__(cls)
+        result._data = dtarr._data
+        result._freq = dtarr.freq
+        result._tz = dtarr.tz
         result.name = name
         # For groupby perf. See note in indexes/base about _index_data
         result._index_data = result._data
@@ -281,6 +288,10 @@ def _eadata(self):
         return DatetimeArray._simple_new(self._data, tz=self.tz,
                                          freq=self.freq)
 
+    @property
+    def dtype(self):
+        return self._eadata.dtype
+
     @property
     def _values(self):
         # tz-naive -> ndarray
@@ -301,6 +312,8 @@ def tz(self, value):
         raise AttributeError("Cannot directly set timezone. Use tz_localize() "
                              "or tz_convert() as appropriate")
 
+    tzinfo = tz
+
     @property
     def size(self):
         # TODO: Remove this when we have a DatetimeTZArray
@@ -625,7 +638,7 @@ def astype(self, dtype, copy=True):
     def _get_time_micros(self):
         values = self.asi8
         if self.tz is not None and not timezones.is_utc(self.tz):
-            values = self._local_timestamps()
+            values = self._eadata._local_timestamps()
         return fields.get_time_micros(values)
 
     def to_series(self, keep_tz=None, index=None, name=None):
@@ -1138,6 +1151,97 @@ def slice_indexer(self, start=None, end=None, step=None, kind=None):
     month_name = wrap_array_method(DatetimeArray.month_name, True)
     day_name = wrap_array_method(DatetimeArray.day_name, True)
 
+    @property
+    def date(self):
+        return self._eadata.date
+
+    @property
+    def time(self):
+        return self._eadata.time
+
+    @property
+    def timetz(self):
+        return self._eadata.timetz
+
+    def strftime(self, date_format):
+        return self._eadata.strftime(date_format)
+
+    def round(self, freq, ambiguous='raise', nonexistent='raise'):
+        result = self._eadata.round(
+            freq, ambiguous=ambiguous, nonexistent=nonexistent)
+        return type(self)._simple_new(
+            result._data, freq=result.freq, tz=result.tz)
+
+    def floor(self, freq, ambiguous='raise', nonexistent='raise'):
+        result = self._eadata.floor(
+            freq, ambiguous=ambiguous, nonexistent=nonexistent)
+        return type(self)._simple_new(
+            result._data, freq=result.freq, tz=result.tz)
+
+    def ceil(self, freq, ambiguous='raise', nonexistent='raise'):
+        result = self._eadata.ceil(
+            freq, ambiguous=ambiguous, nonexistent=nonexistent)
+        return type(self)._simple_new(
+            result._data, freq=result.freq, tz=result.tz)
+
+    @property
+    def offset(self):
+        """
+        get/set the frequency of the instance
+        """
+        msg = ('{cls}.offset has been deprecated and will be removed '
+               'in a future version; use {cls}.freq instead.'
+               .format(cls=type(self).__name__))
+        warnings.warn(msg, FutureWarning, stacklevel=2)
+        return self.freq
+
+    @offset.setter
+    def offset(self, value):
+        """
+        get/set the frequency of the instance
+        """
+        msg = ('{cls}.offset has been deprecated and will be removed '
+               'in a future version; use {cls}.freq instead.'
+               .format(cls=type(self).__name__))
+        warnings.warn(msg, FutureWarning, stacklevel=2)
+        self.freq = value
+
+    @property
+    def freq(self):
+        return self._freq
+
+    @freq.setter
+    def freq(self, value):
+        if value is not None:
+            # let DatetimeArray to validation
+            self._eadata.freq = value
+
+        self._freq = to_offset(value)
+
+    def __getitem__(self, key):
+        result = self._eadata.__getitem__(key)
+        if is_scalar(result):
+            return result
+        elif result.ndim > 1:
+            # To support MPL which performs slicing with 2 dim
+            # even though it only has 1 dim by definition
+            assert isinstance(result, np.ndarray), result
+            return result
+        return type(self)(result, name=self.name)
+
+    def _has_same_tz(self, other):
+        return self._eadata._has_same_tz(other)
+
+    @property
+    def _box_func(self):
+        return lambda x: Timestamp(x, tz=self.tz)
+
+    def __array__(self, dtype=None):
+        return self._eadata.__array__(dtype=dtype)
+
+    def to_pydatetime(self):
+        return self._eadata.to_pydatetime()
+
     # --------------------------------------------------------------------
 
     @Substitution(klass='DatetimeIndex')
@@ -1475,13 +1579,12 @@ def date_range(start=None, end=None, periods=None, freq=None, tz=None,
     if freq is None and com._any_none(periods, start, end):
         freq = 'D'
 
-    result = DatetimeIndex._generate_range(
+    dtarr = DatetimeArray._generate_range(
         start=start, end=end, periods=periods,
         freq=freq, tz=tz, normalize=normalize,
         closed=closed, **kwargs)
-
-    result.name = name
-    return result
+    return DatetimeIndex._simple_new(
+        dtarr._data, tz=dtarr.tz, freq=dtarr.freq, name=name)
 
 
 def bdate_range(start=None, end=None, periods=None, freq='B', tz=None,