REF: Simplify Datetimelike constructor dispatching

pandas/core/arrays/datetimelike.py

@@ -11,6 +11,7 @@
 from pandas._libs.tslibs.period import (
     Period, DIFFERENT_FREQ_INDEX, IncompatibleFrequency)
 
+from pandas.util._decorators import deprecate_kwarg
 from pandas.errors import NullFrequencyError, PerformanceWarning
 from pandas import compat
 
@@ -39,7 +40,6 @@
 from pandas.core.algorithms import checked_add_with_arr
 
 from .base import ExtensionOpsMixin
-from pandas.util._decorators import deprecate_kwarg
 
 
 def _make_comparison_op(cls, op):
@@ -143,6 +143,10 @@ def asi8(self):
     # ------------------------------------------------------------------
     # Array-like Methods
 
+    @property
+    def ndim(self):
+        return len(self.shape)
+
     @property
     def shape(self):
         return (len(self),)
@@ -151,6 +155,10 @@ def shape(self):
     def size(self):
         return np.prod(self.shape)
 
+    @property
+    def nbytes(self):
+        return self._ndarray_values.nbytes
+
     def __len__(self):
         return len(self._data)
 
@@ -211,6 +219,10 @@ def astype(self, dtype, copy=True):
     # ------------------------------------------------------------------
     # Null Handling
 
+    def isna(self):
+        # EA Interface
+        return self._isnan
+
     @property  # NB: override with cache_readonly in immutable subclasses
     def _isnan(self):
         """ return if each value is nan"""
@@ -332,6 +344,10 @@ def _validate_frequency(cls, index, freq, **kwargs):
             # Frequency validation is not meaningful for Period Array/Index
             return None
 
+        # DatetimeArray may pass `ambiguous`, nothing else will be accepted
+        # by cls._generate_range below
+        assert all(key == 'ambiguous' for key in kwargs)
+
         inferred = index.inferred_freq
         if index.size == 0 or inferred == freq.freqstr:
             return None
@@ -590,9 +606,12 @@ def _time_shift(self, periods, freq=None):
 
         start = self[0] + periods * self.freq
         end = self[-1] + periods * self.freq
-        attribs = self._get_attributes_dict()
+
+        # Note: in the DatetimeTZ case, _generate_range will infer the
+        #  appropriate timezone from `start` and `end`, so tz does not need
+        #  to be passed explicitly.
         return self._generate_range(start=start, end=end, periods=None,
-                                    **attribs)
+                                    freq=self.freq)
 
     @classmethod
     def _add_datetimelike_methods(cls):

pandas/core/arrays/period.py

@@ -18,6 +18,7 @@
 
 from pandas.core.dtypes.common import (
     is_integer_dtype, is_float_dtype, is_period_dtype,
+    is_object_dtype,
     is_datetime64_dtype)
 from pandas.core.dtypes.dtypes import PeriodDtype
 from pandas.core.dtypes.generic import ABCSeries
@@ -121,18 +122,30 @@ def freq(self, value):
 
     _attributes = ["freq"]
 
-    def __new__(cls, values, freq=None, **kwargs):
+    def __new__(cls, values, freq=None, dtype=None, **kwargs):
+
+        if freq is not None:
+            # coerce freq to freq object, otherwise it can be coerced
+            # elementwise, which is slow
+            freq = Period._maybe_convert_freq(freq)
+
+        freq = dtl.validate_dtype_freq(dtype, freq)
+
         if is_period_dtype(values):
             # PeriodArray, PeriodIndex
-            if freq is not None and values.freq != freq:
-                raise IncompatibleFrequency(freq, values.freq)
-            freq = values.freq
+            freq = dtl.validate_dtype_freq(values.dtype, freq)
             values = values.asi8
 
         elif is_datetime64_dtype(values):
-            # TODO: what if it has tz?
             values = dt64arr_to_periodarr(values, freq)
 
+        elif is_object_dtype(values) or isinstance(values, (list, tuple)):
+            # e.g. array([Period(...), Period(...), NaT])
+            values = np.array(values, dtype=object)
+            if freq is None:
+                freq = libperiod.extract_freq(values)
+            values = libperiod.extract_ordinals(values, freq)
+
         return cls._simple_new(values, freq=freq, **kwargs)
 
     @classmethod
@@ -175,11 +188,13 @@ def _from_ordinals(cls, values, freq=None, **kwargs):
 
     @classmethod
     def _generate_range(cls, start, end, periods, freq, fields):
+        periods = dtl.validate_periods(periods)
+
         if freq is not None:
             freq = Period._maybe_convert_freq(freq)
 
         field_count = len(fields)
-        if com.count_not_none(start, end) > 0:
+        if start is not None or end is not None:
             if field_count > 0:
                 raise ValueError('Can either instantiate from fields '
                                  'or endpoints, but not both')

pandas/core/arrays/timedeltas.py

@@ -126,8 +126,7 @@ def _simple_new(cls, values, freq=None, **kwargs):
         result._freq = freq
         return result
 
-    def __new__(cls, values, freq=None, start=None, end=None, periods=None,
-                closed=None):
+    def __new__(cls, values, freq=None):
 
         freq, freq_infer = dtl.maybe_infer_freq(freq)
 
@@ -140,8 +139,7 @@ def __new__(cls, values, freq=None, start=None, end=None, periods=None,
         return result
 
     @classmethod
-    def _generate_range(cls, start, end, periods, freq, closed=None, **kwargs):
-        # **kwargs are for compat with TimedeltaIndex, which includes `name`
+    def _generate_range(cls, start, end, periods, freq, closed=None):
 
         periods = dtl.validate_periods(periods)
         if freq is None and any(x is None for x in [periods, start, end]):
@@ -167,10 +165,9 @@ def _generate_range(cls, start, end, periods, freq, closed=None, **kwargs):
 
         if freq is not None:
             index = _generate_regular_range(start, end, periods, freq)
-            index = cls._simple_new(index, freq=freq, **kwargs)
+            index = cls._simple_new(index, freq=freq)
         else:
             index = np.linspace(start.value, end.value, periods).astype('i8')
-            # TODO: shouldn't we pass `name` here?  (via **kwargs)
             index = cls._simple_new(index, freq=freq)
 
         if not left_closed:

pandas/core/indexes/datetimelike.py

@@ -430,6 +430,7 @@ def min(self, axis=None, *args, **kwargs):
         --------
         numpy.ndarray.min
         """
+        _validate_minmax_axis(axis)
         nv.validate_min(args, kwargs)
 
         try:
@@ -458,6 +459,7 @@ def argmin(self, axis=None, *args, **kwargs):
         --------
         numpy.ndarray.argmin
         """
+        _validate_minmax_axis(axis)
         nv.validate_argmin(args, kwargs)
 
         i8 = self.asi8
@@ -478,6 +480,7 @@ def max(self, axis=None, *args, **kwargs):
         --------
         numpy.ndarray.max
         """
+        _validate_minmax_axis(axis)
         nv.validate_max(args, kwargs)
 
         try:
@@ -506,6 +509,7 @@ def argmax(self, axis=None, *args, **kwargs):
         --------
         numpy.ndarray.argmax
         """
+        _validate_minmax_axis(axis)
         nv.validate_argmax(args, kwargs)
 
         i8 = self.asi8
@@ -699,6 +703,31 @@ def astype(self, dtype, copy=True):
             raise TypeError(msg.format(name=type(self).__name__, dtype=dtype))
         return super(DatetimeIndexOpsMixin, self).astype(dtype, copy=copy)
 
+    @Appender(DatetimeLikeArrayMixin._time_shift.__doc__)
+    def _time_shift(self, periods, freq=None):
+        result = DatetimeLikeArrayMixin._time_shift(self, periods, freq=freq)
+        result.name = self.name
+        return result
+
+
+def _validate_minmax_axis(axis):
+    """
+    Ensure that the axis argument passed to min, max, argmin, or argmax is
+    zero or None, as otherwise it will be incorrectly ignored.
+
+    Parameters
+    ----------
+    axis : int or None
+
+    Raises
+    ------
+    ValueError
+    """
+    ndim = 1  # hard-coded for Index
+    if axis is not None and axis >= ndim:
+        raise ValueError("`axis` must be fewer than the number of "
+                         "dimensions ({ndim})".format(ndim=ndim))
+
 
 def _ensure_datetimelike_to_i8(other, to_utc=False):
     """

pandas/core/indexes/datetimes.py

@@ -241,9 +241,11 @@ def __new__(cls, data=None,
 
         if data is None:
             # TODO: Remove this block and associated kwargs; GH#20535
-            return cls._generate_range(start, end, periods, name, freq,
-                                       tz=tz, normalize=normalize,
-                                       closed=closed, ambiguous=ambiguous)
+            result = cls._generate_range(start, end, periods,
+                                         freq=freq, tz=tz, normalize=normalize,
+                                         closed=closed, ambiguous=ambiguous)
+            result.name = name
+            return result
 
         if not isinstance(data, (np.ndarray, Index, ABCSeries,
                                  DatetimeArrayMixin)):
@@ -315,17 +317,6 @@ def __new__(cls, data=None,
 
         return subarr._deepcopy_if_needed(ref_to_data, copy)
 
-    @classmethod
-    @Appender(DatetimeArrayMixin._generate_range.__doc__)
-    def _generate_range(cls, start, end, periods, name=None, freq=None,
-                        tz=None, normalize=False, ambiguous='raise',
-                        closed=None):
-        out = super(DatetimeIndex, cls)._generate_range(
-            start, end, periods, freq,
-            tz=tz, normalize=normalize, ambiguous=ambiguous, closed=closed)
-        out.name = name
-        return out
-
     @classmethod
     def _use_cached_range(cls, freq, _normalized, start, end):
         # Note: This always returns False
@@ -389,27 +380,6 @@ def tz(self, value):
         raise AttributeError("Cannot directly set timezone. Use tz_localize() "
                              "or tz_convert() as appropriate")
 
-    @property
-    def size(self):
-        # TODO: Remove this when we have a DatetimeTZArray
-        # Necessary to avoid recursion error since DTI._values is a DTI
-        # for TZ-aware
-        return self._ndarray_values.size
-
-    @property
-    def shape(self):
-        # TODO: Remove this when we have a DatetimeTZArray
-        # Necessary to avoid recursion error since DTI._values is a DTI
-        # for TZ-aware
-        return self._ndarray_values.shape
-
-    @property
-    def nbytes(self):
-        # TODO: Remove this when we have a DatetimeTZArray
-        # Necessary to avoid recursion error since DTI._values is a DTI
-        # for TZ-aware
-        return self._ndarray_values.nbytes
-
     @classmethod
     def _cached_range(cls, start=None, end=None, periods=None, freq=None,
                       name=None):

pandas/core/indexes/period.py

@@ -165,8 +165,6 @@ def __new__(cls, data=None, ordinal=None, freq=None, start=None, end=None,
             raise TypeError('__new__() got an unexpected keyword argument {}'.
                             format(list(set(fields) - valid_field_set)[0]))
 
-        periods = dtl.validate_periods(periods)
-
         if name is None and hasattr(data, 'name'):
             name = data.name
 
@@ -314,16 +312,6 @@ def __array_wrap__(self, result, context=None):
         # cannot pass _simple_new as it is
         return self._shallow_copy(result, freq=self.freq, name=self.name)
 
-    @property
-    def size(self):
-        # Avoid materializing self._values
-        return self._ndarray_values.size
-
-    @property
-    def shape(self):
-        # Avoid materializing self._values
-        return self._ndarray_values.shape
-
     @property
     def _formatter_func(self):
         return lambda x: "'%s'" % x

pandas/core/indexes/timedeltas.py

@@ -147,12 +147,10 @@ def __new__(cls, data=None, unit=None, freq=None, start=None, end=None,
 
         if data is None:
             # TODO: Remove this block and associated kwargs; GH#20535
-            if freq is None and com._any_none(periods, start, end):
-                raise ValueError('Must provide freq argument if no data is '
-                                 'supplied')
-            periods = dtl.validate_periods(periods)
-            return cls._generate_range(start, end, periods, name, freq,
-                                       closed=closed)
+            out = cls._generate_range(start, end, periods,
+                                      freq=freq, closed=closed)
+            out.name = name
+            return out
 
         if unit is not None:
             data = to_timedelta(data, unit=unit, box=False)
@@ -181,16 +179,6 @@ def __new__(cls, data=None, unit=None, freq=None, start=None, end=None,
 
         return subarr
 
-    @classmethod
-    def _generate_range(cls, start, end, periods,
-                        name=None, freq=None, closed=None):
-        # TimedeltaArray gets `name` via **kwargs, so we need to explicitly
-        # override it if name is passed as a positional argument
-        return super(TimedeltaIndex, cls)._generate_range(start, end,
-                                                          periods, freq,
-                                                          name=name,
-                                                          closed=closed)
-
     @classmethod
     def _simple_new(cls, values, name=None, freq=None, **kwargs):
         result = super(TimedeltaIndex, cls)._simple_new(values, freq, **kwargs)

pandas/io/pytables.py

@@ -2476,8 +2476,7 @@ def _get_index_factory(self, klass):
         if klass == DatetimeIndex:
             def f(values, freq=None, tz=None):
                 # data are already in UTC, localize and convert if tz present
-                result = DatetimeIndex._simple_new(values.values, name=None,
-                                                   freq=freq)
+                result = DatetimeIndex(values.values, name=None, freq=freq)
                 if tz is not None:
                     result = result.tz_localize('UTC').tz_convert(tz)
                 return result