wip

Author: TomAugspurger

pandas/core/arrays/datetimelike.py

@@ -518,10 +518,9 @@ def _addsub_offset_array(self, other, op):
         left = lib.values_from_object(self.astype('O'))
 
         res_values = op(left, np.array(other))
-        kwargs = {}
         if not is_period_dtype(self):
-            kwargs['freq'] = 'infer'
-        return type(self)(res_values, **kwargs)
+            return type(self)(res_values, freq='infer')
+        return self._from_sequence(res_values)
 
     @deprecate_kwarg(old_arg_name='n', new_arg_name='periods')
     def shift(self, periods, freq=None):
@@ -603,8 +602,6 @@ def __add__(self, other):
             elif lib.is_integer(other):
                 # This check must come after the check for np.timedelta64
                 # as is_integer returns True for these
-                # TODO: make a _shift method that's consistent between
-                # Index and EA
                 result = self._tshift(other)
 
             # array-like others
@@ -657,7 +654,7 @@ def __sub__(self, other):
             elif lib.is_integer(other):
                 # This check must come after the check for np.timedelta64
                 # as is_integer returns True for these
-                result = self.shift(-other)
+                result = self._tshift(-other)
             elif isinstance(other, Period):
                 result = self._sub_period(other)
 

pandas/core/arrays/period.py

@@ -30,7 +30,7 @@
 )
 from pandas.core.dtypes.dtypes import PeriodDtype
 from pandas.core.dtypes.generic import (
-    ABCSeries, ABCIndex, ABCPeriodIndex
+    ABCSeries, ABCPeriodIndex, ABCIndexClass,
 )
 
 import pandas.core.common as com
@@ -63,7 +63,7 @@ def _period_array_cmp(cls, op):
 
     def wrapper(self, other):
         op = getattr(self._ndarray_values, opname)
-        if isinstance(other, (ABCSeries, ABCIndex)):
+        if isinstance(other, (ABCSeries, ABCIndexClass)):
             other = other.values
 
         if isinstance(other, Period):
@@ -72,7 +72,7 @@ def wrapper(self, other):
                 raise IncompatibleFrequency(msg)
 
             result = op(other.ordinal)
-        elif isinstance(other, (ABCPeriodIndex, cls)):
+        elif isinstance(other, cls):
             if other.freq != self.freq:
                 msg = DIFFERENT_FREQ_INDEX.format(self.freqstr, other.freqstr)
                 raise IncompatibleFrequency(msg)
@@ -88,7 +88,8 @@ def wrapper(self, other):
             result = np.empty(len(self._ndarray_values), dtype=bool)
             result.fill(nat_result)
         elif isinstance(other, (list, np.ndarray)):
-            # XXX: is this correct?
+            # XXX: is this correct? Why not convert the
+            # sequence to a PeriodArray?
             return NotImplemented
         else:
             other = Period(other, freq=self.freq)
@@ -111,16 +112,16 @@ class PeriodArray(DatetimeLikeArrayMixin, ExtensionArray):
     - ordinals : integer ndarray
     - freq : pd.tseries.offsets.Tick
 
-    The values are physically stored as an ndarray of integers. These are
+    The values are physically stored as a 1-D ndarray of integers. These are
     called "ordinals" and represent some kind of offset from a base.
 
     The `freq` indicates the span covered by each element of the array.
     All elements in the PeriodArray have the same `freq`.
     """
     _attributes = ["freq"]
-    _typ = "periodarray"  # ABCPeriodAray
+    _typ = "periodarray"  # ABCPeriodArray
 
-    # Names others delegate to us on
+    # Names others delegate to us
     _other_ops = []
     _bool_ops = ['is_leap_year']
     _object_ops = ['start_time', 'end_time', 'freq']
@@ -134,7 +135,7 @@ class PeriodArray(DatetimeLikeArrayMixin, ExtensionArray):
     # --------------------------------------------------------------------
     # Constructors
     def __init__(self, values, freq=None):
-        # type: (np.ndarray[int64], Union[str, Tick]) -> None
+        # type: (np.ndarray[np.int64], Union[str, Tick]) -> None
         values = np.array(values, dtype='int64', copy=False)
         self._data = values
         if freq is None:
@@ -237,7 +238,7 @@ def _from_ordinals(cls, values, freq=None):
         # type: (ndarray[int], Optional[Tick]) -> PeriodArray
         """
         Values should be int ordinals
-        `__new__` & `_simple_new` cooerce to ordinals and call this method
+        `__new__` & `_simple_new` coerce to ordinals and call this method
         """
         return cls(values, freq=freq)
 
@@ -536,7 +537,7 @@ def _add_offset(self, other):
         if base != self.freq.rule_code:
             msg = DIFFERENT_FREQ_INDEX.format(self.freqstr, other.freqstr)
             raise IncompatibleFrequency(msg)
-        return self.shift(other.n)
+        return self._tshift(other.n)
 
     def _add_delta_td(self, other):
         assert isinstance(other, (timedelta, np.timedelta64, Tick))
@@ -546,7 +547,7 @@ def _add_delta_td(self, other):
         if isinstance(own_offset, Tick):
             offset_nanos = delta_to_nanoseconds(own_offset)
             if np.all(nanos % offset_nanos == 0):
-                return self.shift(nanos // offset_nanos)
+                return self._tshift(nanos // offset_nanos)
 
         # raise when input doesn't have freq
         raise IncompatibleFrequency("Input has different freq from "
@@ -556,7 +557,7 @@ def _add_delta_td(self, other):
 
     def _add_delta(self, other):
         ordinal_delta = self._maybe_convert_timedelta(other)
-        return self.shift(ordinal_delta)
+        return self._tshift(ordinal_delta)
 
     def shift(self, periods=1):
         """
@@ -640,6 +641,7 @@ def _maybe_convert_timedelta(self, other):
                                                freqstr=self.freqstr))
 
     def _format_native_types(self, na_rep=u'NaT', date_format=None):
+        # TODO(DatetimeArray): remove
         values = self.astype(object)
 
         if date_format:
@@ -658,7 +660,8 @@ def _format_native_types(self, na_rep=u'NaT', date_format=None):
         return values
 
     def view(self, dtype=None, type=None):
-        # This is to support PeriodIndex.view('i8')
+        # This is to support things like `.asi8`
+        # PeriodIndex's parent does .values.view('i8').
         # I don't like adding this,
         return self._data.view(dtype=dtype)
 
@@ -757,6 +760,28 @@ def _box_values_as_index(self):
         from pandas.core.index import Index
         return Index(self._box_values(self.asi8), dtype=object)
 
+    @property
+    def flags(self):
+        """Deprecated"""
+        # Just here to support Index.flags deprecation.
+        # could also override PeriodIndex.flags if we don't want a
+        # version with PeriodArray.flags
+        return self.values.flags
+
+    @property
+    def base(self):
+        return self.values.base
+
+    @property
+    def data(self):
+        return self.astype(object).data
+
+    def item(self):
+        if len(self) == 1:
+            return Period._from_ordinal(self.values[0], self.freq)
+        else:
+            raise ValueError('can only convert an array of size 1 to a '
+                             'Python scalar')
 
 PeriodArray._add_comparison_ops()
 PeriodArray._add_datetimelike_methods()

pandas/core/indexes/period.py

@@ -262,11 +262,13 @@ def _shallow_copy(self, values=None, **kwargs):
         else:
             # this differs too
             if not isinstance(values, PeriodArray):
-                try:
-                    values = PeriodArray._from_ordinals(values, freq=self.freq)
-                except TypeError:
-                    # TODO: this is probably ambiguous for some oridinals.
-                    values = PeriodArray._complex_new(values, freq=self.freq)
+                values = PeriodArray._complex_new(values, freq=self.freq)
+
+        # I don't like overloading shallow_copy with freq changes.
+        # See if it's used anywhere outside of test_resample_empty_dataframe
+        freq = kwargs.pop("freq", None)
+        if freq:
+            values = values.asfreq(freq)
 
         attributes = self._get_attributes_dict()
         attributes.update(kwargs)

pandas/core/ops.py

@@ -1173,6 +1173,11 @@ def dispatch_to_extension_op(op, left, right):
     if is_extension_array_dtype(left):
 
         new_left = left.values
+        if (is_extension_array_dtype(right)
+                and isinstance(right, (ABCIndexClass, ABCSeries))):
+            # unbox
+            right = right._values
+
         if isinstance(right, np.ndarray):
 
             # handle numpy scalars, this is a PITA
@@ -1181,8 +1186,11 @@ def dispatch_to_extension_op(op, left, right):
             if is_scalar(new_right):
                 new_right = [new_right]
             new_right = list(new_right)
+        elif (is_extension_array_dtype(right) and
+              type(new_left) == type(right)):
+            new_right = right
         elif is_extension_array_dtype(right) and type(left) != type(right):
-            new_right = list(new_right)
+            new_right = list(right)
         else:
             new_right = right
 

pandas/tests/arithmetic/test_period.py

@@ -623,7 +623,7 @@ def test_pi_sub_isub_timedeltalike_daily(self, three_days):
     def test_pi_add_iadd_timedeltalike_freq_mismatch_daily(self, not_daily):
         other = not_daily
         rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
-        msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
+        msg = 'Input has different freq(=.+)? from Period.*?\\(freq=D\\)'
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
             rng + other
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
@@ -632,7 +632,7 @@ def test_pi_add_iadd_timedeltalike_freq_mismatch_daily(self, not_daily):
     def test_pi_sub_timedeltalike_freq_mismatch_daily(self, not_daily):
         other = not_daily
         rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
-        msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
+        msg = 'Input has different freq(=.+)? from Period.*?\\(freq=D\\)'
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
             rng - other
 
@@ -651,7 +651,7 @@ def test_pi_add_iadd_timedeltalike_hourly(self, two_hours):
     def test_pi_add_timedeltalike_mismatched_freq_hourly(self, not_hourly):
         other = not_hourly
         rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
-        msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=H\\)'
+        msg = 'Input has different freq(=.+)? from Period.*?\\(freq=H\\)'
 
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
             rng + other
@@ -686,7 +686,7 @@ def test_pi_add_iadd_timedeltalike_freq_mismatch_annual(self,
         other = mismatched_freq
         rng = pd.period_range('2014', '2024', freq='A')
         msg = ('Input has different freq(=.+)? '
-               'from PeriodIndex\\(freq=A-DEC\\)')
+               'from Period.*?\\(freq=A-DEC\\)')
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
             rng + other
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
@@ -697,7 +697,7 @@ def test_pi_sub_isub_timedeltalike_freq_mismatch_annual(self,
         other = mismatched_freq
         rng = pd.period_range('2014', '2024', freq='A')
         msg = ('Input has different freq(=.+)? '
-               'from PeriodIndex\\(freq=A-DEC\\)')
+               'from Period.*?\\(freq=A-DEC\\)')
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
             rng - other
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
@@ -717,7 +717,7 @@ def test_pi_add_iadd_timedeltalike_freq_mismatch_monthly(self,
                                                              mismatched_freq):
         other = mismatched_freq
         rng = pd.period_range('2014-01', '2016-12', freq='M')
-        msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
+        msg = 'Input has different freq(=.+)? from Period.*?\\(freq=M\\)'
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
             rng + other
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
@@ -727,7 +727,7 @@ def test_pi_sub_isub_timedeltalike_freq_mismatch_monthly(self,
                                                              mismatched_freq):
         other = mismatched_freq
         rng = pd.period_range('2014-01', '2016-12', freq='M')
-        msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
+        msg = 'Input has different freq(=.+)? from Period.*?\\(freq=M\\)'
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
             rng - other
         with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
@@ -852,6 +852,7 @@ def test_pi_ops_errors(self, ng):
                 with pytest.raises(TypeError):
                     np.subtract(ng, obj)
 
+    @pytest.mark.xfail(reason="GH-22798", strict=True)
     def test_pi_ops_nat(self):
         idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
                           freq='M', name='idx')
@@ -876,6 +877,7 @@ def test_pi_ops_nat(self):
         self._check(idx + 3, lambda x: x - 3, idx)
         self._check(idx + 3, lambda x: np.subtract(x, 3), idx)
 
+    @pytest.mark.xfail(reason="TODO", strict=True)
     def test_pi_ops_array_int(self):
         idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
                           freq='M', name='idx')
@@ -924,7 +926,7 @@ def test_pi_offset_errors(self):
 
         # Series op is applied per Period instance, thus error is raised
         # from Period
-        msg_idx = r"Input has different freq from PeriodIndex\(freq=D\)"
+        msg_idx = r"Input has different freq from Period.*?\(freq=D\)"
         msg_s = r"Input cannot be converted to Period\(freq=D\)"
         for obj, msg in [(idx, msg_idx), (ser, msg_s)]:
             with tm.assert_raises_regex(period.IncompatibleFrequency, msg):

pandas/tests/test_base.py

@@ -1198,7 +1198,8 @@ def test_iter_box(self):
     (pd.DatetimeIndex(['2017', '2018'], tz="US/Central"), pd.DatetimeIndex,
      'datetime64[ns, US/Central]'),
     (pd.TimedeltaIndex([10**10]), np.ndarray, 'm8[ns]'),
-    (pd.PeriodIndex([2018, 2019], freq='A'), np.ndarray, 'object'),
+    (pd.PeriodIndex([2018, 2019], freq='A'), pd.core.arrays.PeriodArray,
+     pd.core.dtypes.dtypes.PeriodDtype("A-DEC")),
     (pd.IntervalIndex.from_breaks([0, 1, 2]), pd.core.arrays.IntervalArray,
      'interval'),
 ])
@@ -1214,6 +1215,8 @@ def test_values_consistent(array, expected_type, dtype):
         tm.assert_index_equal(l_values, r_values)
     elif pd.api.types.is_categorical(l_values):
         tm.assert_categorical_equal(l_values, r_values)
+    elif pd.api.types.is_period_dtype(l_values):
+        tm.assert_period_array_equal(l_values, r_values)
     elif pd.api.types.is_interval_dtype(l_values):
         tm.assert_interval_array_equal(l_values, r_values)
     else:
@@ -1232,12 +1235,8 @@ def test_values_consistent(array, expected_type, dtype):
     (pd.DatetimeIndex(['2017-01-01T00:00:00'], tz="US/Eastern"),
      np.array(['2017-01-01T05:00:00'], dtype='M8[ns]')),
     (pd.TimedeltaIndex([10**10]), np.array([10**10], dtype='m8[ns]')),
-    pytest.param(
-        pd.PeriodIndex(['2017', '2018'], freq='D'),
-        np.array([17167, 17532]),
-        marks=pytest.mark.xfail(reason="PeriodArray Not implemented",
-                                strict=True)
-    ),
+    (pd.PeriodIndex(['2017', '2018'], freq='D'),
+     np.array([17167, 17532])),
 ])
 def test_ndarray_values(array, expected):
     l_values = pd.Series(array)._ndarray_values

pandas/tests/test_multilevel.py

@@ -16,6 +16,7 @@
 from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype
 import pandas.core.common as com
 import pandas.util.testing as tm
+from pandas.core.arrays import PeriodArray
 from pandas.compat import (range, lrange, StringIO, lzip, u, product as
                            cart_product, zip)
 import pandas as pd
@@ -2319,9 +2320,10 @@ def test_reset_index_period(self):
         df = DataFrame(np.arange(9, dtype='int64').reshape(-1, 1),
                        index=idx, columns=['a'])
         expected = DataFrame({
-            'month': ([pd.Period('2013-01', freq='M')] * 3 +
-                      [pd.Period('2013-02', freq='M')] * 3 +
-                      [pd.Period('2013-03', freq='M')] * 3),
+            'month': PeriodArray._from_periods(np.array(
+                [pd.Period('2013-01', freq='M')] * 3 +
+                [pd.Period('2013-02', freq='M')] * 3 +
+                [pd.Period('2013-03', freq='M')] * 3, dtype=object)),
             'feature': ['a', 'b', 'c'] * 3,
             'a': np.arange(9, dtype='int64')
         }, columns=['month', 'feature', 'a'])