clean up PeriodIndex constructor

Author: max-sixty

pandas/core/algorithms.py

@@ -304,17 +304,18 @@ def _value_counts_arraylike(values, dropna=True):
 
     orig = values
 
+    if is_period:
+        from pandas.tseries.period import PeriodIndex
+        index = PeriodIndex(values)
+        freq = index.freq
+        values = index.values
+
     from pandas.core.series import Series
     values = Series(values).values
     dtype = values.dtype
 
     if com.is_datetime_or_timedelta_dtype(dtype) or is_period:
         from pandas.tseries.index import DatetimeIndex
-        from pandas.tseries.period import PeriodIndex
-
-        if is_period:
-            values = PeriodIndex(values)
-            freq = values.freq
 
         values = values.view(np.int64)
         keys, counts = htable.value_count_scalar64(values, dropna)
@@ -333,7 +334,7 @@ def _value_counts_arraylike(values, dropna=True):
             else:
                 tz = orig.dt.tz
             keys = DatetimeIndex._simple_new(keys, tz=tz)
-        if is_period:
+        elif is_period:
             keys = PeriodIndex._simple_new(keys, freq=freq)
 
     elif com.is_integer_dtype(dtype):

pandas/indexes/base.py

@@ -67,6 +67,8 @@ def _new_Index(cls, d):
     """ This is called upon unpickling, rather than the default which doesn't
     have arguments and breaks __new__
     """
+    if issubclass(cls, ABCPeriodIndex):
+        return cls._simple_new(**d)
     return cls.__new__(cls, **d)
 
 
@@ -371,7 +373,7 @@ def _shallow_copy_with_infer(self, values=None, **kwargs):
         attributes['copy'] = False
         if self._infer_as_myclass:
             try:
-                return self._constructor(values, **attributes)
+                return self._shallow_copy(values, **attributes)
             except (TypeError, ValueError):
                 pass
         return Index(values, **attributes)
@@ -1944,9 +1946,9 @@ def symmetric_difference(self, other, result_name=None):
                               union(other.difference(self))))
         attribs = self._get_attributes_dict()
         attribs['name'] = result_name
-        if 'freq' in attribs:
-            attribs['freq'] = None
-        return self._shallow_copy_with_infer(the_diff, **attribs)
+        # use constructor rather than _shallow_copy, because we have objects
+        # rather than .values
+        return self._constructor(the_diff, **attribs)
 
     sym_diff = deprecate('sym_diff', symmetric_difference)
 
@@ -2419,10 +2421,10 @@ def _reindex_non_unique(self, target):
             missing = com._ensure_platform_int(missing)
             missing_labels = target.take(missing)
             missing_indexer = _ensure_int64(l[~check])
-            cur_labels = self.take(indexer[check])._values
+            cur_labels = self.take(indexer[check])
             cur_indexer = _ensure_int64(l[check])
 
-            new_labels = np.empty(tuple([len(indexer)]), dtype=object)
+            new_labels = np.empty(tuple([len(indexer)]), dtype=target.dtype)
             new_labels[cur_indexer] = cur_labels
             new_labels[missing_indexer] = missing_labels
 
@@ -2446,7 +2448,7 @@ def _reindex_non_unique(self, target):
                 new_indexer = np.arange(len(self.take(indexer)))
                 new_indexer[~check] = -1
 
-        new_index = self._shallow_copy_with_infer(new_labels, freq=None)
+        new_index = self._shallow_copy_with_infer(new_labels)
         return new_index, indexer, new_indexer
 
     def join(self, other, how='left', level=None, return_indexers=False):

pandas/tests/indexes/test_datetimelike.py

@@ -867,7 +867,7 @@ def test_repeat(self):
         # GH10183
         idx = pd.period_range('2000-01-01', periods=3, freq='D')
         res = idx.repeat(3)
-        exp = PeriodIndex(idx.values.repeat(3), freq='D')
+        exp = PeriodIndex._simple_new(idx.values.repeat(3), freq='D')
         self.assert_index_equal(res, exp)
         self.assertEqual(res.freqstr, 'D')
 

pandas/tseries/index.py

@@ -598,6 +598,12 @@ def _simple_new(cls, values, name=None, freq=None, tz=None,
         result._reset_identity()
         return result
 
+    def _shallow_copy_with_infer(self, values=None, **kwargs):
+        # re-infer freq as it may have changed (and always possible to infer
+        # from values for DatetimeIndex)
+        kwargs['freq'] = None
+        return super(DatetimeIndex, self)._shallow_copy_with_infer(values, **kwargs)
+
     @property
     def tzinfo(self):
         """

pandas/tseries/period.py

@@ -41,11 +41,13 @@ def f(self):
 
 
 def _get_ordinals(data, freq):
-    f = lambda x: Period(x, freq=freq).ordinal
-    if isinstance(data[0], Period):
+    if len(data) == 0:
+        return np.array([], dtype='int64')
+    elif isinstance(data[0], Period):
         return period.extract_ordinals(data, freq)
-    else:
-        return lib.map_infer(data, f)
+    if com.is_float_dtype(data):
+        raise ValueError("PeriodIndex can't be constructed from floats")
+    return lib.map_infer(data, lambda x: Period(x, freq=freq).ordinal)
 
 
 def dt64arr_to_periodarr(data, freq, tz):
@@ -188,9 +190,43 @@ def __new__(cls, data=None, ordinal=None, freq=None, start=None, end=None,
             else:
                 data, freq = cls._generate_range(start, end, periods,
                                                  freq, kwargs)
-        else:
-            ordinal, freq = cls._from_arraylike(data, freq, tz)
-            data = np.array(ordinal, dtype=np.int64, copy=False)
+            return cls._simple_new(data, name=name, freq=freq)
+
+        if isinstance(data, PeriodIndex):
+            if freq is None or freq == data.freq:
+                freq = data.freq
+                data = data.values
+            else:
+                base1, _ = _gfc(data.freq)
+                base2, _ = _gfc(freq)
+                data = period.period_asfreq_arr(
+                    data.values, base1, base2, 1)
+            return cls._simple_new(data, name=name, freq=freq)
+
+        if not isinstance(data, (np.ndarray, PeriodIndex,
+                                 DatetimeIndex, Int64Index)):
+            if lib.isscalar(data):
+                raise ValueError('PeriodIndex() must be called with a '
+                                 'collection of some kind, %r was passed'
+                                 % data)
+
+            # other iterable of some kind
+            if not isinstance(data, (list, tuple)):
+                data = list(data)
+
+            data = np.array(data, copy=False)
+
+        if freq is None and len(data) > 0:
+            freq = getattr(data[0], 'freq', None)
+        if freq is None:
+            raise ValueError('freq not specified and cannot be '
+                             'inferred from first element')
+
+        if np.issubdtype(data.dtype, np.datetime64):
+            data = dt64arr_to_periodarr(data, freq, tz)
+            return cls._simple_new(data, name=name, freq=freq)
+
+        data = _get_ordinals(data, freq)
 
         return cls._simple_new(data, name=name, freq=freq)
 
@@ -211,96 +247,23 @@ def _generate_range(cls, start, end, periods, freq, fields):
         return subarr, freq
 
     @classmethod
-    def _from_arraylike(cls, data, freq, tz):
-        if not isinstance(data, (np.ndarray, PeriodIndex,
-                                 DatetimeIndex, Int64Index)):
-            if lib.isscalar(data) or isinstance(data, Period):
-                raise ValueError('PeriodIndex() must be called with a '
-                                 'collection of some kind, %s was passed'
-                                 % repr(data))
-
-            # other iterable of some kind
-            if not isinstance(data, (list, tuple)):
-                data = list(data)
-
-            try:
-                data = com._ensure_int64(data)
-                if freq is None:
-                    raise ValueError('freq not specified')
-                data = np.array([Period(x, freq=freq).ordinal for x in data],
-                                dtype=np.int64)
-            except (TypeError, ValueError):
-                data = com._ensure_object(data)
-
-                if freq is None and len(data) > 0:
-                    freq = getattr(data[0], 'freq', None)
-
-                if freq is None:
-                    raise ValueError('freq not specified and cannot be '
-                                     'inferred from first element')
-
-                data = _get_ordinals(data, freq)
-        else:
-            if isinstance(data, PeriodIndex):
-                if freq is None or freq == data.freq:
-                    freq = data.freq
-                    data = data.values
-                else:
-                    base1, _ = _gfc(data.freq)
-                    base2, _ = _gfc(freq)
-                    data = period.period_asfreq_arr(data.values,
-                                                    base1, base2, 1)
-            else:
-                if freq is None and len(data) > 0:
-                    freq = getattr(data[0], 'freq', None)
-
-                if freq is None:
-                    raise ValueError('freq not specified and cannot be '
-                                     'inferred from first element')
-
-                if data.dtype != np.int64:
-                    if np.issubdtype(data.dtype, np.datetime64):
-                        data = dt64arr_to_periodarr(data, freq, tz)
-                    else:
-                        try:
-                            data = com._ensure_int64(data)
-                        except (TypeError, ValueError):
-                            data = com._ensure_object(data)
-                            data = _get_ordinals(data, freq)
-
-        return data, freq
-
-    @classmethod
-    def _simple_new(cls, values, name=None, freq=None, **kwargs):
+    def _simple_new(cls, data, name=None, freq=None, **kwargs):
+        """ PeriodIndex from array-like of either ints or Periods """
 
-        if not com.is_integer_dtype(values):
-            values = np.array(values, copy=False)
-            if (len(values) > 0 and com.is_float_dtype(values)):
-                raise TypeError("PeriodIndex can't take floats")
-            else:
-                return PeriodIndex(values, name=name, freq=freq, **kwargs)
+        if not com.is_integer_dtype(data):
+            return PeriodIndex(data, name=name, freq=freq, **kwargs)
 
-        values = np.array(values, dtype='int64', copy=False)
+        data = np.array(data, dtype='int64', copy=False)
 
         result = object.__new__(cls)
-        result._data = values
+        result._data = data
         result.name = name
         if freq is None:
             raise ValueError('freq is not specified')
         result.freq = Period._maybe_convert_freq(freq)
         result._reset_identity()
         return result
 
-    def _shallow_copy_with_infer(self, values=None, **kwargs):
-        """ we always want to return a PeriodIndex """
-        return self._shallow_copy(values=values, **kwargs)
-
-    def _shallow_copy(self, values=None, **kwargs):
-        if kwargs.get('freq') is None:
-            # freq must be provided
-            kwargs['freq'] = self.freq
-        return super(PeriodIndex, self)._shallow_copy(values=values, **kwargs)
-
     def _coerce_scalar_to_index(self, item):
         """
         we need to coerce a scalar to a compat for our index type
@@ -348,7 +311,7 @@ def __array_wrap__(self, result, context=None):
 
         if com.is_bool_dtype(result):
             return result
-        return PeriodIndex(result, freq=self.freq, name=self.name)
+        return self._shallow_copy(result)
 
     @property
     def _box_func(self):
@@ -646,7 +609,7 @@ def shift(self, n):
         values = self.values + n * self.freq.n
         if self.hasnans:
             values[self._isnan] = tslib.iNaT
-        return PeriodIndex(data=values, name=self.name, freq=self.freq)
+        return self._shallow_copy(values)
 
     @cache_readonly
     def dtype_str(self):
@@ -851,7 +814,7 @@ def _wrap_union_result(self, other, result):
 
     def _apply_meta(self, rawarr):
         if not isinstance(rawarr, PeriodIndex):
-            rawarr = PeriodIndex(rawarr, freq=self.freq)
+            rawarr = self._shallow_copy(rawarr)
         return rawarr
 
     def __getitem__(self, key):
@@ -869,9 +832,9 @@ def __getitem__(self, key):
                 # values = np.asarray(list(values), dtype=object)
                 # return values.reshape(result.shape)
 
-                return PeriodIndex(result, name=self.name, freq=self.freq)
+                return self._shallow_copy(result)
 
-            return PeriodIndex(result, name=self.name, freq=self.freq)
+            return self._shallow_copy(result)
 
     def _format_native_types(self, na_rep=u('NaT'), date_format=None,
                              **kwargs):
@@ -921,7 +884,7 @@ def append(self, other):
                 to_concat = [x.asobject.values for x in to_concat]
             else:
                 cat_values = np.concatenate([x.values for x in to_concat])
-                return PeriodIndex(cat_values, freq=self.freq, name=name)
+                return self._shallow_copy(cat_values)
 
         to_concat = [x.values if isinstance(x, Index) else x
                      for x in to_concat]
@@ -1143,3 +1106,4 @@ def period_range(start=None, end=None, periods=None, freq='D', name=None):
     """
     return PeriodIndex(start=start, end=end, periods=periods,
                        freq=freq, name=name)
+

pandas/tseries/tests/test_period.py

@@ -1769,12 +1769,15 @@ def test_constructor_simple_new_empty(self):
         result = idx._simple_new(idx, name='p', freq='M')
         assert_index_equal(result, idx)
 
-    def test_constructor_simple_new_floats(self):
+    def test_constructor_floats(self):
         # GH13079
-        for floats in [[1.1], np.array([1.1])]:
-            with self.assertRaises(TypeError):
+        for floats in [[1.1, 2.1], np.array([1.1, 2.1])]:
+            with self.assertRaises(ValueError):
                 pd.PeriodIndex._simple_new(floats, freq='M')
 
+            with self.assertRaises(ValueError):
+                pd.PeriodIndex(floats, freq='M')
+
     def test_shallow_copy_empty(self):
 
         # GH13067
@@ -3279,7 +3282,7 @@ def test_factorize(self):
     def test_recreate_from_data(self):
         for o in ['M', 'Q', 'A', 'D', 'B', 'T', 'S', 'L', 'U', 'N', 'H']:
             org = PeriodIndex(start='2001/04/01', freq=o, periods=1)
-            idx = PeriodIndex(org.values, freq=o)
+            idx = PeriodIndex(org, freq=o)
             tm.assert_index_equal(idx, org)
 
     def test_combine_first(self):