refactor blist out of Series

Author: rsheftel

raccoon/dataframe.py

@@ -189,7 +189,7 @@ def index_name(self, name):
         self._index_name = name
 
     @property
-    def dropin_func(self):
+    def dropin(self):
         return self._dropin
 
     @property

raccoon/series.py

@@ -7,7 +7,6 @@
 from itertools import compress
 
 from tabulate import tabulate
-from blist import blist
 
 from raccoon.sort_utils import sorted_exists, sorted_index, sorted_list_indexes
 
@@ -18,7 +17,7 @@ class SeriesBase(ABC):
     methods in Series are views to the underlying data and not copies.
     """
     # Define slots to make object faster
-    __slots__ = ['_data', '_data_name', '_index', '_index_name', '_sort']
+    __slots__ = ['_data', '_data_name', '_index', '_index_name', '_sort', '_dropin']
 
     def __init__(self):
         """
@@ -29,6 +28,7 @@ def __init__(self):
         self._data = None
         self._data_name = None
         self._sort = None
+        self._dropin = None
 
     def __len__(self):
         return len(self._index)
@@ -90,6 +90,9 @@ def index_name(self, name):
     def sort(self):
         return
 
+    def _check_list(self, x):
+        return type(x) == (self._dropin if self._dropin else list)
+
     def get(self, indexes, as_list=False):
         """
         Given indexes will return a sub-set of the Series. This method will direct to the specific methods
@@ -100,7 +103,7 @@ def get(self, indexes, as_list=False):
         :param as_list: if True then return the values as a list, if False return a Series.
         :return: either Series, list, or single value. The return is a shallow copy
         """
-        if isinstance(indexes, (list, blist)):
+        if self._check_list(indexes):
             return self.get_rows(indexes, as_list)
         else:
             return self.get_cell(indexes)
@@ -211,8 +214,8 @@ def _slice_index(self, slicer):
         return pre_list
 
     def _validate_index(self, indexes):
-        if not(isinstance(indexes, (list, blist)) or indexes is None):
-            raise TypeError('indexes must be list, blist or None')
+        if not(self._check_list(indexes) or type(indexes) == list or indexes is None):
+            raise TypeError('indexes must be list, %s or None' % self._dropin)
         if len(indexes) != len(set(indexes)):
             raise ValueError('index contains duplicates')
         if self._data:
@@ -323,19 +326,21 @@ def equality(self, indexes=None, value=None):
 class Series(SeriesBase):
     """
     Series class. The raccoon Series implements a simplified version of the pandas Series with the key
-    objective difference that the raccoon Series is meant for use cases where the size of the Series is
+    objective difference that the raccoon Series is meant for use cases where the size of the Series rows is
     expanding frequently. This is known to be slow with Pandas due to the use of numpy as the underlying data structure.
-    The Series can be designated as sort, in which case the rows will be sort by index on construction, 
-    and then any addition of a new row will insert it into the Series so that the index remains sort.
+    Raccoon uses native lists, or any other provided drop-in replacement for lists, as the underlying data structure
+    which is quick to expand and grow the size. The Series can be designated as sort, in which case the rows will be
+    sort by index on construction, and then any addition of a new row will insert it into the Series so that the
+    index remains sort.
     """
-    def __init__(self, data=None, index=None, data_name='value', index_name='index', use_blist=False, sort=None):
+    def __init__(self, data=None, index=None, data_name='value', index_name='index', sort=None, dropin=None):
         """
         :param data: (optional) list of values.
         :param index: (optional) list of index values. If None then the index will be integers starting with zero
         :param data_name: (optional) name of the data column, or will default to 'value'
         :param index_name: (optional) name for the index. Default is "index"
-        :param use_blist: if True then use blist() as the underlying data structure, if False use standard list()
         :param sort: if True then Series will keep the index sort. If True all index values must be of same type
+        :param dropin: if supplied the drop-in replacement for list that will be used
         """
         super(SeriesBase, self).__init__()
 
@@ -344,19 +349,19 @@ def __init__(self, data=None, index=None, data_name='value', index_name='index',
         self._index_name = index_name
         self._data = None
         self._data_name = data_name
-        self._blist = use_blist
+        self._dropin = dropin
 
         # setup data list
         if data is None:
-            self._data = blist() if self._blist else list()
+            self._data = dropin() if dropin else list()
             if index:
                 # pad out to the number of rows
                 self._pad_data(len(index))
                 self.index = index
             else:
                 self.index = list()
-        elif isinstance(data, (list, blist)):
-            self._data = blist([x for x in data]) if self._blist else [x for x in data]
+        elif self._check_list(data) or type(data) == list:
+            self._data = dropin([x for x in data]) if dropin else [x for x in data]
             # setup index
             if index:
                 self.index = index
@@ -395,11 +400,11 @@ def index(self):
     @index.setter
     def index(self, index_list):
         self._validate_index(index_list)
-        self._index = blist(index_list) if self._blist else list(index_list)
+        self._index = self._dropin(index_list) if self._dropin else list(index_list)
 
     @property
-    def blist(self):
-        return self._blist
+    def dropin(self):
+        return self._dropin
 
     @property
     def sort(self):
@@ -419,9 +424,9 @@ def sort_index(self):
         """
         sort = sorted_list_indexes(self._index)
         # sort index
-        self._index = blist([self._index[x] for x in sort]) if self._blist else [self._index[x] for x in sort]
+        self._index = self._dropin([self._index[x] for x in sort]) if self._dropin else [self._index[x] for x in sort]
         # sort data
-        self._data = blist([self._data[x] for x in sort]) if self._blist else [self._data[x] for x in sort]
+        self._data = self._dropin([self._data[x] for x in sort]) if self._dropin else [self._data[x] for x in sort]
 
     def set(self, indexes, values=None):
         """
@@ -433,7 +438,7 @@ def set(self, indexes, values=None):
         :param values: value or list of values to set. If a list then must be the same length as the indexes parameter.
         :return: nothing
         """
-        if isinstance(indexes, (list, blist)):
+        if self._check_list(indexes):
             self.set_rows(indexes, values)
         else:
             self.set_cell(indexes, values)
@@ -518,7 +523,7 @@ def set_rows(self, index, values=None):
         :return: nothing
         """
         if all([isinstance(i, bool) for i in index]):  # boolean list
-            if not isinstance(values, (list, blist)):  # single value provided, not a list, so turn values into list
+            if not self._check_list(values):  # single value provided, not a list, so turn values into list
                 values = [values for x in index if x]
             if len(index) != len(self._index):
                 raise ValueError('boolean index list must be same size of existing index')
@@ -528,7 +533,7 @@ def set_rows(self, index, values=None):
             for x, i in enumerate(indexes):
                 self._data[i] = values[x]
         else:  # list of index
-            if not isinstance(values, (list, blist)):  # single value provided, not a list, so turn values into list
+            if not self._check_list(values):  # single value provided, not a list, so turn values into list
                 values = [values for _ in index]
             if len(values) != len(index):
                 raise ValueError('length of values and index must be the same.')
@@ -652,7 +657,7 @@ def delete(self, indexes):
         :param indexes: either a list of values or list of booleans for the rows to delete
         :return: nothing
         """
-        indexes = [indexes] if not isinstance(indexes, (list, blist)) else indexes
+        indexes = [indexes] if not self._check_list(indexes) else indexes
         if all([isinstance(i, bool) for i in indexes]):  # boolean list
             if len(indexes) != len(self._index):
                 raise ValueError('boolean indexes list must be same size of existing indexes')
@@ -681,7 +686,8 @@ class ViewSeries(SeriesBase):
     """
     ViewSeries class. The raccoon ViewSeries implements a view only version of the Series object with the key
     objective difference that the raccoon ViewSeries is meant for view only use cases where the underlying index and
-    data are modified elsewhere or static. Use this for a view into a single column of a DataFrame.
+    data are modified elsewhere or static. Use this for a view into a single column of a DataFrame. There is no type
+    checking of the data, so it is assumed the data type is list-style.
     """
     def __init__(self, data=None, index=None, data_name='value', index_name='index', sort=False, offset=0):
         """
@@ -694,13 +700,14 @@ def __init__(self, data=None, index=None, data_name='value', index_name='index',
         """
         super(SeriesBase, self).__init__()
 
+        # dropin is not a parameter, set it to the value of data
+        self._dropin = data.__class__
+
         # check inputs
         if index is None:
             raise ValueError('Index cannot be None.')
         if data is None:
             raise ValueError('Data cannot be None.')
-        if not isinstance(data, (list, blist)):
-            raise TypeError('Not valid data type.')
 
         # standard variable setup
         self._data = data  # direct view, no copy

raccoon/utils.py

@@ -24,7 +24,7 @@ def assert_frame_equal(left, right, data_function=None, data_args=None):
     assert left.columns == right.columns
     assert left.index_name == right.index_name
     assert left.sort == right.sort
-    assert left.dropin_func == right.dropin_func
+    assert left.dropin == right.dropin
 
 
 def assert_series_equal(left, right, data_function=None, data_args=None):
@@ -50,4 +50,4 @@ def assert_series_equal(left, right, data_function=None, data_args=None):
     if isinstance(left, rc.ViewSeries):
         assert left.offset == right.offset
     if isinstance(left, rc.Series):
-        assert left.blist == right.blist
+        assert left.dropin == right.dropin

tests/test_dropin/test_series_blist.py

@@ -0,0 +1,125 @@
+import pytest
+import raccoon as rc
+from raccoon.utils import assert_series_equal
+
+try:
+    from blist import blist
+except ImportError:
+    pytest.skip("blist is not installed, skipping tests.", allow_module_level=True)
+
+
+def test_assert_series_equal():
+    srs1 = rc.Series([1, 2, 3], index=[1, 2, 3])
+    srs2 = rc.Series([1, 2, 3], index=[1, 2, 3], dropin=blist)
+    with pytest.raises(AssertionError):
+        assert_series_equal(srs1, srs2)
+
+
+def test_default_empty_init():
+    actual = rc.Series(index=[1, 2, 3], data_name='points', dropin=blist)
+    assert actual.data == [None, None, None]
+    assert actual.data_name == 'points'
+    assert actual.index == [1, 2, 3]
+    assert actual.index_name == 'index'
+    assert actual.sort is False
+    assert isinstance(actual.index, blist)
+    assert isinstance(actual.data, blist)
+
+
+def test_use_blist():
+    def check_blist():
+        assert isinstance(srs.index, blist)
+        assert isinstance(srs.data, blist)
+
+    srs = rc.Series(dropin=blist)
+    assert isinstance(srs, rc.Series)
+    assert srs.data == []
+    assert srs.index == []
+    assert srs.sort is True
+    check_blist()
+
+    # add a new row and col
+    srs.set_cell(1, 1)
+    check_blist()
+
+    # add a new row
+    srs.set_cell(2, 2)
+    check_blist()
+
+    # add a new col
+    srs.set_cell(1, 3)
+    check_blist()
+
+    # add a complete new row
+    srs.set_rows([3], [5])
+    check_blist()
+
+
+def test_index_blist():
+    actual = rc.Series([4, 5, 6], index=['a', 'b', 'c'], dropin=blist)
+    result = actual.index
+    assert result == ['a', 'b', 'c']
+    assert isinstance(result, blist)
+
+    # test that a view is returned
+    result.append('bad')
+    assert actual.index == ['a', 'b', 'c', 'bad']
+
+    actual.index = [9, 10, 11]
+    assert actual.index == [9, 10, 11]
+    assert isinstance(result, blist)
+
+    # index too long
+    with pytest.raises(ValueError):
+        actual.index = [1, 3, 4, 5, 6]
+
+
+def test_data_blist():
+    actual = rc.Series([4, 5, 6], index=['a', 'b', 'c'], dropin=blist)
+    assert actual.data == [4, 5, 6]
+    assert isinstance(actual.data, blist)
+
+
+def test_print():
+    srs = rc.Series([1.0, 2.55, 3.1], data_name='boo', index=['row1', 'row2', 'row3'], dropin=blist)
+
+    # __repr__ produces a simple representation
+    expected = "object id: %s\ndata:\nblist([1.0, 2.55, 3.1])\nindex:\nblist(['row1', 'row2', 'row3'])\n" % id(srs)
+    actual = srs.__repr__()
+    assert actual == expected
+
+    # __str__ produces the standard table
+    expected = 'index      boo\n-------  -----\nrow1      1\nrow2      2.55\nrow3      3.1'
+    actual = srs.__str__()
+    assert actual == expected
+
+    # print() method will pass along any argument for the tabulate.tabulate function
+    srs.print()
+
+
+def test_sort_index():
+    srs = rc.Series([4, 5, 6], index=[10, 8, 9], sort=False, dropin=blist)
+    srs.sort_index()
+    assert isinstance(srs.index, blist)
+    assert_series_equal(srs, rc.Series([5, 6, 4], index=[8, 9, 10], sort=False, dropin=blist))
+
+
+def test_select_index():
+    # simple index, not sort, blist
+    srs = rc.Series([1, 2, 3, 4, 5, 6], index=['a', 'b', 'c', 'd', 'e', 'f'], dropin=blist)
+    actual = srs.select_index('c', 'value')
+    assert actual == ['c']
+
+
+def test_from_dataframe():
+    df = rc.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]}, index=['a', 'b', 9], dropin=blist)
+    actual = rc.ViewSeries.from_dataframe(df, 'b')
+    expected = rc.ViewSeries([4, 5, 6], data_name='b', index=['a', 'b', 9])
+    assert_series_equal(actual, expected)
+
+
+def test_from_series():
+    srs = rc.Series(data=[4, 5, 6], data_name='b', index=['a', 'b', 9], dropin=blist)
+    actual = rc.ViewSeries.from_series(srs)
+    expected = rc.ViewSeries([4, 5, 6], data_name='b', index=['a', 'b', 9])
+    assert_series_equal(actual, expected)

tests/test_series/test_delete.py

@@ -38,13 +38,13 @@ def test_delete():
 
 
 def test_delete_sort():
-    srs = rc.Series([4, 5, 6], index=['a', 'b', 'c'], sort=True, use_blist=False)
+    srs = rc.Series([4, 5, 6], index=['a', 'b', 'c'], sort=True)
 
     srs.delete(['a', 'c'])
-    assert_series_equal(srs, rc.Series([5], index=['b'], sort=True, use_blist=False))
+    assert_series_equal(srs, rc.Series([5], index=['b'], sort=True))
 
     srs.delete('b')
-    assert_series_equal(srs, rc.Series(sort=True, use_blist=False))
+    assert_series_equal(srs, rc.Series(sort=True))
 
     # insert back in data
     srs[2] = 9