ENH: array of Periods to PeriodIndex handling, close #1215

Author: wesm

RELEASE.rst

@@ -48,6 +48,8 @@ pandas 0.8.1
   - Always apply passed functions in ``resample``, even if upsampling (#1596)
   - Avoid unnecessary copies in DataFrame constructor with explicit dtype (#1572)
   - Cleaner DatetimeIndex string representation with 1 or 2 elements (#1611)
+  - Improve performance of array-of-Period to PeriodIndex, convert such arrays
+    to PeriodIndex inside Index (#1215)
 
 **Bug fixes**
 

pandas/core/index.py

@@ -38,6 +38,12 @@ class InvalidIndexError(Exception):
 
 _o_dtype = np.dtype(object)
 
+
+def _shouldbe_timestamp(obj):
+    return (lib.is_datetime_array(obj) or lib.is_datetime64_array(obj)
+            or lib.is_timestamp_array(obj))
+
+
 class Index(np.ndarray):
     """
     Immutable ndarray implementing an ordered, sliceable set. The basic object
@@ -100,12 +106,14 @@ def __new__(cls, data, dtype=None, copy=False, name=None):
             subarr = com._asarray_tuplesafe(data, dtype=object)
 
         if dtype is None:
-            if (lib.is_datetime_array(subarr)
-                or lib.is_datetime64_array(subarr)
-                or lib.is_timestamp_array(subarr)):
+            if _shouldbe_timestamp(subarr):
                 from pandas.tseries.index import DatetimeIndex
                 return DatetimeIndex(subarr, copy=copy, name=name)
 
+            if lib.is_period_array(subarr):
+                from pandas.tseries.period import PeriodIndex
+                return PeriodIndex(subarr, name=name)
+
             if lib.is_integer_array(subarr):
                 return Int64Index(subarr.astype('i8'), name=name)
 

pandas/src/inference.pyx

@@ -256,6 +256,33 @@ def is_time_array(ndarray[object] values):
             return False
     return True
 
+def is_period_array(ndarray[object] values):
+    cdef int i, n = len(values)
+    from pandas import Period
+
+    if n == 0:
+        return False
+    for i in range(n):
+        if not isinstance(values[i], Period):
+            return False
+    return True
+
+def extract_ordinals(ndarray[object] values, freq):
+    cdef:
+        Py_ssize_t i, n = len(values)
+        ndarray[int64_t] ordinals = np.empty(n, dtype=np.int64)
+        object p
+
+    for i in range(n):
+        p = values[i]
+        ordinals[i] = p.ordinal
+        if p.freq != freq:
+            raise ValueError("%s is wrong freq" % p)
+
+    return ordinals
+
+
+
 def maybe_convert_numeric(ndarray[object] values, set na_values,
                           convert_empty=True):
     '''

pandas/tseries/period.py

@@ -404,20 +404,12 @@ def _get_date_and_freq(value, freq):
     return dt, freq
 
 
-def _period_unbox(key, check=None):
-    '''
-    Period-like => int64
-    '''
-    if not isinstance(key, Period):
-        key = Period(key, freq=check)
-    elif check is not None:
-        if key.freq != check:
-            raise ValueError("%s is wrong freq" % key)
-    return np.int64(key.ordinal)
-
-def _period_unbox_array(arr, check=None):
-    unboxer = np.frompyfunc(lambda x: _period_unbox(x, check=check), 1, 1)
-    return unboxer(arr)
+def _get_ordinals(data, freq):
+    f = lambda x: Period(x, freq=freq).ordinal
+    if isinstance(data[0], Period):
+        return lib.extract_ordinals(data, freq)
+    else:
+        return lib.map_infer(data, f)
 
 def dt64arr_to_periodarr(data, freq):
     if data.dtype != np.dtype('M8[ns]'):
@@ -575,18 +567,22 @@ def _from_arraylike(cls, data, freq):
                 data = list(data)
 
             try:
-                data = np.array(data, dtype='i8')
+                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 = np.array(data, dtype='O')
+                data = com._ensure_object(data)
 
-            if freq is None and len(data) > 0:
-                freq = getattr(data[0], 'freq', None)
+                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 freq is None:
+                    raise ValueError('freq not specified and cannot be '
+                                     'inferred from first element')
 
-            data = _period_unbox_array(data, check=freq)
+                data = _get_ordinals(data, freq)
         else:
             if isinstance(data, PeriodIndex):
                 if freq is None or freq == data.freq:
@@ -610,10 +606,10 @@ def _from_arraylike(cls, data, freq):
                     pass
                 else:
                     try:
-                        data = data.astype('i8')
+                        data = com._ensure_int64(data)
                     except (TypeError, ValueError):
-                        data = data.astype('O')
-                        data = _period_unbox_array(data, check=freq)
+                        data = com._ensure_object(data)
+                        data = _get_ordinals(data, freq)
 
         return data, freq
 

pandas/tseries/tests/test_period.py

@@ -19,6 +19,7 @@
 import pandas.tseries.period as pmod
 
 import pandas.core.datetools as datetools
+import pandas as pd
 import numpy as np
 randn = np.random.randn
 
@@ -1761,6 +1762,13 @@ def test_map(self):
         exp = [x.ordinal for x in index]
         self.assert_(np.array_equal(result, exp))
 
+    def test_convert_array_of_periods(self):
+        rng = period_range('1/1/2000', periods=20, freq='D')
+        periods = list(rng)
+
+        result = pd.Index(periods)
+        self.assert_(isinstance(result, PeriodIndex))
+
 def _permute(obj):
     return obj.take(np.random.permutation(len(obj)))