REF/ENH: Constructors for DatetimeArray/TimedeltaArray

pandas/core/arrays/datetimelike.py

@@ -888,6 +888,27 @@ def maybe_infer_freq(freq):
     return freq, freq_infer
 
 
+def maybe_define_freq(freq_infer, result):
+    """
+    If appropriate, infer the frequency of the given Datetime/Timedelta Array
+    and pin it to the object at the end of the construction.
+
+    Parameters
+    ----------
+    freq_infer : bool
+    result : DatetimeArray or TimedeltaArray
+
+    Notes
+    -----
+    This may alter `result` in-place, should only ever be called
+    from __new__/__init__.
+    """
+    if freq_infer:
+        inferred = result.inferred_freq
+        if inferred:
+            result.freq = frequencies.to_offset(inferred)
+
+
 def validate_tz_from_dtype(dtype, tz):
     """
     If the given dtype is a DatetimeTZDtype, extract the implied

pandas/core/arrays/datetimes.py

@@ -119,7 +119,8 @@ def wrapper(self, other):
             if isinstance(other, list):
                 # FIXME: This can break for object-dtype with mixed types
                 other = type(self)(other)
-            elif not isinstance(other, (np.ndarray, ABCIndexClass, ABCSeries)):
+            elif not isinstance(other, (np.ndarray, ABCIndexClass, ABCSeries,
+                                        DatetimeArrayMixin)):
                 # Following Timestamp convention, __eq__ is all-False
                 # and __ne__ is all True, others raise TypeError.
                 return ops.invalid_comparison(self, other, op)
@@ -170,6 +171,8 @@ class DatetimeArrayMixin(dtl.DatetimeLikeArrayMixin):
     # Constructors
 
     _attributes = ["freq", "tz"]
+    _freq = None
+    _tz = None
 
     @classmethod
     def _simple_new(cls, values, freq=None, tz=None, **kwargs):
@@ -193,11 +196,16 @@ def _simple_new(cls, values, freq=None, tz=None, **kwargs):
         result._tz = timezones.tz_standardize(tz)
         return result
 
-    def __new__(cls, values, freq=None, tz=None, dtype=None):
+    def __new__(cls, values, freq=None, tz=None, dtype=None, copy=False):
+        if isinstance(values, (list, tuple)) or is_object_dtype(values):
+            values = cls._from_sequence(values, copy=copy)
+            # TODO: Can we set copy=False here to avoid re-coping?
+
         if tz is None and hasattr(values, 'tz'):
-            # e.g. DatetimeIndex
+            # e.g. DatetimeArray, DatetimeIndex
             tz = values.tz
 
+        # TODO: what about if freq == 'infer'?
         if freq is None and hasattr(values, "freq"):
             # i.e. DatetimeArray, DatetimeIndex
             freq = values.freq
@@ -207,26 +215,46 @@ def __new__(cls, values, freq=None, tz=None, dtype=None):
         # if dtype has an embedded tz, capture it
         tz = dtl.validate_tz_from_dtype(dtype, tz)
 
-        if isinstance(values, DatetimeArrayMixin):
+        if lib.is_scalar(values):
+            raise ValueError('{cls}() must be called with a '
+                             'collection of some kind, {data} was passed'
+                             .format(cls=cls.__name__, data=repr(values)))
+        elif isinstance(values, ABCSeries):
+            # extract nanosecond unix timestamps
+            if tz is None:
+                # TODO: Try to do this in just one place
+                tz = values.dt.tz
+            values = np.array(values.view('i8'))
+        elif isinstance(values, DatetimeArrayMixin):
             # extract nanosecond unix timestamps
             values = values.asi8
+
         if values.dtype == 'i8':
             values = values.view('M8[ns]')
 
         assert isinstance(values, np.ndarray), type(values)
         assert is_datetime64_dtype(values)  # not yet assured nanosecond
-        values = conversion.ensure_datetime64ns(values, copy=False)
+        values = conversion.ensure_datetime64ns(values, copy=copy)
 
         result = cls._simple_new(values, freq=freq, tz=tz)
-        if freq_infer:
-            inferred = result.inferred_freq
-            if inferred:
-                result.freq = to_offset(inferred)
+        dtl.maybe_define_freq(freq_infer, result)
 
         # NB: Among other things not yet ported from the DatetimeIndex
         # constructor, this does not call _deepcopy_if_needed
         return result
 
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy=False):
+        # list, tuple, or object-dtype ndarray/Index
+        values = np.array(scalars, dtype=np.object_, copy=copy)
+
+        # TODO: See if we can decrease circularity
+        from pandas.core.tools.datetimes import to_datetime
+        values = to_datetime(values)
+
+        # pass dtype to constructor in order to convert timezone if necessary
+        return cls(values, dtype=dtype)
+
     @classmethod
     def _generate_range(cls, start, end, periods, freq, tz=None,
                         normalize=False, ambiguous='raise', closed=None):

pandas/core/arrays/period.py

@@ -165,7 +165,9 @@ class PeriodArray(dtl.DatetimeLikeArrayMixin, ExtensionArray):
 
     # --------------------------------------------------------------------
     # Constructors
-    def __init__(self, values, freq=None, copy=False):
+    def __init__(self, values, freq=None, dtype=None, copy=False):
+        freq = dtl.validate_dtype_freq(dtype, freq)
+
         if freq is not None:
             freq = Period._maybe_convert_freq(freq)
 

pandas/core/arrays/timedeltas.py

@@ -11,15 +11,14 @@
 from pandas import compat
 
 from pandas.core.dtypes.common import (
-    _TD_DTYPE, is_list_like)
+    _TD_DTYPE, is_list_like, is_object_dtype, is_timedelta64_dtype)
 from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import isna
 
 import pandas.core.common as com
 from pandas.core.algorithms import checked_add_with_arr
 
 from pandas.tseries.offsets import Tick
-from pandas.tseries.frequencies import to_offset
 
 from . import datetimelike as dtl
 
@@ -112,9 +111,7 @@ def dtype(self):
 
     @classmethod
     def _simple_new(cls, values, freq=None, dtype=_TD_DTYPE):
-        # `dtype` is passed by _shallow_copy in corner cases, should always
-        #  be timedelta64[ns] if present
-        assert dtype == _TD_DTYPE
+        _require_m8ns_dtype(dtype)
         assert isinstance(values, np.ndarray), type(values)
 
         if values.dtype == 'i8':
@@ -127,22 +124,44 @@ def _simple_new(cls, values, freq=None, dtype=_TD_DTYPE):
         result._freq = freq
         return result
 
-    def __new__(cls, values, freq=None):
+    def __new__(cls, values, freq=None, dtype=_TD_DTYPE, copy=False):
+        _require_m8ns_dtype(dtype)
+
+        if isinstance(values, (list, tuple)) or is_object_dtype(values):
+            values = cls._from_sequence(values, copy=copy)._data
+            # TODO: can we set copy=False to avoid re-copying?
 
         freq, freq_infer = dtl.maybe_infer_freq(freq)
 
-        values = np.array(values, copy=False)
-        if values.dtype == np.object_:
-            values = array_to_timedelta64(values)
+        if isinstance(values, TimedeltaArrayMixin):
+            if freq is None and values.freq is not None:
+                freq = values.freq
+                freq_infer = False
+            values = values._data
 
-        result = cls._simple_new(values, freq=freq)
-        if freq_infer:
-            inferred = result.inferred_freq
-            if inferred:
-                result.freq = to_offset(inferred)
+        values = np.array(values, copy=copy)
+
+        if values.dtype == 'i8':
+            pass
+        elif not is_timedelta64_dtype(values):
+            raise TypeError(values.dtype)
+        elif values.dtype != _TD_DTYPE:
+            # i.e. non-nano unit
+            # TODO: use tslibs.conversion func? watch out for overflows
+            values = values.astype(_TD_DTYPE)
 
+        result = cls._simple_new(values, freq=freq)
+        dtl.maybe_define_freq(freq_infer, result)
         return result
 
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=_TD_DTYPE, copy=False):
+        # list, tuple, or object-dtype ndarray/Index
+        values = np.array(scalars, dtype=np.object_, copy=copy)
+
+        result = array_to_timedelta64(values)
+        return cls(result, dtype=dtype)
+
     @classmethod
     def _generate_range(cls, start, end, periods, freq, closed=None):
 
@@ -413,3 +432,21 @@ def _generate_regular_range(start, end, periods, offset):
 
     data = np.arange(b, e, stride, dtype=np.int64)
     return data
+
+
+def _require_m8ns_dtype(dtype):
+    """
+    `dtype` is included in the constructor signature for consistency with
+    DatetimeArray and PeriodArray, but only timedelta64[ns] is considered
+    valid.  Raise if anything else is passed.
+
+    Parameters
+    ----------
+    dtype : dtype
+
+    Raises
+    ------
+    ValueError
+    """
+    if dtype != _TD_DTYPE:
+        raise ValueError("Only timedelta64[ns] dtype is valid.", dtype)

pandas/core/indexes/datetimes.py

@@ -182,7 +182,6 @@ class DatetimeIndex(DatetimeArrayMixin, DatelikeOps, TimelikeOps,
 
     """
     _resolution = cache_readonly(DatetimeArrayMixin._resolution.fget)
-    _shallow_copy = Index._shallow_copy
 
     _typ = 'datetimeindex'
     _join_precedence = 10
@@ -199,10 +198,11 @@ def _join_i8_wrapper(joinf, **kwargs):
 
     _engine_type = libindex.DatetimeEngine
 
-    tz = None
+    _tz = None
     _freq = None
     _comparables = ['name', 'freqstr', 'tz']
     _attributes = ['name', 'freq', 'tz']
+    timetuple = None
 
     # define my properties & methods for delegation
     _bool_ops = ['is_month_start', 'is_month_end',
@@ -226,6 +226,9 @@ def _join_i8_wrapper(joinf, **kwargs):
     _timezone = cache_readonly(DatetimeArrayMixin._timezone.fget)
     is_normalized = cache_readonly(DatetimeArrayMixin.is_normalized.fget)
 
+    # --------------------------------------------------------------------
+    # Constructors
+
     def __new__(cls, data=None,
                 freq=None, start=None, end=None, periods=None, tz=None,
                 normalize=False, closed=None, ambiguous='raise',
@@ -254,13 +257,13 @@ def __new__(cls, data=None,
             result.name = name
             return result
 
-        if not isinstance(data, (np.ndarray, Index, ABCSeries,
-                                 DatetimeArrayMixin)):
-            if is_scalar(data):
-                raise ValueError('DatetimeIndex() must be called with a '
-                                 'collection of some kind, %s was passed'
-                                 % repr(data))
-            # other iterable of some kind
+        if is_scalar(data):
+            raise ValueError('{cls}() must be called with a '
+                             'collection of some kind, {data} was passed'
+                             .format(cls=cls.__name__, data=repr(data)))
+
+        elif not isinstance(data, (np.ndarray, Index, ABCSeries,
+                                   DatetimeArrayMixin)):
             if not isinstance(data, (list, tuple)):
                 data = list(data)
             data = np.asarray(data, dtype='O')
@@ -280,16 +283,15 @@ def __new__(cls, data=None,
                 data = data.tz_localize(tz, ambiguous=ambiguous)
             else:
                 # the tz's must match
-                if str(tz) != str(data.tz):
+                if not timezones.tz_compare(tz, data.tz):
                     msg = ('data is already tz-aware {0}, unable to '
                            'set specified tz: {1}')
                     raise TypeError(msg.format(data.tz, tz))
 
-            subarr = data.values
-
             if freq is None:
                 freq = data.freq
                 verify_integrity = False
+            data = data._data
         elif issubclass(data.dtype.type, np.datetime64):
             if data.dtype != _NS_DTYPE:
                 data = conversion.ensure_datetime64ns(data)
@@ -298,14 +300,13 @@ def __new__(cls, data=None,
                 tz = timezones.maybe_get_tz(tz)
                 data = conversion.tz_localize_to_utc(data.view('i8'), tz,
                                                      ambiguous=ambiguous)
-            subarr = data.view(_NS_DTYPE)
         else:
             # must be integer dtype otherwise
             # assume this data are epoch timestamps
             if data.dtype != _INT64_DTYPE:
                 data = data.astype(np.int64, copy=False)
-            subarr = data.view(_NS_DTYPE)
 
+        subarr = data.view(_NS_DTYPE)
         assert isinstance(subarr, np.ndarray), type(subarr)
         assert subarr.dtype == 'M8[ns]', subarr.dtype
 
@@ -320,19 +321,9 @@ def __new__(cls, data=None,
             if freq is not None and not freq_infer:
                 cls._validate_frequency(subarr, freq, ambiguous=ambiguous)
 
-        if freq_infer:
-            inferred = subarr.inferred_freq
-            if inferred:
-                subarr.freq = to_offset(inferred)
-
+        dtl.maybe_define_freq(freq_infer, subarr)
         return subarr._deepcopy_if_needed(ref_to_data, copy)
 
-    def _convert_for_op(self, value):
-        """ Convert value to be insertable to ndarray """
-        if self._has_same_tz(value):
-            return _to_m8(value)
-        raise ValueError('Passed item and index have different timezone')
-
     @classmethod
     def _simple_new(cls, values, name=None, freq=None, tz=None,
                     dtype=None, **kwargs):
@@ -349,6 +340,8 @@ def _simple_new(cls, values, name=None, freq=None, tz=None,
         result._reset_identity()
         return result
 
+    # --------------------------------------------------------------------
+
     @property
     def _values(self):
         # tz-naive -> ndarray
@@ -400,6 +393,12 @@ def _is_dates_only(self):
         from pandas.io.formats.format import _is_dates_only
         return _is_dates_only(self.values) and self.tz is None
 
+    def _convert_for_op(self, value):
+        """ Convert value to be insertable to ndarray """
+        if self._has_same_tz(value):
+            return _to_m8(value)
+        raise ValueError('Passed item and index have different timezone')
+
     @property
     def _formatter_func(self):
         from pandas.io.formats.format import _get_format_datetime64