fixup

Author: kernc

pandas/core/internals.py

@@ -1760,16 +1760,15 @@ def putmask(self, mask, new, align=True, inplace=False, axis=0,
         """
         inplace = validate_bool_kwarg(inplace, 'inplace')
 
-        # use block's copy logic.
+        new_values, _, new, _ = self._try_coerce_args(self.values, new)
         # .values may be an Index which does shallow copy by default
-        new_values = self.values if inplace else self.copy().values
-        new_values, _, new, _ = self._try_coerce_args(new_values, new)
+        if not inplace:
+            new_values = new_values.copy(deep=True)
 
-        # Cannot modify a SparseArray
         if is_sparse(new_values):
-            new_values = new_values.to_dense()
-            if is_sparse(mask):
-                mask = mask.to_dense()
+            indexer = mask.to_dense().values.ravel().nonzero()[0]
+            block = self.copy().setitem(indexer, new)
+            return [block]
 
         if isinstance(new, np.ndarray) and len(new) == len(mask):
             new = new[mask]
@@ -2817,7 +2816,10 @@ def _can_hold_element(self, element):
         return np.can_cast(np.asarray(element).dtype, self.sp_values.dtype)
 
     def _try_coerce_result(self, result):
-        if np.ndim(result) > 0 and not is_sparse(result):
+        if (
+                    # isinstance(result, np.ndarray) and
+                np.ndim(result) > 0
+                and not is_sparse(result)):
             result = SparseArray(result, kind=self.kind,
                                  fill_value=self.fill_value, dtype=self.dtype)
         return result
@@ -3819,7 +3821,8 @@ def fast_xs(self, loc):
             # Such assignment may incorrectly coerce NaT to None
             # result[blk.mgr_locs] = blk._slice((slice(None), loc))
             for i, rl in enumerate(blk.mgr_locs):
-                result[rl] = blk._try_coerce_result(blk.iget((i, loc)))
+                # result[rl] = blk._try_coerce_result(blk.iget((i, loc)))
+                result[rl] = blk.iget((i, loc))
 
         return result
 

pandas/core/sparse/array.py

@@ -402,7 +402,7 @@ def set_values(self, indexer, value):
             warnings.warn(
                 'Setting SparseSeries/Array values is particularly '
                 'inefficient when indexing with multiple keys because the '
-                'whole series series is made dense interim.',
+                'whole series is made dense interim.',
                 PerformanceWarning, stacklevel=2)
 
             values = self.to_dense()
@@ -412,7 +412,7 @@ def set_values(self, indexer, value):
 
         warnings.warn(
             'Setting SparseSeries/Array values is inefficient '
-            '(a copy of data is made)', PerformanceWarning, stacklevel=2)
+            '(a copy of data is made).', PerformanceWarning, stacklevel=2)
 
         # If label already in sparse index, just switch the value on a copy
         idx = self.sp_index.lookup(indexer)
@@ -428,7 +428,9 @@ def set_values(self, indexer, value):
 
         indices = np.insert(indices, pos, indexer)
         sp_values = np.insert(self.sp_values, pos, value)
-        sp_index = _make_index(self.sp_index.length, indices, self.kind)
+        # Length can be increased when adding a new value into index
+        length = max(self.sp_index.length, indexer + 1)
+        sp_index = _make_index(length, indices, self.kind)
 
         return SparseArray(sp_values, sparse_index=sp_index,
                            fill_value=self.fill_value)

pandas/core/sparse/series.py

@@ -531,25 +531,16 @@ def set_value(self, label, value, takeable=False):
         return self._set_value(label, value, takeable=takeable)
 
     def _set_value(self, label, value, takeable=False):
-        self._data = self._data.copy().setitem(indexer=label, value=value)
+        self._data = self._data.copy()
+        try:
+            idx = self.index.get_loc(label)
+        except KeyError:
+            idx = len(self)
+            self._data.axes[0] = self._data.index.append(Index([label]))
+        self._data = self._data.setitem(indexer=idx, value=value)
         return self
     _set_value.__doc__ = set_value.__doc__
 
-    def _set_values(self, key, value):
-
-        # this might be inefficient as we have to recreate the sparse array
-        # rather than setting individual elements, but have to convert
-        # the passed slice/boolean that's in dense space into a sparse indexer
-        # not sure how to do that!
-        if isinstance(key, Series):
-            key = key.values
-
-        values = self.values.to_dense()
-        values[key] = _index.convert_scalar(values, value)
-        values = SparseArray(values, fill_value=self.fill_value,
-                             kind=self.kind)
-        self._data = SingleBlockManager(values, self.index)
-
     def to_dense(self, sparse_only=False):
         """
         Convert SparseSeries to a Series.

pandas/tests/sparse/test_frame.py

@@ -15,6 +15,7 @@
     is_object_dtype,
     is_float)
 from pandas.core.indexes.datetimes import DatetimeIndex
+from pandas.errors import PerformanceWarning
 from pandas.tseries.offsets import BDay
 from pandas.util import testing as tm
 from pandas.compat import lrange
@@ -1534,7 +1535,7 @@ def test_quantile_multi(self):
         tm.assert_sp_frame_equal(result, sparse_expected)
 
 
-def _test_assignment(kind, indexer, key=None):
+def _test_assignment(kind, indexer, key=None, expect_warning=True):
     arr = np.array([[1, nan],
                     [nan, 1]])
     df = DataFrame(arr, copy=True)
@@ -1546,7 +1547,11 @@ def get_indexer(df):
     if key is None:
         key = pd.isnull(sdf).to_sparse()
 
-    get_indexer(sdf)[key] = 2
+    if expect_warning:
+        with tm.assert_produces_warning(PerformanceWarning):
+            get_indexer(sdf)[key] = 2
+    else:
+        get_indexer(sdf)[key] = 2
 
     get_indexer(df)[key] = 2
     res = df.to_sparse(kind=kind)
@@ -1571,12 +1576,13 @@ def test_frame_assignment_loc(spindex_kind, indexer, key):
     _test_assignment(spindex_kind, indexer, key)
 
 
-@pytest.mark.parametrize('key', [None, [0, 1], [True, False]])
+@pytest.mark.parametrize('key', [None, [True, False]])
 def test_frame_assignment_setitem(spindex_kind, key):
     _test_assignment(spindex_kind, None, key)
 
 
 @pytest.mark.parametrize('indexer', ['loc', 'at'])
 @pytest.mark.parametrize('key', [3])
 def test_frame_assignment_extend_index(spindex_kind, indexer, key):
-    _test_assignment(spindex_kind, indexer, key)
+    _test_assignment(spindex_kind, indexer, key,
+                     expect_warning=indexer == 'at')

pandas/tests/sparse/test_series.py

@@ -11,6 +11,7 @@
 
 from pandas import (Series, DataFrame, bdate_range,
                     isna, compat, _np_version_under1p12)
+from pandas.errors import PerformanceWarning
 from pandas.tseries.offsets import BDay
 import pandas.util.testing as tm
 from pandas.compat import range
@@ -1557,6 +1558,8 @@ def test_series_assignment(kind, indexer, key):
     res = SparseSeries(res, kind=kind)
 
     ss_setitem = getattr(ss, indexer) if indexer else ss
-    ss_setitem[key] = 1
+
+    with tm.assert_produces_warning(PerformanceWarning):
+        ss_setitem[key] = 1
 
     tm.assert_sp_series_equal(ss, res)