tshift, shift

pandas/core/accessor.py

@@ -68,8 +68,6 @@ def _add_delegate_accessors(cls, delegate, accessors, typ,
  overwrite : boolean, default False
  overwrite the method/property in the target class if it exists
  """
- delegated_to = getattr(delegate, '_delegated_to', delegate)
-
  def _create_delegator_property(name):
 
  def _getter(self):
@@ -82,15 +80,15 @@ def _setter(self, new_values):
  _setter.__name__ = name
 
  return property(fget=_getter, fset=_setter,
- doc=getattr(delegated_to, name).__doc__)
+ doc=getattr(delegate, name).__doc__)
 
  def _create_delegator_method(name):
 
  def f(self, *args, **kwargs):
  return self._delegate_method(name, *args, **kwargs)
 
  f.__name__ = name
- f.__doc__ = getattr(delegated_to, name).__doc__
+ f.__doc__ = getattr(delegate, name).__doc__
 
  return f
 
@@ -107,12 +105,10 @@ def f(self, *args, **kwargs):
 
 
 def delegate_names(delegate, accessors, typ, overwrite=False):
+ # type (type, list, str, bool) -> Callable
  """
  Add delegated names to a class using a class decorator.
 
- Methods and attributes are delegated to ...
-
-
  This provides an alternative usage to directly calling
  `_add_delegate_accessors` below a class definition.
 

pandas/core/arrays/datetimelike.py

@@ -553,6 +553,9 @@ def shift(self, periods, freq=None):
  --------
  Index.shift : Shift values of Index.
  """
+ return self._tshift(periods, freq=freq)
+
+ def _tshift(self, periods, freq=None):
  if freq is not None and freq != self.freq:
  if isinstance(freq, compat.string_types):
  freq = frequencies.to_offset(freq)
@@ -600,7 +603,9 @@ 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
- result = self.shift(other)
+ # TODO: make a _shift method that's consistent between
+ # Index and EA
+ result = self._tshift(other)
 
  # array-like others
  elif is_timedelta64_dtype(other):

pandas/core/arrays/period.py

@@ -113,9 +113,32 @@ class PeriodArray(DatetimeLikeArrayMixin, ExtensionArray):
  """
  _attributes = ["freq"]
  _typ = "period" # ABCPeriodArray
+
+ # Names others delegate to us on
+ _other_ops = []
+ _bool_ops = ['is_leap_year']
+ _object_ops = ['start_time', 'end_time', 'freq']
+ _field_ops = ['year', 'month', 'day', 'hour', 'minute', 'second',
+ 'weekofyear', 'weekday', 'week', 'dayofweek',
+ 'dayofyear', 'quarter', 'qyear',
+ 'days_in_month', 'daysinmonth']
+ _datetimelike_ops = _field_ops + _object_ops + _bool_ops
+ _datetimelike_methods = ['strftime', 'to_timestamp', 'asfreq']
+
  # --------------------------------------------------------------------
  # Constructors
 
+ @property
+ def _foo(self):
+ return 'foo!'
+
+ @_foo.setter
+ def _foo(self, value):
+ print("setting foo to ", value)
+
+ def _bar(self, arg, kwarg=1):
+ print(arg, kwarg)
+
  def __new__(cls, data=None, ordinal=None, freq=None, start=None, end=None,
  periods=None, tz=None, dtype=None, copy=False,
  **fields):
@@ -511,11 +534,27 @@ def shift(self, periods=1):
  -------
  shifted : Period Array/Index
  """
+ # We have two kinds of shift.
+ # 1. ExtensionArray.shift: move positions of each value,
+ # fill NA on the end
+ # 2. Datelike.tshift: move each value through time
+ # Each Datelike array will implement both. It's up to the
+ # caller to call the correct one.
+ return self._ea_shift(periods=periods)
+
+ def _ea_shift(self, periods=1):
  # TODO: remove from DatetimeLikeArrayMixin
  # The semantics for Index.shift differ from EA.shift
  # then just call super.
  return ExtensionArray.shift(self, periods)
 
+ def _tshift(self, n, freq=None):
+ # TODO: docs
+ values = self.values + n * self.freq.n
+ if self.hasnans:
+ values[self._isnan] = iNaT
+ return self._simple_new(values, freq=self.freq)
+
  def _maybe_convert_timedelta(self, other):
  """
  Convert timedelta-like input to an integer multiple of self.freq
@@ -628,7 +667,8 @@ def end_time(self):
 
 PeriodArray._add_comparison_ops()
 PeriodArray._add_datetimelike_methods()
-
+# PeriodArray._add_numeric_methods_disabled()
+# PeriodArray._add_logical_methods_disabled()
 
 # -------------------------------------------------------------------
 # Constructor Helpers

pandas/core/indexes/accessors.py

@@ -270,11 +270,11 @@ def freq(self):
  return self._get_values().inferred_freq
 
 
-@delegate_names(delegate=PeriodIndex,
- accessors=PeriodIndex._datetimelike_ops,
+@delegate_names(delegate=PeriodArray,
+ accessors=PeriodArray._datetimelike_ops,
  typ="property")
-@delegate_names(delegate=PeriodIndex,
- accessors=PeriodIndex._datetimelike_methods,
+@delegate_names(delegate=PeriodArray,
+ accessors=PeriodArray._datetimelike_methods,
  typ="method")
 class PeriodProperties(Properties):
  """
@@ -289,8 +289,6 @@ class PeriodProperties(Properties):
  Returns a Series indexed like the original Series.
  Raises TypeError if the Series does not contain datetimelike values.
  """
- def _delegate_method(self, name, *args, **kwargs):
- pass
 
 
 class CombinedDatetimelikeProperties(DatetimeProperties, TimedeltaProperties):

pandas/core/indexes/period.py

@@ -1,6 +1,7 @@
 # pylint: disable=E1101,E1103,W0232
 from datetime import datetime
 import numpy as np
+import operator
 import warnings
 
 from pandas.core import common as com
@@ -20,6 +21,7 @@
 import pandas.tseries.frequencies as frequencies
 from pandas.tseries.frequencies import get_freq_code as _gfc
 
+from pandas.core.accessor import PandasDelegate, delegate_names
 from pandas.core.indexes.datetimes import DatetimeIndex, Int64Index, Index
 from pandas.core.indexes.datetimelike import DatelikeOps, DatetimeIndexOpsMixin
 from pandas.core.tools.datetimes import parse_time_string
@@ -64,8 +66,23 @@ def _new_PeriodIndex(cls, **d):
  return cls._from_ordinals(values=values, **d)
 
 
+class PeriodDelegateMixin(PandasDelegate):
+ """
+ Delegate from PeriodIndex to PeriodArray.
+ """
+ def _delegate_property_get(self, name, *args, **kwargs):
+ return getattr(self._data, name)
+
+ def _delegate_property_set(self, name, value, *args, **kwargs):
+ setattr(self._data, name, value)
+
+ def _delegate_method(self, name, *args, **kwargs):
+ return operator.methodcaller(name, *args, **kwargs)(self._data)
+
+
+# @delegate_names(PeriodArray, PeriodArray._datetimelike_methods, typ="method")
 class PeriodIndex(DatelikeOps, DatetimeIndexOpsMixin,
- Int64Index):
+ Int64Index, PeriodDelegateMixin):
  """
  Immutable ndarray holding ordinal values indicating regular periods in
  time such as particular years, quarters, months, etc.
@@ -145,19 +162,9 @@ class PeriodIndex(DatelikeOps, DatetimeIndexOpsMixin,
  """
  _typ = 'periodindex'
  _attributes = ['name', 'freq']
- _delegated_to = PeriodArray
+ # _delegated_to = PeriodArray
 
  # define my properties & methods for delegation
- _other_ops = []
- _bool_ops = ['is_leap_year']
- _object_ops = ['start_time', 'end_time', 'freq']
- _field_ops = ['year', 'month', 'day', 'hour', 'minute', 'second',
- 'weekofyear', 'weekday', 'week', 'dayofweek',
- 'dayofyear', 'quarter', 'qyear',
- 'days_in_month', 'daysinmonth']
- _datetimelike_ops = _field_ops + _object_ops + _bool_ops
- _datetimelike_methods = ['strftime', 'to_timestamp', 'asfreq']
-
  _is_numeric_dtype = False
  _infer_as_myclass = True
 
@@ -339,13 +346,8 @@ def shift(self, n):
  -------
  shifted : PeriodIndex
  """
- # TODO: docs
- # Note, this differs from the definition of ExtensionArray.shift
- # so we don't dispatch
- values = self._ndarray_values + n * self.freq.n
- if self.hasnans:
- values[self._isnan] = tslib.iNaT
- return self._shallow_copy(values=values)
+ i8values = self._data._tshift(n)
+ return self._simple_new(i8values, name=self.name, freq=self.freq)
 
  def _coerce_scalar_to_index(self, item):
  """