TST: unit testing and buglets in SparseArray, #436

Author: wesm

pandas/__init__.py

@@ -20,14 +20,14 @@
 from pandas.info import __doc__
 
 from pandas.core.api import *
+from pandas.sparse.api import *
+from pandas.stats.api import *
+
 from pandas.core.common import set_printoptions
 from pandas.core.common import set_eng_float_format
 from pandas.io.parsers import read_csv, read_table, read_clipboard, ExcelFile
 from pandas.io.pytables import HDFStore
-from pandas.stats.api import *
 from pandas.util.testing import debug
 
 from pandas.tools.pivot import pivot_table
 
-from pandas.sparse.api import (SparseArray, SparseSeries, SparseDataFrame,
-                               SparsePanel)

pandas/sparse/api.py

@@ -1,5 +1,7 @@
+# pylint: disable=W0611
+
 from pandas.sparse.array import SparseArray
 from pandas.sparse.list import SparseList
-from pandas.sparse.series import SparseSeries
+from pandas.sparse.series import SparseSeries, SparseTimeSeries
 from pandas.sparse.frame import SparseDataFrame
 from pandas.sparse.panel import SparsePanel

pandas/sparse/array.py

@@ -200,19 +200,21 @@ def __repr__(self):
     __rfloordiv__ = _sparse_op_wrap(lambda x, y: y // x, 'floordiv')
     __rpow__ = _sparse_op_wrap(lambda x, y: y ** x, '__rpow__')
 
+    def disable(self, other):
+        raise NotImplementedError('inplace binary ops not supported')
     # Inplace operators
-    __iadd__ = __add__
-    __isub__ = __sub__
-    __imul__ = __mul__
-    __itruediv__ = __truediv__
-    __ifloordiv__ = __floordiv__
-    __ipow__ = __pow__
+    __iadd__ = disable
+    __isub__ = disable
+    __imul__ = disable
+    __itruediv__ = disable
+    __ifloordiv__ = disable
+    __ipow__ = disable
 
     # Python 2 division operators
     if not py3compat.PY3:
         __div__ = _sparse_op_wrap(operator.div, 'div')
         __rdiv__ = _sparse_op_wrap(lambda x, y: y / x, '__rdiv__')
-        __idiv__ = __div__
+        __idiv__ = disable
 
     @property
     def values(self):
@@ -240,6 +242,14 @@ def __getitem__(self, key):
             data_slice = self.values[key]
             return self._constructor(data_slice)
 
+    def __getslice__(self, i, j):
+        if i < 0:
+            i -= len(self)
+        if j < 0:
+            j -= len(self)
+        slobj = slice(i, j)
+        return self.__getitem__(slobj)
+
     def _get_val_at(self, loc):
         n = len(self)
         if loc < 0:

pandas/sparse/frame.py

@@ -218,13 +218,13 @@ def _set_item(self, key, value):
                                           kind=self.default_kind)
         if hasattr(value, '__iter__'):
             if isinstance(value, Series):
-                cleanSeries = value.reindex(self.index)
+                clean_series = value.reindex(self.index)
                 if not isinstance(value, SparseSeries):
-                    cleanSeries = sp_maker(cleanSeries)
+                    clean_series = sp_maker(clean_series)
             else:
-                cleanSeries = sp_maker(value)
+                clean_series = sp_maker(value)
 
-            self._series[key] = cleanSeries
+            self._series[key] = clean_series
         # Scalar
         else:
             self._series[key] = sp_maker(value)

pandas/sparse/list.py

@@ -7,8 +7,12 @@ class SparseList(object):
     """
     Data structure for accumulating data to be converted into a
     SparseArray. Has similar API to the standard Python list
-    """
 
+    Parameters
+    ----------
+    data : scalar or array-like
+    fill_value : scalar, default NaN
+    """
     def __init__(self, data=None, fill_value=np.nan):
         self.fill_value = fill_value
         self._chunks = []
@@ -104,6 +108,13 @@ def to_array(self):
         return self._chunks[0]
 
     def append(self, value):
+        """
+        Append element or array-like chunk of data to the SparseList
+
+        Parameters
+        ----------
+        value: scalar or array-like
+        """
         if np.isscalar(value):
             value = [value]
 

pandas/sparse/series.py

@@ -75,17 +75,17 @@ class SparseSeries(SparseArray, Series):
     def __new__(cls, data, index=None, sparse_index=None, kind='block',
                 fill_value=None, name=None, copy=False):
 
-        is_sparse_series = isinstance(data, SparseSeries)
+        is_sparse_array = isinstance(data, SparseArray)
         if fill_value is None:
-            if is_sparse_series:
+            if is_sparse_array:
                 fill_value = data.fill_value
             else:
                 fill_value = nan
 
-        if is_sparse_series:
-            if index is None:
+        if is_sparse_array:
+            if isinstance(data, SparseSeries) and index is None:
                 index = data.index
-            else:
+            elif index is not None:
                 assert(len(index) == len(data))
 
             sparse_index = data.sp_index
@@ -236,19 +236,10 @@ def __repr__(self):
     __rfloordiv__ = _sparse_op_wrap(lambda x, y: y // x, 'floordiv')
     __rpow__ = _sparse_op_wrap(lambda x, y: y ** x, '__rpow__')
 
-    # Inplace operators
-    __iadd__ = __add__
-    __isub__ = __sub__
-    __imul__ = __mul__
-    __itruediv__ = __truediv__
-    __ifloordiv__ = __floordiv__
-    __ipow__ = __pow__
-
     # Python 2 division operators
     if not py3compat.PY3:
         __div__ = _sparse_op_wrap(operator.div, 'div')
         __rdiv__ = _sparse_op_wrap(lambda x, y: y / x, '__rdiv__')
-        __idiv__ = __div__
 
     def __getitem__(self, key):
         """

pandas/sparse/tests/test_array.py

@@ -1,8 +1,66 @@
+from numpy import nan, ndarray
 import numpy as np
 
+import operator
 import unittest
 
+from pandas.sparse.api import SparseArray
+from pandas.util.testing import assert_almost_equal
+
+def assert_sp_array_equal(left, right):
+    assert_almost_equal(left.sp_values, right.sp_values)
+    assert(left.sp_index.equals(right.sp_index))
+    if np.isnan(left.fill_value):
+        assert(np.isnan(right.fill_value))
+    else:
+        assert(left.fill_value == right.fill_value)
+
+
 class TestSparseArray(unittest.TestCase):
 
     def setUp(self):
-        pass
+        self.arr_data = np.array([nan, nan, 1, 2, 3, nan, 4, 5, nan, 6])
+        self.arr = SparseArray(self.arr_data)
+        self.zarr = SparseArray([0, 0, 1, 2, 3, 0, 4, 5, 0, 6], fill_value=0)
+
+    def test_values_asarray(self):
+        assert_almost_equal(self.arr.values, self.arr_data)
+        assert_almost_equal(self.arr.sp_values, np.asarray(self.arr))
+
+    def test_getslice(self):
+        result = self.arr[:-3]
+        exp = SparseArray(self.arr.values[:-3])
+        assert_sp_array_equal(result, exp)
+
+    def test_binary_operators(self):
+        data1 = np.random.randn(20)
+        data2 = np.random.randn(20)
+        data1[::2] = np.nan
+        data2[::3] = np.nan
+
+        arr1 = SparseArray(data1)
+        arr2 = SparseArray(data2)
+
+        def _check_op(op):
+            res = op(arr1, arr2)
+            exp = SparseArray(op(arr1.values, arr2.values))
+            self.assert_(isinstance(res, SparseArray))
+            assert_almost_equal(res.values, exp.values)
+
+        def _check_inplace_op(op):
+            tmp = arr1.copy()
+            self.assertRaises(NotImplementedError, op, tmp, arr2)
+
+        bin_ops = [operator.add, operator.sub, operator.mul, operator.truediv,
+                   operator.floordiv, operator.pow]
+        for op in bin_ops:
+            _check_op(op)
+
+        inplace_ops = ['iadd', 'isub', 'imul', 'itruediv', 'ifloordiv', 'ipow']
+        for op in inplace_ops:
+            _check_inplace_op(getattr(operator, op))
+
+if __name__ == '__main__':
+    import nose
+    nose.runmodule(argv=[__file__,'-vvs','-x','--pdb', '--pdb-failure'],
+                   exit=False)

pandas/sparse/tests/test_list.py

@@ -76,6 +76,7 @@ def test_getitem(self):
         for i in range(len(arr)):
             assert_almost_equal(splist[i], arr[i])
 
+
 if __name__ == '__main__':
     import nose
     nose.runmodule(argv=[__file__,'-vvs','-x','--pdb', '--pdb-failure'],

pandas/sparse/tests/test_sparse.py

@@ -22,13 +22,16 @@
 import pandas.sparse.frame as spf
 
 from pandas._sparse import BlockIndex, IntIndex
-from pandas.core.sparse import (SparseSeries, SparseTimeSeries,
-                                SparseDataFrame, SparsePanel)
+from pandas.sparse.api import (SparseSeries, SparseTimeSeries,
+                               SparseDataFrame, SparsePanel,
+                               SparseArray)
 
 import pandas.tests.test_frame as test_frame
 import pandas.tests.test_panel as test_panel
 import pandas.tests.test_series as test_series
 
+from test_array import assert_sp_array_equal
+
 def _test_data1():
     # nan-based
     arr = np.arange(20, dtype=float)
@@ -63,14 +66,6 @@ def assert_sp_series_equal(a, b):
     assert(a.index.equals(b.index))
     assert_sp_array_equal(a, b)
 
-def assert_sp_array_equal(left, right):
-    assert_almost_equal(left.sp_values, right.sp_values)
-    assert(left.sp_index.equals(right.sp_index))
-    if np.isnan(left.fill_value):
-        assert(np.isnan(right.fill_value))
-    else:
-        assert(left.fill_value == right.fill_value)
-
 
 def assert_sp_frame_equal(left, right, exact_indices=True):
     """
@@ -332,7 +327,7 @@ def test_set_value(self):
         self.assert_(res.index[-1] == 'foobar')
         self.assertEqual(res['foobar'], 0)
 
-    def test_getitem_fancy_index(self):
+    def test_getitem_slice(self):
         idx = self.bseries.index
         res = self.bseries[::2]
         self.assert_(isinstance(res, SparseSeries))
@@ -345,6 +340,10 @@ def test_getitem_fancy_index(self):
         res = self.bseries[5:]
         assert_sp_series_equal(res, self.bseries.reindex(idx[5:]))
 
+        # negative indices
+        res = self.bseries[:-3]
+        assert_sp_series_equal(res, self.bseries.reindex(idx[:-3]))
+
     def test_take(self):
         def _compare_with_dense(sp):
             dense = sp.to_dense()
@@ -368,9 +367,6 @@ def _compare(idx):
         sp = SparseSeries(np.ones(10.) * nan)
         assert_almost_equal(sp.take([0, 1, 2, 3, 4]), np.repeat(nan, 5))
 
-    def test_getslice(self):
-        pass
-
     def test_setitem(self):
         self.assertRaises(Exception, self.bseries.__setitem__, 5, 7.)
         self.assertRaises(Exception, self.iseries.__setitem__, 5, 7.)
@@ -432,6 +428,15 @@ def test_operators_corner2(self):
         result = val - self.zbseries
         assert_sp_series_equal(result, 3 - self.zbseries)
 
+
+    def test_binary_operators(self):
+        def _check_inplace_op(op):
+            tmp = self.bseries.copy()
+            self.assertRaises(NotImplementedError, op, tmp, self.bseries)
+        inplace_ops = ['iadd', 'isub', 'imul', 'itruediv', 'ifloordiv', 'ipow']
+        for op in inplace_ops:
+            _check_inplace_op(getattr(operator, op))
+
     def test_reindex(self):
         def _compare_with_series(sps, new_index):
             spsre = sps.reindex(new_index)
@@ -936,6 +941,13 @@ def test_setitem_corner(self):
         self.frame['a'] = self.frame['B']
         assert_sp_series_equal(self.frame['a'], self.frame['B'])
 
+    def test_setitem_array(self):
+        arr = self.frame['B'].view(SparseArray)
+
+        self.frame['E'] = arr
+        assert_sp_series_equal(self.frame['E'], self.frame['B'])
+        self.assertRaises(Exception, self.frame.__setitem__, 'F', arr[:-1])
+
     def test_delitem(self):
         A = self.frame['A']
         C = self.frame['C']