Update PeriodIndex._simple_new

pandas/core/arrays/period.py

@@ -16,7 +16,7 @@
 from pandas._libs.tslibs.timedeltas import delta_to_nanoseconds, Timedelta
 from pandas._libs.tslibs.fields import isleapyear_arr
 from pandas.util._decorators import cache_readonly
-from pandas.core.algorithms import checked_add_with_arr
+import pandas.core.algorithms as algos
 from pandas.core.dtypes.common import (
  is_integer_dtype, is_float_dtype, is_period_dtype,
  pandas_dtype,
@@ -35,6 +35,7 @@
 from pandas.core.dtypes.generic import (
  ABCSeries, ABCIndexClass, ABCPeriodIndex
 )
+from pandas.core.dtypes.missing import isna
 
 import pandas.core.common as com
 
@@ -342,9 +343,6 @@ def __setitem__(self, key, value):
  self._data[key] = value
 
  def take(self, indices, allow_fill=False, fill_value=None):
- from pandas.core.algorithms import take
- from pandas import isna
-
  if allow_fill:
  if isna(fill_value):
  fill_value = iNaT
@@ -354,10 +352,10 @@ def take(self, indices, allow_fill=False, fill_value=None):
  msg = "'fill_value' should be a Period. Got '{}'."
  raise ValueError(msg.format(fill_value))
 
- new_values = take(self._data,
- indices,
- allow_fill=allow_fill,
- fill_value=fill_value)
+ new_values = algos.take(self._data,
+  indices,
+  allow_fill=allow_fill,
+  fill_value=fill_value)
 
  return type(self)(new_values, self.freq)
 
@@ -368,15 +366,15 @@ def fillna(self, value=None, method=None, limit=None):
  # TODO(#20300)
  # To avoid converting to object, we re-implement here with the changes
  # 1. Passing `_ndarray_values` to func instead of self.astype(object)
- # 2. Re-boxing with `_from_ordinals`
+ # 2. Re-boxing output of 1.
  # #20300 should let us do this kind of logic on ExtensionArray.fillna
  # and we can use it.
  from pandas.api.types import is_array_like
  from pandas.util._validators import validate_fillna_kwargs
  from pandas.core.missing import pad_1d, backfill_1d
 
  if isinstance(value, ABCSeries):
- value = value.values
+ value = value._values
 
  value, method = validate_fillna_kwargs(value, method)
 
@@ -406,21 +404,19 @@ def copy(self, deep=False):
  return type(self)(self._data.copy(), freq=self.freq)
 
  def value_counts(self, dropna=False):
- from pandas.core.algorithms import value_counts
- from pandas.core.indexes.period import PeriodIndex
+ from pandas import Series, PeriodIndex
 
  if dropna:
  values = self[~self.isna()]._data
  else:
  values = self._data
 
- result = value_counts(values, sort=False)
- index = PeriodIndex._from_ordinals(result.index,
- name=result.index.name,
- freq=self.freq)
- return type(result)(result.values,
- index=index,
- name=result.name)
+ cls = type(self)
+
+ result = algos.value_counts(values, sort=False)
+ index = PeriodIndex(cls(result.index, freq=self.freq),
+ name=result.index.name)
+ return Series(result.values, index=index, name=result.name)
 
  def shift(self, periods=1):
  """
@@ -844,8 +840,8 @@ def _addsub_int_array(self, other, op):
  # easy case for PeriodIndex
  if op is operator.sub:
  other = -other
- res_values = checked_add_with_arr(self.asi8, other,
- arr_mask=self._isnan)
+ res_values = algos.checked_add_with_arr(self.asi8, other,
+  arr_mask=self._isnan)
  res_values = res_values.view('i8')
  res_values[self._isnan] = iNaT
  return type(self)(res_values, freq=self.freq)

pandas/core/indexes/period.py

@@ -8,6 +8,7 @@
 from pandas.core.dtypes.common import (
  is_integer,
  is_float,
+ is_float_dtype,
  is_integer_dtype,
  is_datetime64_any_dtype,
  is_bool_dtype,
@@ -29,7 +30,6 @@
 
 from pandas.core.algorithms import unique1d
 from pandas.core.dtypes.dtypes import PeriodDtype
-from pandas.core.dtypes.generic import ABCIndexClass
 from pandas.core.arrays.period import PeriodArray, period_array
 from pandas.core.base import _shared_docs
 from pandas.core.indexes.base import _index_shared_docs, ensure_index
@@ -63,7 +63,9 @@ def _new_PeriodIndex(cls, **d):
  # GH13277 for unpickling
  values = d.pop('data')
  if values.dtype == 'int64':
- return cls._from_ordinals(values=values, **d)
+ freq = d.pop('freq', None)
+ data = PeriodArray(values, freq=freq)
+ return cls._simple_new(data, **d)
  else:
  return cls(values, **d)
 
@@ -187,6 +189,9 @@ class PeriodIndex(DatelikeOps, DatetimeIndexOpsMixin,
 
  _engine_type = libindex.PeriodEngine
 
+ # ------------------------------------------------------------------------
+ # Index Constructors
+
  def __new__(cls, data=None, ordinal=None, freq=None, start=None, end=None,
  periods=None, tz=None, dtype=None, copy=False, name=None,
  **fields):
@@ -241,6 +246,35 @@ def __new__(cls, data=None, ordinal=None, freq=None, start=None, end=None,
 
  return cls._simple_new(data, name=name)
 
+ @classmethod
+ def _simple_new(cls, values, name=None, freq=None, **kwargs):
+ """
+ Create a new PeriodIndex.
+
+ Parameters
+ ----------
+ values : PeriodArray, PeriodIndex, Index[int64], ndarray[int64]
+ Values that can be converted to a PeriodArray without inference
+ or coercion.
+
+ """
+ # TODO: raising on floats is tested, but maybe not useful.
+ # Should the callers know not to pass floats?
+ # At the very least, I think we can ensure that lists aren't passed.
+ if isinstance(values, list):
+ values = np.asarray(values)
+ if is_float_dtype(values):
+ raise TypeError("PeriodIndex._simple_new does not accept floats.")
+ values = PeriodArray(values, freq=freq)
+
+ if not isinstance(values, PeriodArray):
+ raise TypeError("PeriodIndex._simple_new only accepts PeriodArray")
+ result = object.__new__(cls)
+ result._data = values
+ result.name = name
+ result._reset_identity()
+ return result
+
  # ------------------------------------------------------------------------
  # Data
  @property
@@ -270,42 +304,6 @@ def freq(self, value):
  # here, but people shouldn't be doing this anyway.
  self._data._freq = value
 
- # ------------------------------------------------------------------------
- # Index Constructors
-
- @classmethod
- def _simple_new(cls, values, name=None, freq=None, **kwargs):
- # type: (PeriodArray, Any, Any) -> PeriodIndex
- """
- Values can be any type that can be coerced to Periods.
- Ordinals in an ndarray are fastpath-ed to `_from_ordinals`
- """
- if isinstance(values, cls):
- # TODO: don't do this
- values = values.values
- elif (isinstance(values, (ABCIndexClass, np.ndarray)) and
- is_integer_dtype(values)):
- # TODO: don't do this.
- values = PeriodArray._simple_new(values, freq)
-
- if not isinstance(values, PeriodArray):
- raise TypeError("PeriodIndex._simple_new only accepts PeriodArray")
- result = object.__new__(cls)
- result._data = values
- result.name = name
- result._reset_identity()
- return result
-
- @classmethod
- def _from_ordinals(cls, values, name=None, freq=None, **kwargs):
- """
- Values should be int ordinals
- `__new__` & `_simple_new` cooerce to ordinals and call this method
- """
- data = PeriodArray(values, freq=freq)
- result = cls._simple_new(data, name=name)
- return result
-
  def _shallow_copy(self, values=None, **kwargs):
  # TODO: simplify, figure out type of values
  if values is None:

pandas/io/packers.py

@@ -53,7 +53,7 @@
 )
 from pandas.compat import u, u_safe
 from pandas.core import internals
-from pandas.core.arrays import IntervalArray
+from pandas.core.arrays import IntervalArray, PeriodArray
 from pandas.core.arrays.sparse import BlockIndex, IntIndex
 from pandas.core.dtypes.common import (
  is_categorical_dtype, is_object_dtype, needs_i8_conversion, pandas_dtype
@@ -599,7 +599,9 @@ def decode(obj):
  elif typ == u'period_index':
  data = unconvert(obj[u'data'], np.int64, obj.get(u'compress'))
  d = dict(name=obj[u'name'], freq=obj[u'freq'])
- return globals()[obj[u'klass']]._from_ordinals(data, **d)
+ freq = d.pop('freq', None)
+ return globals()[obj[u'klass']](PeriodArray(data, freq), **d)
+
  elif typ == u'datetime_index':
  data = unconvert(obj[u'data'], np.int64, obj.get(u'compress'))
  d = dict(name=obj[u'name'], freq=obj[u'freq'], verify_integrity=False)