BUG: Empty PeriodIndex issues

closes #13067
closes #13212

Author: Maximilian Roos <[email protected]>

Closes #13079 from MaximilianR/period_resample_0 and squashes the following commits:

8c7b9db [Maximilian Roos] empty PeriodIndex issues

Author: max-sixty

doc/source/whatsnew/v0.18.2.txt

@@ -156,6 +156,9 @@ Bug Fixes
 
 
 - Bug in ``PeriodIndex`` and ``Period`` subtraction raises ``AttributeError`` (:issue:`13071`)
+- Bug in ``.resample(..)`` with a ``PeriodIndex`` not changing its ``freq`` appropriately when empty (:issue:`13067`)
+- Bug in ``PeriodIndex`` construction returning a ``float64`` index in some circumstances (:issue:`13067`)
+- Bug in ``.resample(..)`` with a ``PeriodIndex`` not retaining its type or name with an empty ``DataFrame``appropriately when empty (:issue:`13212`)
 
 
 
@@ -175,4 +178,7 @@ Bug Fixes
 - Bug in ``Period`` addition raises ``TypeError`` if ``Period`` is on right hand side (:issue:`13069`)
 - Bug in ``Peirod`` and ``Series`` or ``Index`` comparison raises ``TypeError`` (:issue:`13200`)
 - Bug in ``pd.set_eng_float_format()`` that would prevent NaN's from formatting (:issue:`11981`)
+
+
+
 - Bug in ``groupby`` where ``apply`` returns different result depending on whether first result is ``None`` or not (:issue:`12824`)

pandas/core/groupby.py

@@ -37,7 +37,7 @@
                                is_datetime_or_timedelta_dtype, is_bool,
                                is_bool_dtype, AbstractMethodError,
                                _maybe_fill)
-from pandas.core.config import option_context
+from pandas.core.config import option_context, is_callable
 import pandas.lib as lib
 from pandas.lib import Timestamp
 import pandas.tslib as tslib
@@ -643,9 +643,20 @@ def apply(self, func, *args, **kwargs):
 
         func = self._is_builtin_func(func)
 
-        @wraps(func)
-        def f(g):
-            return func(g, *args, **kwargs)
+        # this is needed so we don't try and wrap strings. If we could
+        # resolve functions to their callable functions prior, this
+        # wouldn't be needed
+        if args or kwargs:
+            if is_callable(func):
+
+                @wraps(func)
+                def f(g):
+                    return func(g, *args, **kwargs)
+            else:
+                raise ValueError('func must be a callable if args or '
+                                 'kwargs are supplied')
+        else:
+            f = func
 
         # ignore SettingWithCopy here in case the user mutates
         with option_context('mode.chained_assignment', None):
@@ -2675,7 +2686,7 @@ def _wrap_transformed_output(self, output, names=None):
     def _wrap_applied_output(self, keys, values, not_indexed_same=False):
         if len(keys) == 0:
             # GH #6265
-            return Series([], name=self.name)
+            return Series([], name=self.name, index=keys)
 
         def _get_index():
             if self.grouper.nkeys > 1:
@@ -3222,8 +3233,7 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
         from pandas.core.index import _all_indexes_same
 
         if len(keys) == 0:
-            # XXX
-            return DataFrame({})
+            return DataFrame(index=keys)
 
         key_names = self.grouper.names
 
@@ -3646,17 +3656,12 @@ def _gotitem(self, key, ndim, subset=None):
     def _wrap_generic_output(self, result, obj):
         result_index = self.grouper.levels[0]
 
-        if result:
-            if self.axis == 0:
-                result = DataFrame(result, index=obj.columns,
-                                   columns=result_index).T
-            else:
-                result = DataFrame(result, index=obj.index,
-                                   columns=result_index)
+        if self.axis == 0:
+            return DataFrame(result, index=obj.columns,
+                             columns=result_index).T
         else:
-            result = DataFrame(result)
-
-        return result
+            return DataFrame(result, index=obj.index,
+                             columns=result_index)
 
     def _get_data_to_aggregate(self):
         obj = self._obj_with_exclusions

pandas/tests/indexing/test_indexing.py

@@ -4250,7 +4250,8 @@ def test_series_partial_set_period(self):
                 pd.Period('2011-01-03', freq='D')]
         exp = Series([np.nan, 0.2, np.nan],
                      index=pd.PeriodIndex(keys, name='idx'), name='s')
-        assert_series_equal(ser.loc[keys], exp, check_index_type=True)
+        result = ser.loc[keys]
+        assert_series_equal(result, exp)
 
     def test_partial_set_invalid(self):
 

pandas/tests/test_groupby.py

@@ -775,11 +775,11 @@ def test_agg_apply_corner(self):
         # DataFrame
         grouped = self.tsframe.groupby(self.tsframe['A'] * np.nan)
         exp_df = DataFrame(columns=self.tsframe.columns, dtype=float,
-                           index=pd.Index(
-                               [], dtype=np.float64))
+                           index=pd.Index([], dtype=np.float64))
         assert_frame_equal(grouped.sum(), exp_df, check_names=False)
         assert_frame_equal(grouped.agg(np.sum), exp_df, check_names=False)
-        assert_frame_equal(grouped.apply(np.sum), DataFrame({}, dtype=float))
+        assert_frame_equal(grouped.apply(np.sum), exp_df.iloc[:, :0],
+                           check_names=False)
 
     def test_agg_grouping_is_list_tuple(self):
         from pandas.core.groupby import Grouping

pandas/tseries/period.py

@@ -17,9 +17,9 @@
 from pandas.core.base import _shared_docs
 
 import pandas.core.common as com
-from pandas.core.common import (isnull, _INT64_DTYPE, _maybe_box,
-                                _values_from_object, ABCSeries,
-                                is_integer, is_float, is_object_dtype)
+from pandas.core.common import (
+    isnull, _INT64_DTYPE, _maybe_box, _values_from_object, ABCSeries,
+    is_integer, is_float)
 from pandas import compat
 from pandas.compat.numpy import function as nv
 from pandas.util.decorators import Appender, cache_readonly, Substitution
@@ -271,10 +271,15 @@ def _from_arraylike(cls, data, freq, tz):
 
     @classmethod
     def _simple_new(cls, values, name=None, freq=None, **kwargs):
-        if not getattr(values, 'dtype', None):
+
+        if not com.is_integer_dtype(values):
             values = np.array(values, copy=False)
-        if is_object_dtype(values):
-            return PeriodIndex(values, name=name, freq=freq, **kwargs)
+            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)
+
+        values = np.array(values, dtype='int64', copy=False)
 
         result = object.__new__(cls)
         result._data = values

pandas/tseries/resample.py

@@ -21,6 +21,7 @@
 from pandas.compat.numpy import function as nv
 
 from pandas.lib import Timestamp
+from pandas._period import IncompatibleFrequency
 import pandas.lib as lib
 import pandas.tslib as tslib
 
@@ -795,27 +796,27 @@ def _downsample(self, how, **kwargs):
         ax = self.ax
 
         new_index = self._get_new_index()
-        if len(new_index) == 0:
-            return self._wrap_result(self._selected_obj.reindex(new_index))
 
         # Start vs. end of period
         memb = ax.asfreq(self.freq, how=self.convention)
 
         if is_subperiod(ax.freq, self.freq):
             # Downsampling
-            rng = np.arange(memb.values[0], memb.values[-1] + 1)
-            bins = memb.searchsorted(rng, side='right')
+            if len(new_index) == 0:
+                bins = []
+            else:
+                rng = np.arange(memb.values[0], memb.values[-1] + 1)
+                bins = memb.searchsorted(rng, side='right')
             grouper = BinGrouper(bins, new_index)
             return self._groupby_and_aggregate(how, grouper=grouper)
         elif is_superperiod(ax.freq, self.freq):
             return self.asfreq()
         elif ax.freq == self.freq:
             return self.asfreq()
 
-        raise ValueError('Frequency {axfreq} cannot be '
-                         'resampled to {freq}'.format(
-                             axfreq=ax.freq,
-                             freq=self.freq))
+        raise IncompatibleFrequency(
+            'Frequency {} cannot be resampled to {}, as they are not '
+            'sub or super periods'.format(ax.freq, self.freq))
 
     def _upsample(self, method, limit=None):
         """
@@ -838,9 +839,6 @@ def _upsample(self, method, limit=None):
         obj = self.obj
         new_index = self._get_new_index()
 
-        if len(new_index) == 0:
-            return self._wrap_result(self._selected_obj.reindex(new_index))
-
         # Start vs. end of period
         memb = ax.asfreq(self.freq, how=self.convention)
 

pandas/tseries/tests/test_period.py

@@ -1742,13 +1742,45 @@ def test_constructor_datetime64arr(self):
         self.assertRaises(ValueError, PeriodIndex, vals, freq='D')
 
     def test_constructor_simple_new(self):
-        idx = period_range('2007-01', name='p', periods=20, freq='M')
+        idx = period_range('2007-01', name='p', periods=2, freq='M')
         result = idx._simple_new(idx, 'p', freq=idx.freq)
         self.assertTrue(result.equals(idx))
 
         result = idx._simple_new(idx.astype('i8'), 'p', freq=idx.freq)
         self.assertTrue(result.equals(idx))
 
+        result = idx._simple_new(
+            [pd.Period('2007-01', freq='M'), pd.Period('2007-02', freq='M')],
+            'p', freq=idx.freq)
+        self.assertTrue(result.equals(idx))
+
+        result = idx._simple_new(
+            np.array([pd.Period('2007-01', freq='M'),
+                      pd.Period('2007-02', freq='M')]),
+            'p', freq=idx.freq)
+        self.assertTrue(result.equals(idx))
+
+    def test_constructor_simple_new_empty(self):
+        # GH13079
+        idx = PeriodIndex([], freq='M', name='p')
+        result = idx._simple_new(idx, name='p', freq='M')
+        assert_index_equal(result, idx)
+
+    def test_constructor_simple_new_floats(self):
+        # GH13079
+        for floats in [[1.1], np.array([1.1])]:
+            with self.assertRaises(TypeError):
+                pd.PeriodIndex._simple_new(floats, freq='M')
+
+    def test_shallow_copy_empty(self):
+
+        # GH13067
+        idx = PeriodIndex([], freq='M')
+        result = idx._shallow_copy()
+        expected = idx
+
+        assert_index_equal(result, expected)
+
     def test_constructor_nat(self):
         self.assertRaises(ValueError, period_range, start='NaT',
                           end='2011-01-01', freq='M')