fixups

Author: TomAugspurger

pandas/core/arrays/datetimelike.py

@@ -297,8 +297,6 @@ class TimelikeOps(object):
     )
 
     def _round(self, freq, mode, ambiguous, nonexistent):
-        from pandas.core.indexes.datetimelike import _ensure_datetimelike_to_i8
-
         # round the local times
         values = _ensure_datetimelike_to_i8(self)
         result = round_nsint64(values, mode, freq)
@@ -335,7 +333,6 @@ class DatetimeLikeArrayMixin(AttributesMixin,
     Assumes that __new__/__init__ defines:
         _data
         _freq
-        _scalar_type : {Timestamp, Timedelta, Period}
 
     and that the inheriting class has methods:
         _generate_range
@@ -476,10 +473,9 @@ def __setitem__(
         # https://mypy.readthedocs.io/en/latest/generics.html
 
         # n.b. This is moved from PeriodArray with the following changes
-        # 1. added is_slice check (bug on master)
-        # 2. changed dedicated ctor (period_array) to _from_sequence
-        # 3. Changed freq checking to use `_check_compatible_with`
-        # 4. Handle `value=iNaT` (may be able to revert. Check internals.)
+        # 1. changed dedicated ctor (period_array) to _from_sequence
+        # 2. Changed freq checking to use `_check_compatible_with`
+        # 3. Handle `value=iNaT` (may be able to revert. Check internals.)
         if is_list_like(value):
             is_slice = isinstance(key, slice)
             if (not is_slice

pandas/core/arrays/datetimes.py

@@ -199,7 +199,6 @@ class DatetimeArrayMixin(dtl.DatetimeLikeArrayMixin,
     # Constructors
 
     _attributes = ["freq", "tz"]
-    _tz = None
     _freq = None
 
     @classmethod
@@ -222,7 +221,6 @@ def _simple_new(cls, values, freq=None, tz=None):
         result._freq = freq
         tz = timezones.maybe_get_tz(tz)
         if tz:
-            result._tz = timezones.tz_standardize(tz)
             result._dtype = DatetimeTZDtype('ns', tz)
         else:
             result._dtype = values.dtype  # M8[ns]
@@ -392,7 +390,7 @@ def tz(self):
         Return timezone.
         """
         # GH 18595
-        return self._tz
+        return getattr(self.dtype, 'tz', None)
 
     @tz.setter
     def tz(self, value):

pandas/core/arrays/period.py

@@ -17,7 +17,7 @@
 from pandas.core.dtypes.common import (
     _TD_DTYPE, ensure_object, is_array_like, is_datetime64_dtype,
     is_datetime64_ns_dtype, is_datetime64tz_dtype, is_float_dtype,
-    is_list_like, is_period_dtype, pandas_dtype)
+    is_period_dtype, pandas_dtype)
 from pandas.core.dtypes.dtypes import PeriodDtype
 from pandas.core.dtypes.generic import ABCIndexClass, ABCPeriodIndex, ABCSeries
 from pandas.core.dtypes.missing import isna, notna
@@ -362,50 +362,6 @@ def _formatter(self, boxed=False):
             return str
         return "'{}'".format
 
-    def __setitem__(
-            self,
-            key,   # type: Union[int, Sequence[int], Sequence[bool], slice]
-            value  # type: Union[NaTType, Period, Sequence[Period]]
-    ):
-        # type: (...) -> None
-        # n.b. the type on `value` is a bit too restrictive.
-        # we also accept a sequence of stuff coercible to a PeriodArray
-        # by period_array, which includes things like ndarray[object],
-        # ndarray[datetime64ns]. I think ndarray[int] / ndarray[str] won't
-        # work, since the freq can't be inferred.
-        if is_list_like(value):
-            is_slice = isinstance(key, slice)
-            if (not is_slice
-                    and len(key) != len(value)
-                    and not com.is_bool_indexer(key)):
-                msg = ("shape mismatch: value array of length '{}' does not "
-                       "match indexing result of length '{}'.")
-                raise ValueError(msg.format(len(key), len(value)))
-            if not is_slice and len(key) == 0:
-                return
-
-            value = period_array(value)
-
-            if self.freqstr != value.freqstr:
-                msg = DIFFERENT_FREQ_INDEX.format(self.freqstr, value.freqstr)
-                raise IncompatibleFrequency(msg)
-
-            value = value.asi8
-        elif isinstance(value, Period):
-
-            if self.freqstr != value.freqstr:
-                msg = DIFFERENT_FREQ_INDEX.format(self.freqstr, value.freqstr)
-                raise IncompatibleFrequency(msg)
-
-            value = value.ordinal
-        elif isna(value):
-            value = iNaT
-        else:
-            msg = ("'value' should be a 'Period', 'NaT', or array of those. "
-                   "Got '{}' instead.".format(type(value).__name__))
-            raise TypeError(msg)
-        self._data[key] = value
-
     @Appender(dtl.DatetimeLikeArrayMixin._validate_fill_value.__doc__)
     def _validate_fill_value(self, fill_value):
         if isna(fill_value):

pandas/core/base.py

@@ -15,7 +15,7 @@
 from pandas.util._validators import validate_bool_kwarg
 
 from pandas.core.dtypes.common import (
-    is_datetime64_dtype, is_datetimelike, is_extension_array_dtype,
+    is_datetime64tz_dtype, is_datetimelike, is_extension_array_dtype,
     is_extension_type, is_list_like, is_object_dtype, is_scalar)
 from pandas.core.dtypes.generic import ABCDataFrame, ABCIndexClass, ABCSeries
 from pandas.core.dtypes.missing import isna
@@ -895,15 +895,10 @@ def to_numpy(self):
         >>> ser.to_numpy()
         array(['a', 'b', 'a'], dtype=object)
         """
-        if is_extension_array_dtype(self.dtype):
-            return np.asarray(self._values)
-        elif is_datetime64_dtype(self.dtype):
-            # This secondary `asarray` may be unavoidable, as long as
-            # we have
-            # 1. DatetimeArray-backed Index
-            # 2. `M8[ns]` dtype for tz-naive, DatetimeTZDtype for tz-aware.
-            return np.asarray(self._values)
-        return self._values
+        if is_datetime64tz_dtype(self.dtype):
+            # Ensure that timezones are preserved.
+            return np.asarray(self._values.astype(object))
+        return np.asarray(self._values)
 
     @property
     def _ndarray_values(self):

pandas/core/dtypes/concat.py

@@ -436,8 +436,8 @@ def _concat_datetime(to_concat, axis=0, typs=None):
             return _concat_datetimetz(to_concat)
 
     elif 'timedelta' in typs:
-        to_concat = [x.astype(np.int64, copy=False) for x in to_concat]
-        return _concatenate_2d(to_concat, axis=axis).view(_TD_DTYPE)
+        return _concatenate_2d([x.view(np.int64) for x in to_concat],
+                               axis=axis).view(_TD_DTYPE)
 
     elif any(typ.startswith('period') for typ in typs):
         assert len(typs) == 1
@@ -455,9 +455,7 @@ def _convert_datetimelike_to_object(x):
             x = np.asarray(x.astype(object))
         else:
             shape = x.shape
-            x = tslib.ints_to_pydatetime(x.astype(np.int64,
-                                                  copy=False).ravel(),
-                                         box="timestamp")
+            x = tslib.ints_to_pydatetime(x.view(np.int64).ravel(), box=True)
             x = x.reshape(shape)
 
     elif x.dtype == _TD_DTYPE:

pandas/core/generic.py

@@ -9658,7 +9658,7 @@ def describe_categorical_1d(data):
                 if is_datetime64_any_dtype(data):
                     tz = data.dt.tz
                     # astype for ndarray / datetimearray compat.
-                    asint = data.dropna()._values.astype('i8', copy=False)
+                    asint = data.dropna().values.view('i8')
                     top = Timestamp(top)
                     if top.tzinfo is not None and tz is not None:
                         # Don't tz_localize(None) if key is already tz-aware

pandas/tests/test_base.py

@@ -16,7 +16,10 @@
 from pandas import (Series, Index, DatetimeIndex, TimedeltaIndex,
                     PeriodIndex, Timedelta, IntervalIndex, Interval,
                     CategoricalIndex, Timestamp)
-from pandas.core.arrays import DatetimeArrayMixin as DatetimeArray
+from pandas.core.arrays import (
+    DatetimeArrayMixin as DatetimeArray,
+    TimedeltaArrayMixin as TimedeltaArray,
+)
 from pandas.compat import StringIO, PYPY, long
 from pandas.compat.numpy import np_array_datetime64_compat
 from pandas.core.accessor import PandasDelegate
@@ -1314,16 +1317,17 @@ def test_array_multiindex_raises():
     (DatetimeArray(np.array(['2000', '2001'], dtype='M8[ns]')),
      np.array(['2000', '2001'], dtype='M8[ns]')),
 
-    # tz-aware datetime
-    # XXX: On master, np.asarray(Series[datetime64[ns, tz]]) is
-    # an ndarray[datetime64[ns]] (normalized to UTC and tz dropped).
-    # Do we want to change that?
-    # Or do we want `.to_numpy()` to be inconsistent with asarray? (no!)
-    pytest.param(
-        DatetimeArray(np.array(['2000', '2000'], dtype='M8[ns]'),
-                      tz='US/Central'),
-        np.array([pd.Timestamp("2000", tz="US/Central")] * 2),
-        marks=pytest.mark.xfail(reason="np.asarray", strict=True))
+    # tz-aware stays tz`-aware
+    (DatetimeArray(np.array(['2000-01-01T06:00:00',
+                             '2000-01-02T06:00:00'],
+                            dtype='M8[ns]'),
+                   tz='US/Central'),
+     np.array([pd.Timestamp('2000-01-01', tz='US/Central'),
+               pd.Timestamp('2000-01-02', tz='US/Central')])),
+
+    # Timedelta
+    (TimedeltaArray([0, 3600000000000], freq='H'),
+     np.array([0, 3600000000000], dtype='m8[ns]')),
 ])
 @pytest.mark.parametrize('box', [pd.Series, pd.Index])
 def test_to_numpy(array, expected, box):