Segfault with pd.tslib.get_period_field FIX

doc/source/basics.rst

@@ -724,16 +724,16 @@ We illustrate these fill methods on a simple TimeSeries:
    ts2.reindex(ts.index, method='ffill')
    ts2.reindex(ts.index, method='bfill')
 
+Note these methods require that the indexes are **order increasing**.
+
 Note the same result could have been achieved using :ref:`fillna
 <missing_data.fillna>`:
 
 .. ipython:: python
 
    ts2.reindex(ts.index).fillna(method='ffill')
 
-Note these methods generally assume that the indexes are **sorted**. They may
-be modified in the future to be a bit more flexible but as time series data is
-ordered most of the time anyway, this has not been a major priority.
+Note that this method does not check the order of the index.
 
 .. _basics.drop:
 

doc/source/missing_data.rst

@@ -205,6 +205,9 @@ To remind you, these are the available filling methods:
 With time series data, using pad/ffill is extremely common so that the "last
 known value" is available at every time point.
 
+The ``ffill()`` function is equivalent to ``fillna(method='ffill')``
+and ``bfill()`` is equivalent to ``fillna(method='bfill')``
+
 .. _missing_data.dropna:
 
 Dropping axis labels with missing data: dropna

doc/source/release.rst

@@ -50,6 +50,8 @@ pandas 0.13
 
 **API Changes**
 
+  - ``DataFrame.reindex()`` and forward/backward filling now raises ValueError
+    if either index is not monotonic (:issue: `4484`).
   - ``pandas`` now is Python 2/3 compatible without the need for 2to3 thanks to
     @jtratner. As a result, pandas now uses iterators more extensively. This
     also led to the introduction of substantive parts of the Benjamin

pandas/core/index.py

@@ -811,12 +811,12 @@ def get_indexer(self, target, method=None, limit=None):
                             'objects')
 
         if method == 'pad':
-            if not self.is_monotonic:
-                raise AssertionError('Must be monotonic for forward fill')
+            if not self.is_monotonic or not target.is_monotonic:
+                raise ValueError('Must be monotonic for forward fill')
             indexer = self._engine.get_pad_indexer(target.values, limit)
         elif method == 'backfill':
-            if not self.is_monotonic:
-                raise AssertionError('Must be monotonic for backward fill')
+            if not self.is_monotonic or not target.is_monotonic:
+                raise ValueError('Must be monotonic for backward fill')
             indexer = self._engine.get_backfill_indexer(target.values, limit)
         elif method is None:
             indexer = self._engine.get_indexer(target.values)

pandas/tests/test_frame.py

@@ -1629,6 +1629,29 @@ def test_nested_exception(self):
             repr(df)
         except Exception as e:
             self.assertNotEqual(type(e), UnboundLocalError)
+
+    def test_reverse_reindex_ffill_raises(self):
+        dr = pd.date_range('2013-08-01', periods=6, freq='B')
+        data = np.random.randn(6,1)
+        df = pd.DataFrame(data, index=dr, columns=list('A'))
+        df['A'][3] = np.nan
+        df_rev = pd.DataFrame(data, index=dr[::-1], columns=list('A'))
+        # Reverse index is not 'monotonic'
+        self.assertRaises(ValueError, df_rev.reindex, df.index, method='pad')
+        self.assertRaises(ValueError, df_rev.reindex, df.index, method='ffill')
+        self.assertRaises(ValueError, df_rev.reindex, df.index, method='bfill')
+
+    def test_reversed_reindex_ffill_raises(self):
+        dr = pd.date_range('2013-08-01', periods=6, freq='B')
+        data = np.random.randn(6,1)
+        df = pd.DataFrame(data, index=dr, columns=list('A'))
+        df['A'][3] = np.nan
+        df = pd.DataFrame(data, index=dr, columns=list('A'))
+        # Reversed reindex is not 'monotonic'
+        self.assertRaises(ValueError, df.reindex, dr[::-1], method='pad')
+        self.assertRaises(ValueError, df.reindex, dr[::-1], method='ffill')
+        self.assertRaises(ValueError, df.reindex, dr[::-1], method='bfill')
+
 
 _seriesd = tm.getSeriesData()
 _tsd = tm.getTimeSeriesData()

pandas/tests/test_tslib.py

@@ -0,0 +1,18 @@
+import unittest
+
+import numpy as np
+import pandas as pd
+
+class TestPeriodField(unittest.TestCase):
+    _multiprocess_can_split_ = True
+
+    def test_get_period_field_raises_on_out_of_range(self):
+        self.assertRaises(ValueError, pd.tslib.get_period_field, -1, 0, 0)
+
+    def test_get_period_field_array_raises_on_out_of_range(self):
+        self.assertRaises(ValueError, pd.tslib.get_period_field_arr, -1, np.empty(1), 0)
+
+if __name__ == '__main__':
+    import nose
+    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
+                   exit=False)

pandas/tseries/tests/test_timeseries.py

@@ -546,7 +546,7 @@ def test_pad_require_monotonicity(self):
 
         rng2 = rng[::2][::-1]
 
-        self.assertRaises(AssertionError, rng2.get_indexer, rng,
+        self.assertRaises(ValueError, rng2.get_indexer, rng,
                           method='pad')
 
     def test_frame_ctor_datetime64_column(self):

pandas/tslib.pyx

@@ -2417,6 +2417,8 @@ ctypedef int (*accessor)(int64_t ordinal, int freq) except INT32_MIN
 
 def get_period_field(int code, int64_t value, int freq):
     cdef accessor f = _get_accessor_func(code)
+    if <long>f == <long>NULL:
+        raise ValueError('Unrecognized code: %s' % code)
     return f(value, freq)
 
 def get_period_field_arr(int code, ndarray[int64_t] arr, int freq):
@@ -2426,6 +2428,8 @@ def get_period_field_arr(int code, ndarray[int64_t] arr, int freq):
         accessor f
 
     f = _get_accessor_func(code)
+    if <long>f == <long>NULL:
+        raise ValueError('Unrecognized code: %s' % code)
 
     sz = len(arr)
     out = np.empty(sz, dtype=np.int64)
@@ -2460,8 +2464,7 @@ cdef accessor _get_accessor_func(int code):
         return &pday_of_year
     elif code == 10:
         return &pweekday
-    else:
-        raise ValueError('Unrecognized code: %s' % code)
+    return NULL
 
 
 def extract_ordinals(ndarray[object] values, freq):