Fixups

* min / max
* astype
* clean

Author: TomAugspurger

pandas/core/arrays/datetimelike.py

@@ -10,7 +10,7 @@
     DIFFERENT_FREQ_INDEX, IncompatibleFrequency, Period)
 from pandas._libs.tslibs.timedeltas import Timedelta, delta_to_nanoseconds
 from pandas._libs.tslibs.timestamps import (
-    RoundTo, Timestamp, maybe_integer_op_deprecated, round_nsint64)
+    RoundTo, maybe_integer_op_deprecated, round_nsint64)
 import pandas.compat as compat
 from pandas.compat.numpy import function as nv
 from pandas.errors import (
@@ -29,7 +29,7 @@
 from pandas.core.dtypes.inference import is_array_like
 from pandas.core.dtypes.missing import isna
 
-from pandas.core import missing
+from pandas.core import missing, nanops
 from pandas.core.algorithms import (
     checked_add_with_arr, take, unique1d, value_counts)
 import pandas.core.common as com
@@ -72,8 +72,6 @@ def cmp_method(self, other):
 
 class AttributesMixin(object):
 
-    _scalar_types = (Period, Timestamp, Timedelta)
-
     @property
     def _attributes(self):
         # Inheriting subclass should implement _attributes as a list of strings
@@ -1098,7 +1096,7 @@ def _time_shift(self, periods, freq=None):
                 freq = frequencies.to_offset(freq)
             offset = periods * freq
             result = self + offset
-            if getattr(self, 'tz', None):
+            if hasattr(self, 'tz'):
                 result._dtype = DatetimeTZDtype(tz=self.tz)
             return result
 
@@ -1310,38 +1308,32 @@ def _evaluate_compare(self, other, op):
         result[mask] = filler
         return result
 
+    # --------------------------------------------------------------
+    # Reductions
+
     def _reduce(self, name, skipna=True, **kwargs):
         op = getattr(self, name, None)
         if op:
             return op(skipna=skipna)
         else:
-            return super()._reduce(name, skipna, **kwargs)
-
-    # --------------------------------------------------------------
-    # Reductions
-
-    def _values_for_reduction(self, skipna=True):
-        if skipna:
-            values = self[~self._isnan]
-        else:
-            values = self
-        return values.asi8
+            return super(DatetimeLikeArrayMixin, self)._reduce(
+                name, skipna, **kwargs
+            )
 
     def min(self, skipna=True):
-        # TODO: Deduplicate with Datetimelike.
-        # they get to take some shortcuts based on monotonicity.
-        i8 = self._values_for_reduction(skipna=skipna)
-        if len(i8):
-            return self._box_func(i8.min())
-        else:
+        result = nanops.nanmin(self.asi8, skipna=skipna, mask=self.isna())
+        if isna(result):
+            # Period._from_ordinal does not handle np.nan gracefully
             return NaT
+        return self._box_func(result)
 
     def max(self, skipna=True):
-        i8 = self._values_for_reduction(skipna=skipna)
-        if len(i8):
-            return self._box_func(i8.max())
-        else:
+        # TODO: skipna is broken with max.
+        result = nanops.nanmax(self.asi8, skipna=skipna, mask=self.isna())
+        if isna(result):
+            # Period._from_ordinal does not handle np.nan gracefully
             return NaT
+        return self._box_func(result)
 
 
 DatetimeLikeArrayMixin._add_comparison_ops()

pandas/tests/arrays/test_datetimelike.py

@@ -130,6 +130,13 @@ def test_scalar_from_string(self):
         result = arr._scalar_from_string(str(arr[0]))
         assert result == arr[0]
 
+    def test_reduce_invalid(self):
+        data = np.arange(10, dtype='i8')
+        arr = self.array_cls(data, freq='D')
+
+        with pytest.raises(TypeError, match='cannot perform'):
+            arr._reduce("not a method")
+
 
 class TestDatetimeArray(SharedTests):
     index_cls = pd.DatetimeIndex

pandas/tests/arrays/test_datetimes.py

@@ -120,3 +120,41 @@ def test_tz_dtype_matches(self):
         result, _, _ = sequence_to_dt64ns(
             arr, dtype=DatetimeTZDtype(tz="US/Central"))
         tm.assert_extension_array_equal(arr, result)
+
+
+class TestReductions(object):
+
+    @pytest.mark.parametrize("tz", [None, "US/Central"])
+    def test_min_max(self, tz):
+        arr = DatetimeArray._from_sequence([
+            '2000-01-03',
+            '2000-01-03',
+            'NaT',
+            '2000-01-02',
+            '2000-01-05',
+            '2000-01-04',
+        ], tz=tz)
+
+        result = arr.min()
+        expected = pd.Timestamp('2000-01-02', tz=tz)
+        assert result == expected
+
+        result = arr.max()
+        expected = pd.Timestamp('2000-01-05', tz=tz)
+        assert result == expected
+
+        result = arr.min(skipna=False)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=False)
+        assert result is pd.NaT
+
+    @pytest.mark.parametrize("tz", [None, "US/Central"])
+    @pytest.mark.parametrize('skipna', [True, False])
+    def test_min_max_empty(self, skipna, tz):
+        arr = DatetimeArray._from_sequence([], tz=tz)
+        result = arr.min(skipna=skipna)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=skipna)
+        assert result is pd.NaT

pandas/tests/arrays/test_period.py

@@ -246,3 +246,42 @@ def test_repr_large():
         "Length: 1000, dtype: period[D]"
     )
     assert result == expected
+
+
+# ----------------------------------------------------------------------------
+# Reductions
+
+class TestReductions(object):
+
+    def test_min_max(self):
+        arr = period_array([
+            '2000-01-03',
+            '2000-01-03',
+            'NaT',
+            '2000-01-02',
+            '2000-01-05',
+            '2000-01-04',
+        ], freq='D')
+
+        result = arr.min()
+        expected = pd.Period('2000-01-02', freq='D')
+        assert result == expected
+
+        result = arr.max()
+        expected = pd.Period('2000-01-05', freq='D')
+        assert result == expected
+
+        result = arr.min(skipna=False)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=False)
+        assert result is pd.NaT
+
+    @pytest.mark.parametrize('skipna', [True, False])
+    def test_min_max_empty(self, skipna):
+        arr = period_array([], freq='D')
+        result = arr.min(skipna=skipna)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=skipna)
+        assert result is pd.NaT

pandas/tests/arrays/test_timedeltas.py

@@ -73,3 +73,34 @@ def test_neg_freq(self):
 
         result = -arr
         tm.assert_timedelta_array_equal(result, expected)
+
+
+class TestReductions(object):
+
+    def test_min_max(self):
+        arr = TimedeltaArray._from_sequence([
+            '3H', '3H', 'NaT', '2H', '5H', '4H',
+        ])
+
+        result = arr.min()
+        expected = pd.Timedelta('2H')
+        assert result == expected
+
+        result = arr.max()
+        expected = pd.Timedelta('5H')
+        assert result == expected
+
+        result = arr.min(skipna=False)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=False)
+        assert result is pd.NaT
+
+    @pytest.mark.parametrize('skipna', [True, False])
+    def test_min_max_empty(self, skipna):
+        arr = TimedeltaArray._from_sequence([])
+        result = arr.min(skipna=skipna)
+        assert result is pd.NaT
+
+        result = arr.max(skipna=skipna)
+        assert result is pd.NaT

pandas/tests/indexes/datetimes/test_astype.py

@@ -299,3 +299,26 @@ def test_to_period_nofreq(self):
         idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-03'])
         assert idx.freqstr is None
         tm.assert_index_equal(idx.to_period(), expected)
+
+    @pytest.mark.parametrize('tz', [None, 'US/Central'])
+    def test_astype_category(self, tz):
+        obj = pd.date_range("2000", periods=2, tz=tz)
+        result = obj.astype('category')
+        expected = pd.CategoricalIndex([pd.Timestamp('2000-01-01', tz=tz),
+                                        pd.Timestamp('2000-01-02', tz=tz)])
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype('category')
+        expected = expected.values
+        tm.assert_categorical_equal(result, expected)
+
+    @pytest.mark.parametrize('tz', [None, 'US/Central'])
+    def test_astype_array_fallback(self, tz):
+        obj = pd.date_range("2000", periods=2, tz=tz)
+        result = obj.astype(bool)
+        expected = pd.Index(np.array([True, True]))
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype(bool)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)

pandas/tests/indexes/period/test_astype.py

@@ -97,3 +97,24 @@ def test_astype_object2(self):
         for i in [0, 1, 3]:
             assert result_list[i] == expected_list[i]
         assert result_list[2] is pd.NaT
+
+    def test_astype_category(self):
+        obj = pd.period_range("2000", periods=2)
+        result = obj.astype('category')
+        expected = pd.CategoricalIndex([pd.Period('2000-01-01', freq="D"),
+                                        pd.Period('2000-01-02', freq="D")])
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype('category')
+        expected = expected.values
+        tm.assert_categorical_equal(result, expected)
+
+    def test_astype_array_fallback(self):
+        obj = pd.period_range("2000", periods=2)
+        result = obj.astype(bool)
+        expected = pd.Index(np.array([True, True]))
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype(bool)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)

pandas/tests/indexes/timedeltas/test_astype.py

@@ -4,6 +4,7 @@
 import pytest
 
 import pandas.util.testing as tm
+import pandas as pd
 from pandas import (
     Float64Index, Index, Int64Index, NaT, Timedelta, TimedeltaIndex,
     timedelta_range
@@ -77,3 +78,24 @@ def test_astype_raises(self, dtype):
         msg = 'Cannot cast TimedeltaArray(Mixin)? to dtype'
         with pytest.raises(TypeError, match=msg):
             idx.astype(dtype)
+
+    def test_astype_category(self):
+        obj = pd.timedelta_range("1H", periods=2, freq='H')
+        result = obj.astype('category')
+        expected = pd.CategoricalIndex([pd.Timedelta('1H'),
+                                        pd.Timedelta('2H')])
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype('category')
+        expected = expected.values
+        tm.assert_categorical_equal(result, expected)
+
+    def test_astype_array_fallback(self):
+        obj = pd.timedelta_range("1H", periods=2)
+        result = obj.astype(bool)
+        expected = pd.Index(np.array([True, True]))
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype(bool)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)