Merge commit 'v0.16.2-49-g3908ad5' into debian

* commit 'v0.16.2-49-g3908ad5':
  DOC: release note for pandas-dev#9607, as_blocks copy arg
  ENH: allow as_blocks to take a copy argument (pandas-dev#9607)
  BUG: pandas-dev#10228 resampling empty Series caused segfaults
  BUG #GH10425 test_categorical big-endian fix
  BUG: xref pandas-dev#10428, need platform_int as indexer
  ENH: GH10378 Pass kwargs to interpolation methods.

Author: yarikoptic

doc/source/whatsnew/v0.17.0.txt

@@ -31,6 +31,8 @@ New features
 Other enhancements
 ^^^^^^^^^^^^^^^^^^
 
+- ``.as_blocks`` will now take a ``copy`` optional argument to return a copy of the data, default is to copy (no change in behavior from prior versions), (:issue:`9607`)
+
 .. _whatsnew_0170.api:
 
 Backwards incompatible API changes
@@ -44,6 +46,7 @@ Other API Changes
 ^^^^^^^^^^^^^^^^^
 - Enable writing Excel files in :ref:`memory <_io.excel_writing_buffer>` using StringIO/BytesIO (:issue:`7074`)
 - Enable serialization of lists and dicts to strings in ExcelWriter (:issue:`8188`)
+- Allow passing `kwargs` to the interpolation methods (:issue:`10378`).
 
 .. _whatsnew_0170.deprecations:
 
@@ -72,9 +75,28 @@ Bug Fixes
 ~~~~~~~~~
 - Bug in ``DataFrame.apply`` when function returns categorical series. (:issue:`9573`)
 
+
 - Bug in ``Index.drop_duplicates`` dropping name(s) (:issue:`10115`)
+
+
 - Bug in ``pd.Series`` when setting a value on an empty ``Series`` whose index has a frequency. (:issue:`10193`)
+
+
 - Bug in ``DataFrame.reset_index`` when index contains `NaT`. (:issue:`10388`)
+
+
 - Bug in ``ExcelReader`` when worksheet is empty (:issue:`6403`)
+
+
 - Bug in ``Table.select_column`` where name is not preserved (:issue:`10392`)
+
+
 - Bug in ``DataFrame.interpolate`` with ``axis=1`` and ``inplace=True`` (:issue:`10395`)
+
+
+
+- Bug in ``test_categorical`` on big-endian builds (:issue:`10425`)
+
+
+
+- Bug that caused segfault when resampling an empty Series (:issue:`10228`)

pandas/algos.pyx

@@ -2157,6 +2157,8 @@ def group_nth_bin_object(ndarray[object, ndim=2] out,
     nobs = np.zeros((<object> out).shape, dtype=np.float64)
     resx = np.empty((<object> out).shape, dtype=object)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -2247,6 +2249,8 @@ def group_last_bin_object(ndarray[object, ndim=2] out,
     nobs = np.zeros((<object> out).shape, dtype=np.float64)
     resx = np.empty((<object> out).shape, dtype=object)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:

pandas/core/common.py

@@ -1588,7 +1588,8 @@ def backfill_2d(values, limit=None, mask=None, dtype=None):
     return values
 
 
-def _clean_interp_method(method, order=None):
+def _clean_interp_method(method, **kwargs):
+    order = kwargs.get('order')
     valid = ['linear', 'time', 'index', 'values', 'nearest', 'zero', 'slinear',
              'quadratic', 'cubic', 'barycentric', 'polynomial',
              'krogh', 'piecewise_polynomial',
@@ -1603,7 +1604,7 @@ def _clean_interp_method(method, order=None):
 
 
 def interpolate_1d(xvalues, yvalues, method='linear', limit=None,
-                   fill_value=None, bounds_error=False, order=None):
+                   fill_value=None, bounds_error=False, order=None, **kwargs):
     """
     Logic for the 1-d interpolation.  The result should be 1-d, inputs
     xvalues and yvalues will each be 1-d arrays of the same length.
@@ -1682,18 +1683,17 @@ def _interp_limit(invalid, limit):
                   'piecewise_polynomial', 'pchip']
     if method in sp_methods:
         new_x = new_x[firstIndex:]
-        xvalues = xvalues[firstIndex:]
 
         result[firstIndex:][invalid] = _interpolate_scipy_wrapper(
             valid_x, valid_y, new_x, method=method, fill_value=fill_value,
-            bounds_error=bounds_error, order=order)
+            bounds_error=bounds_error, order=order, **kwargs)
         if limit:
             result[violate_limit] = np.nan
         return result
 
 
 def _interpolate_scipy_wrapper(x, y, new_x, method, fill_value=None,
-                               bounds_error=False, order=None):
+                               bounds_error=False, order=None, **kwargs):
     """
     passed off to scipy.interpolate.interp1d. method is scipy's kind.
     Returns an array interpolated at new_x.  Add any new methods to
@@ -1734,7 +1734,7 @@ def _interpolate_scipy_wrapper(x, y, new_x, method, fill_value=None,
                                     bounds_error=bounds_error)
         new_y = terp(new_x)
     elif method == 'spline':
-        terp = interpolate.UnivariateSpline(x, y, k=order)
+        terp = interpolate.UnivariateSpline(x, y, k=order, **kwargs)
         new_y = terp(new_x)
     else:
         # GH 7295: need to be able to write for some reason
@@ -1746,7 +1746,7 @@ def _interpolate_scipy_wrapper(x, y, new_x, method, fill_value=None,
         if not new_x.flags.writeable:
             new_x = new_x.copy()
         method = alt_methods[method]
-        new_y = method(x, y, new_x)
+        new_y = method(x, y, new_x, **kwargs)
     return new_y
 
 

pandas/core/generic.py

@@ -2359,14 +2359,18 @@ def ftypes(self):
         return Series(self._data.get_ftypes(), index=self._info_axis,
                       dtype=np.object_)
 
-    def as_blocks(self):
+    def as_blocks(self, copy=True):
         """
         Convert the frame to a dict of dtype -> Constructor Types that each has
         a homogeneous dtype.
 
         NOTE: the dtypes of the blocks WILL BE PRESERVED HERE (unlike in
               as_matrix)
 
+        Parameters
+        ----------
+        copy : boolean, default True
+
         Returns
         -------
         values : a dict of dtype -> Constructor Types
@@ -2381,7 +2385,7 @@ def as_blocks(self):
         for dtype, blocks in bd.items():
             # Must combine even after consolidation, because there may be
             # sparse items which are never consolidated into one block.
-            combined = self._data.combine(blocks, copy=True)
+            combined = self._data.combine(blocks, copy=copy)
             result[dtype] = self._constructor(combined).__finalize__(self)
 
         return result
@@ -2896,6 +2900,7 @@ def interpolate(self, method='linear', axis=0, limit=None, inplace=False,
             Update the NDFrame in place if possible.
         downcast : optional, 'infer' or None, defaults to None
             Downcast dtypes if possible.
+        kwargs : keyword arguments to pass on to the interpolating function.
 
         Returns
         -------

pandas/core/index.py

@@ -5261,7 +5261,8 @@ def convert_indexer(start, stop, step, indexer=indexer, labels=labels):
                 # set that we have selected
                 from pandas import Series
                 mapper = Series(indexer)
-                result = Series(Index(labels.take(indexer)).isin(r).nonzero()[0])
+                indexer = labels.take(com._ensure_platform_int(indexer))
+                result = Series(Index(indexer).isin(r).nonzero()[0])
                 m = result.map(mapper).values
 
             else:

pandas/src/generate_code.py

@@ -751,6 +751,8 @@ def group_last_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     nobs = np.zeros_like(out)
     resx = np.empty_like(out)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -797,6 +799,8 @@ def group_nth_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     nobs = np.zeros_like(out)
     resx = np.empty_like(out)
 
+    if len(bin) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -948,6 +952,8 @@ def group_add_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     nobs = np.zeros_like(out)
     sumx = np.zeros_like(out)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -1064,6 +1070,8 @@ def group_prod_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     nobs = np.zeros_like(out)
     prodx = np.ones_like(out)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -1184,6 +1192,8 @@ def group_var_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     sumx = np.zeros_like(out)
     sumxx = np.zeros_like(out)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -1285,6 +1295,8 @@ def group_count_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
         ndarray[int64_t, ndim=2] nobs = np.zeros((out.shape[0], out.shape[1]),
                                                  dtype=np.int64)
 
+    if len(bins) == 0:
+        return
     ngroups = len(bins) + (bins[len(bins) - 1] != N)
 
     for i in range(N):
@@ -1329,6 +1341,8 @@ def group_min_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     minx = np.empty_like(out)
     minx.fill(%(inf_val)s)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -1453,6 +1467,8 @@ def group_max_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     maxx = np.empty_like(out)
     maxx.fill(-%(inf_val)s)
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -1629,6 +1645,8 @@ def group_mean_bin_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
     sumx = np.zeros_like(out)
 
     N, K = (<object> values).shape
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else:
@@ -1685,6 +1703,8 @@ def group_ohlc_%(name)s(ndarray[%(dest_type2)s, ndim=2] out,
         %(dest_type2)s vopen, vhigh, vlow, vclose, NA
         bint got_first = 0
 
+    if len(bins) == 0:
+        return
     if bins[len(bins) - 1] == len(values):
         ngroups = len(bins)
     else: