def test_set_from_blank_srs():
# single cell
srs = rc.Series(sort=False)
srs.set(indexes=1, values=9)
assert srs.index == [1]
assert srs.data == [9]
# single column
srs = rc.Series(sort=False)
srs.set(indexes=[1, 2, 3], values=[9, 10, 11])
assert srs.index == [1, 2, 3]
assert srs.data == [9, 10, 11]
def test_sort_index():
# test on list
srs = rc.Series([4, 5, 6], index=[10, 8, 9], sort=False)
srs.sort_index()
assert isinstance(srs.index, list)
assert_series_equal(srs, rc.Series([5, 6, 4], index=[8, 9, 10], sort=False))
# fails on mixed type columns
srs = rc.Series([4, 5, 6], index=[10, 'a', 9])
with pytest.raises(TypeError):
srs.sort_index()
def test_reset_index():
# no index defined
srs = rc.Series([4, 5, 6])
srs.reset_index()
expected = rc.Series([4, 5, 6])
assert_series_equal(srs, expected)
# with index and index name defined
srs = rc.Series([1, 2, 3], index=['x', 'y', 'z'], index_name='jelo')
srs.reset_index()
expected = rc.Series([1, 2, 3], [0, 1, 2], sort=False)
assert_series_equal(srs, expected)
def test_from_series_view():
# sort = False
ins = rc.Series(data=[4, 5, 6],
data_name='b',
index=['a', 'b', 9],
sort=False)
srs = rc.ViewSeries.from_series(ins)
assert srs.sort is False
assert srs.index is srs.index
assert srs.data is ins.data
# change cell
ins['a'] = 22
assert srs.data == [22, 5, 6]
assert srs.index == ['a', 'b', 9]
# add a row
ins[11] = -88
assert srs.data == [22, 5, 6, -88]
assert srs.index == ['a', 'b', 9, 11]
# append row
ins.append_row(12, 77)
assert srs.data == [22, 5, 6, -88, 77]
assert srs.index == ['a', 'b', 9, 11, 12]
# sort = True
ins = rc.Series(data=[1, 2, 3], data_name='a', index=[0, 1, 5], sort=True)
srs = rc.ViewSeries.from_series(ins)
assert srs.sort is True
assert srs.index is srs.index
assert srs.data is ins.data
# change cell
ins[1] = 22
assert srs.data == [1, 22, 3]
assert srs.index == [0, 1, 5]
# add a row end
ins[6] = 4
assert srs.data == [1, 22, 3, 4]
assert srs.index == [0, 1, 5, 6]
# add value in middle
ins[2] = 12
assert srs.data == [1, 22, 12, 3, 4]
assert srs.index == [0, 1, 2, 5, 6]
# append row
ins.append_row(7, 55)
assert srs.data == [1, 22, 12, 3, 4, 55]
assert srs.index == [0, 1, 2, 5, 6, 7]
def test_append_row():
actual = rc.Series([7, 9], index=[10, 12], sort=False)
actual.append_row(9, 99)
expected = rc.Series([7, 9, 99], index=[10, 12, 9])
assert_series_equal(actual, expected)
actual.append_row(16, 100)
expected = rc.Series([7, 9, 99, 100], index=[10, 12, 9, 16])
assert_series_equal(actual, expected)
with pytest.raises(IndexError):
actual.append_row(10, 100)
def test_set_index_subset_sort():
actual = rc.Series([1, 2, 3], index=[10, 11, 12], sort=True)
# by index value
actual.set(indexes=[12, 11, 10], values=[66, 55, 44])
assert actual.data == [44, 55, 66]
actual.set(indexes=[12, 10], values=[33, 11])
assert actual.data == [11, 55, 33]
# new rows at end
actual.set(indexes=[12, 14, 15], values=[120, 130, 140])
assert actual.data == [11, 55, 120, 130, 140]
assert actual.index == [10, 11, 12, 14, 15]
# new rows at beginning
actual.set(indexes=[10, 4, 5], values=[-140, -120, -130])
assert actual.data == [-120, -130, -140, 55, 120, 130, 140]
assert actual.index == [4, 5, 10, 11, 12, 14, 15]
# new rows in middle
actual.set(indexes=[13, 6], values=[3131, 6060])
assert actual.data == [-120, -130, 6060, -140, 55, 120, 3131, 130, 140]
assert actual.index == [4, 5, 6, 10, 11, 12, 13, 14, 15]
# new row new columns
actual.set(indexes=[14, 15, 16], values=['zoo', 'boo', 'hoo'])
assert actual.index == [4, 5, 6, 10, 11, 12, 13, 14, 15, 16]
assert actual.data == [-120, -130, 6060, -140, 55, 120, 3131, 'zoo', 'boo', 'hoo']
# values list shorter than indexes, raise error
with pytest.raises(ValueError):
actual.set(indexes=[10, 11], values=[1])
# by boolean list
actual = rc.Series([1, 2], index=['first', 'second'], sort=True)
actual.set(indexes=[False, True], values=[99])
assert actual.data == [1, 99]
# boolean list not size of existing index
with pytest.raises(ValueError):
actual.set(indexes=[True, False, True], values=[1, 2])
# boolean list True entries not same size as values list
with pytest.raises(ValueError):
actual.set(indexes=[True, True, False], values=[4, 5, 6])
with pytest.raises(ValueError):
actual.set(indexes=[True, True, False], values=[4])
def test_set_rows_sort():
actual = rc.Series([7, 8, 9], index=[10, 11, 12], sort=True)
# change some of the values
actual.set([11, 12], [88, 99])
assert actual.data == [7, 88, 99]
# change all existing values
actual.set(actual.index, values=[44, 55, 66])
assert actual.data == [44, 55, 66]
# modify existing and add a new row
actual.set([12, 9, 10.5], [666, 77, 1])
assert actual.data == [77, 44, 1, 55, 666]
assert actual.index == [9, 10, 10.5, 11, 12]
# only add a new row
actual.set([8], [5])
assert actual.data == [5, 77, 44, 1, 55, 666]
assert actual.index == [8, 9, 10, 10.5, 11, 12]
# not enough values
with pytest.raises(ValueError):
actual.set(indexes=[True, True, True], values=[1, 2])
# number of values must equal number of True indexes
with pytest.raises(ValueError):
actual.set(indexes=[True, False, True], values=[1, 2, 3])
# too many values
with pytest.raises(ValueError):
actual.set(indexes=[True, True, True, True], values=[1, 2, 3, 4])
def test_append_rows():
actual = rc.Series([7, 9], index=[10, 12], sort=False)
actual.append_rows([9, 11], [99, 100])
expected = rc.Series([7, 9, 99, 100], index=[10, 12, 9, 11])
assert_series_equal(actual, expected)
actual.append_rows([16, 17], [110, 120])
expected = rc.Series([7, 9, 99, 100, 110, 120], index=[10, 12, 9, 11, 16, 17])
assert_series_equal(actual, expected)
with pytest.raises(IndexError):
actual.append_rows([1, 10], [100, 110])
with pytest.raises(ValueError):
actual.append_rows([1, 10], [100, 110, 120])
def test_set_cell_sort():
actual = rc.Series([7, 8, 9], index=[10, 12, 13], sort=True)
# change existing value
actual.set(12, 55)
assert actual.get(12) == 55
actual.set(10, 11)
assert actual.get(10) == 11
actual.set(10, 13)
assert actual.get(10) == 13
assert actual.data == [13, 55, 9]
# add a new row
actual.set(14, 15)
assert actual.index == [10, 12, 13, 14]
assert actual.data == [13, 55, 9, 15]
# row in the middle
actual.set(11, -1)
assert actual.index == [10, 11, 12, 13, 14]
assert actual.data == [13, -1, 55, 9, 15]
# add before beginning
actual.set(5, 999)
assert actual.index == [5, 10, 11, 12, 13, 14]
assert actual.data == [999, 13, -1, 55, 9, 15]
# fails for mixed index type
with pytest.raises(TypeError):
actual.set('Z', 60)
def test_use_blist():
def check_blist():
assert isinstance(srs.index, blist)
assert isinstance(srs.data, blist)
srs = rc.Series(use_blist=True)
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_view():
data = [4, 5, 6]
index = ['a', 'b', 'c']
actual = rc.ViewSeries(data, index)
result = actual.index
assert result == ['a', 'b', 'c']
assert isinstance(result, list)
# test that a view is returned
assert result is index
assert result is actual.index
# modify
result[1] = 'new'
assert actual.index == ['a', 'new', 'c']
assert index == ['a', 'new', 'c']
# index too long
with pytest.raises(ValueError):
actual.index = [1, 3, 4, 5, 6]
assert actual.index_name == 'index'
actual.index_name = 'new name'
assert actual.index_name == 'new name'
actual = rc.Series([4, 5, 6], index=['a', 'b', 'c'], index_name='letters')
assert actual.index_name == 'letters'
def test_get_slicer():
srs = rc.Series([7, 8, 9], index=[1, 2, 3], sort=False)
assert_series_equal(srs[2:3], rc.Series([8, 9], index=[2, 3], sort=False))
assert_series_equal(srs[1:2], rc.Series([7, 8], index=[1, 2], sort=False))
assert_series_equal(srs[2:2], rc.Series([8], index=[2], sort=False))
# test indexes not in the range
with pytest.raises(IndexError):
_ = srs[4:5]
with pytest.raises(IndexError):
_ = srs[1:8]
with pytest.raises(IndexError):
_ = srs[2:1]
def test_sorted_init():
# initialized with index defaults to False
df = rc.Series([5, 4, 6], index=[12, 11, 13])
assert df.sort is False
df = rc.Series([5, 4, 6], index=[12, 11, 13], sort=True)
assert df.sort is True
assert df.index == [11, 12, 13]
assert df.data == [4, 5, 6]
# initialized with no index defaults to True
df = rc.Series([5, 4, 6])
assert df.sort is True
df = rc.Series([5, 4, 6], sort=False)
assert df.sort is False
# if sort is true, but no index provided it will assume already in sort order
df = rc.Series([5, 4, 6], sort=True)
assert df.sort is True
assert df.index == [0, 1, 2]
assert df.data == [5, 4, 6]
# start un-sort, then set to sort
df = rc.Series([5, 4, 6], index=[12, 11, 13], sort=False)
assert df.sort is False
assert df.index == [12, 11, 13]
assert df.data == [5, 4, 6]
df.sort = True
assert df.index == [11, 12, 13]
assert df.data == [4, 5, 6]
# mixed type index will bork on sort=True
with pytest.raises(TypeError):
rc.Series([5, 4, 6], index=[1, 'b', 3], sort=True)
def test_names():
srs = rc.Series([1, 2])
assert srs.index_name == 'index'
assert srs.data_name == 'value'
srs.index_name = 'new_index'
srs.data_name = 'data'
assert srs.index_name == 'new_index'
assert srs.data_name == 'data'
def test_get_data_mutability():
# the .data method only returns a view, and changes to the return values will corrupt the Series
srs = rc.Series([1.0, 2.55, 3.1])
orig_data = deepcopy(srs.data)
data = srs.data
# regular Series return a view of data
data.append(99)
assert srs.data != orig_data
assert srs.data == [1.0, 2.55, 3.1, 99]
# using the get commands returns a shallow copy
srs = rc.Series([[1], [2], [3]])
# mutate inner value
srs[1].append(22)
# changes the new_df
assert srs.data == [[1], [2, 22], [3]]
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_sort_multi_index():
srs = rc.Series([4, 5, 6],
index=[(10, 'c'), (10, 'a'), (10, 'b')],
sort=False)
srs.sort_index()
assert isinstance(srs.index, list)
assert_series_equal(
srs,
rc.Series([5, 6, 4],
index=[(10, 'a'), (10, 'b'), (10, 'c')],
sort=False))
# fails on mixed type columns
srs = rc.Series([4, 5, 6], index=[(10, 'c'), 'a', (10, 'b')])
if PYTHON3:
with pytest.raises(TypeError):
srs.sort_index()
def test_data_function():
# Example function for testing
def assert_approx_equal(left_data, right_data, precision=0.00001):
for i in range(len(left_data)):
assert abs(left_data[i] - right_data[i]) <= precision
srs1 = rc.Series([1.0, 3.0], index=[1, 3])
srs2 = rc.Series([1.0, 3.001], index=[1, 3])
# confirm fails with standard compare
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
# passes with function and proper parameters
assert_series_equal(srs1, srs2, assert_approx_equal, {'precision': 0.01})
# fails with function and precision parameter to low
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2, assert_approx_equal, {'precision': 0.00001})
def test_from_series():
srs = rc.Series(data=[4, 5, 6], index=['a', 'b', 9], data_name='b')
actual = rc.ViewSeries.from_series(srs)
expected = rc.ViewSeries([4, 5, 6], data_name='b', index=['a', 'b', 9])
assert_series_equal(actual, expected)
srs = rc.Series(data=[1, 2, 3],
data_name='a',
index=['a', 'b', 'e'],
sort=True,
index_name='date')
actual = rc.ViewSeries.from_series(srs, -1)
expected = rc.ViewSeries([1, 2, 3],
data_name='a',
index=['a', 'b', 'e'],
sort=True,
offset=-1,
index_name='date')
assert_series_equal(actual, expected)
def test_default_empty_init():
actual = rc.Series()
assert isinstance(actual, rc.Series)
assert actual.data == []
assert actual.data_name == 'value'
assert actual.index == []
assert actual.sort is True
assert isinstance(actual.index, list)
assert isinstance(actual.data, list)
actual = rc.Series(sort=False)
assert actual.sort is False
assert isinstance(actual.index, list)
assert isinstance(actual.data, list)
actual = rc.Series(data_name='points')
assert actual.data == []
assert actual.data_name == 'points'
assert actual.index == []
assert actual.sort is True
assert isinstance(actual.index, list)
assert isinstance(actual.data, list)
actual = rc.Series(index=[1, 2, 3], data_name='points')
assert actual.data == [None, None, None]
assert actual.data_name == 'points'
assert actual.index == [1, 2, 3]
assert actual.sort is False
assert isinstance(actual.index, list)
assert isinstance(actual.data, list)
actual = rc.Series(index=[1, 2, 3],
index_name='dates',
data_name='points',
sort=True)
assert actual.data == [None, None, None]
assert actual.data_name == 'points'
assert actual.index == [1, 2, 3]
assert actual.index_name == 'dates'
assert actual.sort is True
assert isinstance(actual.index, list)
assert isinstance(actual.data, list)
def test_delete():
srs = rc.Series([1, 2, 3], index=['a', 'b', 'c'])
srs.delete(['a', 'c'])
assert_series_equal(srs, rc.Series([2], index=['b']))
srs.delete('b')
assert_series_equal(srs, rc.Series(sort=False))
# insert back in data
srs[1] = 9
assert srs.data == [9]
assert srs.index == [1]
srs[2] = 8
assert srs.data == [9, 8]
assert srs.index == [1, 2]
srs = rc.Series([4, 5, 6], index=['a', 'b', 'c'])
# cannot delete values not in index
with pytest.raises(ValueError):
srs.delete(['bad'])
# length of boolean must be len of index
with pytest.raises(ValueError):
srs.delete([True, False])
srs.delete([True, False, True])
assert_series_equal(srs, rc.Series([5], index=['b']))
srs.delete([True])
assert_series_equal(srs, rc.Series(sort=False))
def test_set_square_brackets():
srs = rc.Series(sort=False)
srs[1] = 2
assert srs.data == [2]
assert srs.index == [1]
# srs[[0, 3]] - - set index = [0, 3]
srs[[0, 3]] = 4
assert srs.data == [2, 4, 4]
assert srs.index == [1, 0, 3]
# srs[1:2] - - set index slice 1:2
srs[1:3] = 5
assert srs.data == [5, 5, 5]
assert srs.index == [1, 0, 3]
assert srs.sort is False
# with sort = True
srs = rc.Series(sort=True)
srs[1] = 2
assert srs.data == [2]
assert srs.index == [1]
# srs[[0, 3]] - - set index = [0, 3]
srs[[0, 3]] = 4
assert srs.data == [4, 2, 4]
assert srs.index == [0, 1, 3]
# srs[1:2] - - set index slice 1:2
srs[1:3] = 5
assert srs.data == [4, 5, 5]
assert srs.index == [0, 1, 3]
assert srs.sort is True
# insert
srs[2] = 6
assert srs.data == [4, 5, 6, 5]
assert srs.index == [0, 1, 2, 3]
def test_default_init():
# no index
actual = rc.Series([4, 5, 6])
assert actual.data == [4, 5, 6]
assert actual.data_name == 'value'
assert actual.index == [0, 1, 2]
assert actual.sort is True
assert isinstance(actual.index, list)
assert isinstance(actual.data, list)
assert len(actual) == 3
# with index
actual = rc.Series(data=[4, 5, 6],
index=['a', 'b', 'c'],
index_name='letters')
assert actual.data == [4, 5, 6]
assert actual.index == ['a', 'b', 'c']
assert actual.index_name == 'letters'
assert actual.sort is False
assert isinstance(actual.index, list)
assert isinstance(actual.data, list)
assert len(actual) == 3
def test_from_series_view_breaks():
# These actions will break the view link between the Series and the ViewSeries
# changing index
ins = rc.Series(data=[1, 2, 3], data_name='a', index=[0, 1, 5], sort=True)
srs = rc.ViewSeries.from_series(ins)
assert srs.index is ins.index
assert srs.data is ins.data
ins.index = [1, 2, 3]
assert srs.index is not ins.index
assert srs.data is ins.data
# sorting index
ins = rc.Series(data=[1, 2, 3], data_name='a', index=[0, 1, 5], sort=True)
srs = rc.ViewSeries.from_series(ins)
assert srs.index is ins.index
assert srs.data is ins.data
ins.sort_index()
assert srs.index is not ins.index
assert srs.data is not ins.data
def test_equality():
srs = rc.Series([1, 2, 1, 2, 1, 1])
assert srs.sort is True
assert srs.equality(value=1) == [True, False, True, False, True, True]
assert srs.equality([1, 2, 3], 2) == [True, False, True]
assert srs.equality([False, False, False, True, True, True], 1) == [False, True, True]
# change all 1 to 3
srs.set(indexes=srs.equality(value=1), values=3)
assert srs.data == [3, 2, 3, 2, 3, 3]
srs = rc.Series([1, 2, 1, 2, 1, 1], sort=False)
assert srs.sort is False
assert srs.equality(value=1) == [True, False, True, False, True, True]
assert srs.equality([1, 2, 3], 2) == [True, False, True]
assert srs.equality([False, False, False, True, True, True], 1) == [False, True, True]
# not enough booleans to match index len
with pytest.raises(ValueError):
srs.equality([True, True], 2)
def test_head():
srs = rc.Series([3, 4, 5], sort=False)
assert_series_equal(srs.head(0), rc.Series([], [], sort=False))
assert_series_equal(srs.head(1), rc.Series([3], sort=False))
assert_series_equal(srs.head(2), rc.Series([3, 4], sort=False))
assert_series_equal(srs.head(3), rc.Series([3, 4, 5], sort=False))
assert_series_equal(srs.head(999), rc.Series([3, 4, 5], sort=False))
def test_get_rows_sorted():
srs = rc.Series([1, 2, 3, 4],
index=[10, 11, 12, 99],
index_name='start_10',
sort=True)
expected = rc.Series([2, 3],
index=[11, 12],
index_name='start_10',
sort=True)
actual = srs.get([11, 12])
assert_series_equal(actual, expected)
# test with boolean list
actual = srs.get([False, True, True, False])
assert_series_equal(actual, expected)
# index out of order
expected = rc.Series([4, 1],
index=[99, 10],
index_name='start_10',
sort=True)
actual = srs.get([99, 10])
assert_series_equal(actual, expected)
# get as a list
assert srs.get([11, 12], as_list=True) == [2, 3]
# get as a list
assert srs.get([False, True, True, False], as_list=True) == [2, 3]
# items not in index raise errors
with pytest.raises(ValueError):
srs.get([11, 88], as_list=True)
# not enough items in boolean list
with pytest.raises(ValueError):
srs.get([True, True])
def test_get_slicer_sorted():
srs = rc.Series([7, 8, 9], index=[1, 2, 3], sort=True)
assert_series_equal(srs[2:3], rc.Series([8, 9], index=[2, 3], sort=True))
assert_series_equal(srs[1:2], rc.Series([7, 8], index=[1, 2], sort=True))
assert_series_equal(srs[0.5:2.5], rc.Series([7, 8],
index=[1, 2],
sort=True))
assert_series_equal(srs[2:2], rc.Series([8], index=[2], sort=True))
assert_series_equal(srs[4:5], rc.Series([], index=[], sort=True))
assert_series_equal(srs[2:1], rc.Series([], index=[], sort=True))
assert_series_equal(srs[1:8], srs)
def test_views():
# assert that df.data is data and df.index are copies and do not alter input data
data = [4, 5, 6]
index = ['a', 'b', 'c']
actual = rc.Series(data=data, index=index)
assert actual.data is not data
assert actual.index is not index
# change input data, no change to series
data.append(7)
index.append('e')
assert actual.data == [4, 5, 6]
assert actual.index == ['a', 'b', 'c']
def test_index():
actual = rc.Series([4, 5, 6], index=['a', 'b', 'c'])
result = actual.index
assert result == ['a', 'b', 'c']
assert isinstance(result, list)
# 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, list)
# index too long
with pytest.raises(ValueError):
actual.index = [1, 3, 4, 5, 6]
assert actual.index_name == 'index'
actual.index_name = 'new name'
assert actual.index_name == 'new name'
actual = rc.Series([4, 5, 6], index=['a', 'b', 'c'], index_name='letters')
assert actual.index_name == 'letters'
