def test_get_locations():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8])
assert_series_equal(srs.get_locations([0, 2]),
rc.Series([5, 7], index=[2, 6]))
assert srs.get_locations([0, 2], as_list=True) == [5, 7]
assert_series_equal(srs.get_locations([2]), rc.Series([7], index=[6]))
def test_tail():
srs = rc.Series([3, 4, 5], sort=False)
assert_series_equal(srs.tail(0), rc.Series([], [], sort=False))
assert_series_equal(srs.tail(1), rc.Series([5], index=[2], sort=False))
assert_series_equal(srs.tail(2), rc.Series([4, 5], index=[1, 2], sort=False))
assert_series_equal(srs.tail(3), rc.Series([3, 4, 5], sort=False))
assert_series_equal(srs.tail(999), rc.Series([3, 4, 5], sort=False))
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_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_tail():
srs = rc.Series([3, 4, 5], sort=False)
assert_series_equal(srs.tail(0), rc.Series([], [], sort=False))
assert_series_equal(srs.tail(1), rc.Series([5], index=[2], sort=False))
assert_series_equal(srs.tail(2), rc.Series([4, 5],
index=[1, 2],
sort=False))
assert_series_equal(srs.tail(3), rc.Series([3, 4, 5], sort=False))
assert_series_equal(srs.tail(999), rc.Series([3, 4, 5], sort=False))
def test_set_locations():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8])
srs.set_locations([0, 2], [-1, -3])
assert_series_equal(srs, rc.Series([-1, 6, -3, 8], index=[2, 4, 6, 8]))
srs.set_locations([1, 3], -10)
assert_series_equal(srs, rc.Series([-1, -10, -3, -10], index=[2, 4, 6, 8]))
with pytest.raises(IndexError):
srs.set_locations([1, 10], [9, 99])
def test_set_locations():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8])
srs.set_locations([0, 2], [-1, -3])
assert_series_equal(srs, rc.Series([-1, 6, -3, 8], index=[2, 4, 6, 8]))
srs.set_locations([1, 3], -10)
assert_series_equal(srs, rc.Series([-1, -10, -3, -10], index=[2, 4, 6, 8]))
with pytest.raises(IndexError):
srs.set_locations([1, 10], [9, 99])
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')])
with pytest.raises(TypeError):
srs.sort_index()
def test_set_location():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8])
srs.set_location(0, -1)
assert_series_equal(srs, rc.Series([-1, 6, 7, 8], index=[2, 4, 6, 8]))
srs.set_location(3, -10)
assert_series_equal(srs, rc.Series([-1, 6, 7, -10], index=[2, 4, 6, 8]))
with pytest.raises(IndexError):
srs.set_location(5, 9)
def test_set_location():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8])
srs.set_location(0, -1)
assert_series_equal(srs, rc.Series([-1, 6, 7, 8], index=[2, 4, 6, 8]))
srs.set_location(3, -10)
assert_series_equal(srs, rc.Series([-1, 6, 7, -10], index=[2, 4, 6, 8]))
with pytest.raises(IndexError):
srs.set_location(5, 9)
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_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_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_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_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_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_get_square_brackets_sorted():
srs = rc.Series([10, 11, 12], index=['a', 'b', 'c'], sort=True)
assert srs['b'] == 11
assert_series_equal(srs[['a', 'c']], rc.Series([10, 12], ['a', 'c'], sort=True))
# get a series back
assert_series_equal(srs[['b']], rc.Series([11], ['b'], sort=True))
assert_series_equal(srs[['c', 'a']], rc.Series([12, 10], ['c', 'a'], sort=True))
# srs[[0, 2]] -- get indexes = [0, 2]
srs = rc.Series([10, 11, 12], sort=True)
assert_series_equal(srs[[0, 2]], rc.Series([10, 12], index=[0, 2], sort=True))
assert_series_equal(srs[[2, 1]], rc.Series([12, 11], index=[2, 1], sort=True))
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_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_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_get_square_brackets():
srs = rc.Series([10, 11, 12], index=['a', 'b', 'c'], sort=False)
assert srs['b'] == 11
assert_series_equal(srs[['a', 'c']], rc.Series([10, 12], ['a', 'c']))
# get a series back
assert_series_equal(srs[['b']], rc.Series([11], ['b'], sort=False))
assert_series_equal(srs[['c', 'a']],
rc.Series([12, 10], ['c', 'a'], sort=False))
# srs[[0, 2]] -- get indexes = [0, 2]
srs = rc.Series([10, 11, 12], sort=False)
assert_series_equal(srs[[0, 2]],
rc.Series([10, 12], index=[0, 2], sort=False))
assert_series_equal(srs[[2, 1]],
rc.Series([12, 11], index=[2, 1], sort=False))
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))
# test on blist
srs = rc.Series([4, 5, 6], index=[10, 8, 9], sort=False, use_blist=True)
srs.sort_index()
assert isinstance(srs.index, blist)
assert_series_equal(srs, rc.Series([5, 6, 4], index=[8, 9, 10], sort=False, use_blist=True))
# fails on mixed type columns
srs = rc.Series([4, 5, 6], index=[10, 'a', 9])
if PYTHON3:
with pytest.raises(TypeError):
srs.sort_index()
def test_from_dataframe():
df = rc.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]}, index=['a', 'b', 9])
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)
df = rc.DataFrame({
'a': [1, 2, 3],
'b': [4, 5, 6]
},
index=['a', 'b', 'e'],
sort=True,
index_name='date')
actual = rc.ViewSeries.from_dataframe(df, 'a', -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_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_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)
srs = rc.Series(data=[4, 5, 6], data_name='b', index=['a', 'b', 9], use_blist=True)
actual = rc.ViewSeries.from_series(srs)
expected = rc.ViewSeries([4, 5, 6], data_name='b', index=['a', 'b', 9])
assert_series_equal(actual, expected)
def test_from_dataframe():
df = rc.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]}, index=['a', 'b', 9])
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)
df = rc.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]}, index=['a', 'b', 'e'], sort=True, index_name='date')
actual = rc.ViewSeries.from_dataframe(df, 'a', -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)
df = rc.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]}, index=['a', 'b', 9], use_blist=True)
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_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_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_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_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_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_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_assert_series_equal():
srs1 = rc.Series([1, 2, 3], index=[1, 2, 3])
assert_series_equal(srs1, srs1)
srs2 = rc.Series([1, 1, 1], index=[1, 2, 3])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.Series([1, 2, 3], index=[11, 12, 13])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.Series([1, 2, 3], index=[1, 2, 3], sort=True)
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
# View Series
srs1 = rc.ViewSeries([1, 2, 3], index=[1, 2, 3])
assert_series_equal(srs1, srs1)
srs2 = rc.ViewSeries([1, 1, 1], index=[1, 2, 3])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.ViewSeries([1, 2, 3], index=[1, 2, 3], offset=9)
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.ViewSeries([1, 2, 3], index=[11, 12, 13])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.ViewSeries([1, 2, 3], index=[1, 2, 3], sort=True)
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
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_assert_series_equal():
srs1 = rc.Series([1, 2, 3], index=[1, 2, 3])
assert_series_equal(srs1, srs1)
srs2 = rc.Series([1, 1, 1], index=[1, 2, 3])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.Series([1, 2, 3], index=[11, 12, 13])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.Series([1, 2, 3], index=[1, 2, 3], use_blist=True)
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.Series([1, 2, 3], index=[1, 2, 3], sort=True)
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
# View Series
srs1 = rc.ViewSeries([1, 2, 3], index=[1, 2, 3])
assert_series_equal(srs1, srs1)
srs2 = rc.ViewSeries([1, 1, 1], index=[1, 2, 3])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.ViewSeries([1, 2, 3], index=[1, 2, 3], offset=9)
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.ViewSeries([1, 2, 3], index=[11, 12, 13])
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
srs2 = rc.ViewSeries([1, 2, 3], index=[1, 2, 3], sort=True)
with pytest.raises(AssertionError):
assert_series_equal(srs1, srs2)
def test_get_locations():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8])
assert_series_equal(srs.get_locations([0, 2]), rc.Series([5, 7], index=[2, 6]))
assert srs.get_locations([0, 2], as_list=True) == [5, 7]
assert_series_equal(srs.get_locations([2]), rc.Series([7], index=[6]))
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_get_slice():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8], sort=True)
assert_series_equal(srs.get_slice(2, 8), srs)
assert_series_equal(srs.get_slice(1, 8), srs)
assert_series_equal(srs.get_slice(2, 18), srs)
assert_series_equal(srs.get_slice(1, 18), srs)
assert_series_equal(srs.get_slice(4, 4), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(3, 4), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(4, 5), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(3, 5), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(3, 6),
rc.Series([6, 7], [4, 6], sort=True))
assert_series_equal(srs.get_slice(4, 7),
rc.Series([6, 7], [4, 6], sort=True))
assert_series_equal(srs.get_slice(3, 7),
rc.Series([6, 7], [4, 6], sort=True))
assert_series_equal(srs.get_slice(None, 7),
rc.Series([5, 6, 7], [2, 4, 6], sort=True))
assert_series_equal(srs.get_slice(3, None),
rc.Series([6, 7, 8], [4, 6, 8], sort=True))
assert_series_equal(srs.get_slice(3, 3), rc.Series([], [], sort=True))
assert_series_equal(srs.get_slice(0, 0), rc.Series([], [], sort=True))
assert_series_equal(srs.get_slice(5, 5), rc.Series([], [], sort=True))
# Only works with sort=True
with pytest.raises(RuntimeError):
rc.Series([4, 5], [6, 7], sort=False).get_slice(6, 6)
def test_get_slice():
srs = rc.Series([5, 6, 7, 8], index=[2, 4, 6, 8], sort=True)
assert_series_equal(srs.get_slice(2, 8), srs)
assert_series_equal(srs.get_slice(1, 8), srs)
assert_series_equal(srs.get_slice(2, 18), srs)
assert_series_equal(srs.get_slice(1, 18), srs)
assert_series_equal(srs.get_slice(4, 4), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(3, 4), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(4, 5), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(3, 5), rc.Series([6], [4], sort=True))
assert_series_equal(srs.get_slice(3, 6), rc.Series([6, 7], [4, 6], sort=True))
assert_series_equal(srs.get_slice(4, 7), rc.Series([6, 7], [4, 6], sort=True))
assert_series_equal(srs.get_slice(3, 7), rc.Series([6, 7], [4, 6], sort=True))
assert_series_equal(srs.get_slice(None, 7), rc.Series([5, 6, 7], [2, 4, 6], sort=True))
assert_series_equal(srs.get_slice(3, None), rc.Series([6, 7, 8], [4, 6, 8], sort=True))
assert_series_equal(srs.get_slice(3, 3), rc.Series([], [], sort=True))
assert_series_equal(srs.get_slice(0, 0), rc.Series([], [], sort=True))
assert_series_equal(srs.get_slice(5, 5), rc.Series([], [], sort=True))
# Only works with sort=True
with pytest.raises(RuntimeError):
rc.Series([4, 5], [6, 7], sort=False).get_slice(6, 6)
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_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_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)
