def test_series_binary_operator_e(self):
s1 = Series((False, True, False, True), index=list('abcd'))
s2 = Series([True] * 3, index=list('abc'))
self.assertEqual(
(s1 == -1).to_pairs(),
(('a', False), ('b', False), ('c', False), ('d', False)))
self.assertEqual(
(s1 == s2).to_pairs(),
(('a', False), ('b', True), ('c', False), ('d', False)))
self.assertEqual(
(s1 == True).to_pairs(),
(('a', False), ('b', True), ('c', False), ('d', True)))
# NOTE: these are unexpected results that derive from NP Boolean operator behaviors
self.assertEqual(
(s1 == (True, )).to_pairs(),
(('a', False), ('b', True), ('c', False), ('d', True)))
self.assertEqual(
(s1 == (True, False)).to_pairs(),
(('a', False), ('b', False), ('c', False), ('d', False)))
# as this is samed sized, NP does element wise comparison
self.assertEqual((s1 == (False, True, False, True)).to_pairs(),
(('a', True), ('b', True), ('c', True), ('d', True)))
self.assertEqual(
(s1 == (False, True, False, True, False)).to_pairs(),
(('a', False), ('b', False), ('c', False), ('d', False)))
def test_series_assign_f(self):
s1 = Series(range(5), index=('a', 'b', 'c', 'd', 'e'))
with self.assertRaises(Exception):
# cannot have an assignment target that is not in the Series
s1.assign[['f', 'd']](10)
self.assertEqual(
s1.assign[['d', 'c']](Series((10, 20),
index=('d', 'c'))).to_pairs(),
(('a', 0), ('b', 1), ('c', 20), ('d', 10), ('e', 4)))
self.assertEqual(
s1.assign[['c', 'd']](Series((10, 20),
index=('d', 'c'))).to_pairs(),
(('a', 0), ('b', 1), ('c', 20), ('d', 10), ('e', 4)))
self.assertEqual(
s1.assign[['c', 'd']](Series((10, 20, 30),
index=('d', 'c', 'f'))).to_pairs(),
(('a', 0), ('b', 1), ('c', 20), ('d', 10), ('e', 4)))
self.assertEqual(
s1.assign[['c', 'd', 'b']](Series((10, 20), index=('d', 'c')),
fill_value=-1).to_pairs(),
(('a', 0), ('b', -1), ('c', 20), ('d', 10), ('e', 4)))
def test_display_cell_fill_width_a(self) -> None:
config_width_12 = sf.DisplayConfig.from_default(
cell_max_width=12, cell_max_width_leftmost=12, type_color=False)
config_width_6 = sf.DisplayConfig.from_default(
cell_max_width=6, cell_max_width_leftmost=6, type_color=False)
def chunks(size: int, count: int) -> tp.Iterator[str]:
pos = 0
for _ in range(count):
yield LONG_SAMPLE_STR[pos:pos + size]
pos = pos + size
s = Series(chunks(20, 3), index=('a', 'b', 'c'))
self.assertEqual(
s.display(config=config_width_12).to_rows(), [
'<Series>', '<Index>', 'a Lorem ips...',
'b t amet, c...', 'c adipiscin...',
'<<U1> <<U20>'
])
self.assertEqual(
s.display(config=config_width_6).to_rows(), [
'<Se...', '<In...', 'a Lor...', 'b t a...',
'c adi...', '<<U1> <<U20>'
])
config = sf.DisplayConfig.from_default(type_color=False,
cell_max_width_leftmost=20)
row_count = 2
index = [str(chr(x)) for x in range(97, 97 + row_count)]
f = FrameGO(index=index)
for i in range(4):
chunker = iter(chunks(10, row_count))
s = Series((x for x in chunker), index=index)
f[i] = s
f.columns._update_array_cache()
self.assertEqual(
f.display(config=config).to_rows(), [
'<FrameGO>',
'<IndexGO> 0 1 2 3 <int64>',
'<Index>',
'a Lorem ipsu Lorem ipsu Lorem ipsu Lorem ipsu',
'b m dolor si m dolor si m dolor si m dolor si',
'<<U1> <<U10> <<U10> <<U10> <<U10>'
])
self.assertEqual(
f.display(config=config_width_6).to_rows(), [
'<Fr...', '<In... 0 1 2 3 <in...',
'<In...', 'a Lor... Lor... Lor... Lor...',
'b m d... m d... m d... m d...',
'<<U1> <<U10> <<U10> <<U10> <<U10>'
])
def test_series_assign_g(self):
s1 = Series(range(5), index=('a', 'b', 'c', 'd', 'e'), name='x')
s2 = Series(list('abc'), index=list('abc'), name='y')
post = s1.assign[s2.index](s2)
self.assertEqual(post.name, 'x')
self.assertEqual(post.values.tolist(), ['a', 'b', 'c', 3, 4])
def test_hierarchy_series_a(self):
f = IndexHierarchy.from_tree
s1 = Series(23, index=f(dict(a=(1, 2, 3))))
self.assertEqual(s1.values.tolist(), [23, 23, 23])
f = IndexHierarchy.from_product
s2 = Series(3, index=f(Index(('a', 'b')), Index((1, 2))))
self.assertEqual(s2.to_pairs(), ((('a', 1), 3), (('a', 2), 3),
(('b', 1), 3), (('b', 2), 3)))
def test_matmul_e(self) -> None:
# lhs: series, rhs: series
s1 = Series((3, 4, 2), index=('x', 'y', 'z'))
s2 = Series((10, 11, 12), index=('x', 'y', 'z'))
self.assertEqual(matmul(s1, s2), 98)
self.assertEqual(matmul(s1, s2.values), 98)
def test_series_unique_a(self):
s1 = Series([10, 10, 2, 2], index=('a', 'b', 'c', 'd'), dtype=int)
self.assertEqual(s1.unique().tolist(), [2, 10])
s2 = Series(['b', 'b', 'c', 'c'],
index=('a', 'b', 'c', 'd'),
dtype=object)
self.assertEqual(s2.unique().tolist(), ['b', 'c'])
def test_series_binary_operator_b(self):
'''Test binary operators with Series of same index
'''
s1 = Series(range(4), index=('a', 'b', 'c', 'd'))
s2 = Series((x * 2 for x in range(4)), index=('a', 'b', 'c', 'd'))
self.assertEqual(list((s1 + s2).items()), [('a', 0), ('b', 3),
('c', 6), ('d', 9)])
self.assertEqual(list((s1 * s2).items()), [('a', 0), ('b', 2),
('c', 8), ('d', 18)])
def test_index_intersection_c(self) -> None:
idx1 = Index((10, 20))
with self.assertRaises(RuntimeError):
# raises as it identifies labelled data
_ = idx1.intersection(Series([20, 30]))
idx2 = idx1.intersection(Series([20, 30]).values)
self.assertEqual(idx2.values.tolist(), [20])
idx3 = idx1.intersection([20, 30])
self.assertEqual(idx3.values.tolist(), [20])
def test_series_init_b(self):
s1 = Series(['a', 'b', 'c', 'd'], index=('a', 'b', 'c', 'd'))
self.assertEqual(s1.to_pairs(),
(('a', 'a'), ('b', 'b'), ('c', 'c'), ('d', 'd')))
# testing direct specification of string type
s2 = Series(['a', 'b', 'c', 'd'],
index=('a', 'b', 'c', 'd'),
dtype=str)
self.assertEqual(s2.to_pairs(),
(('a', 'a'), ('b', 'b'), ('c', 'c'), ('d', 'd')))
def test_series_binary_operator_c(self):
'''Test binary operators with Series of different index
'''
s1 = Series(range(4), index=('a', 'b', 'c', 'd'))
s2 = Series((x * 2 for x in range(4)), index=('c', 'd', 'e', 'f'))
self.assertAlmostEqualItems(list((s1 * s2).items()), [('a', nan),
('b', nan),
('c', 0),
('d', 6),
('e', nan),
('f', nan)])
def test_series_pickle_a(self):
s1 = Series(range(6), index=list('abcdef'))
s2 = Series((2, 3, 0, -1, 8, 6), index=list('abcdef'))
s3 = s2.astype(bool)
for series in (s1, s2, s3):
pbytes = pickle.dumps(series)
series_new = pickle.loads(pbytes)
for v in series: # iter labels
# this compares series objects
self.assertFalse(series_new.values.flags.writeable)
self.assertEqual(series_new.loc[v], series.loc[v])
def test_series_from_concat_c(self):
s1 = Series((
2,
3,
0,
), index=list('abc'))
s2 = Series(('10', '20'), index=list('de'))
s3 = Series((8, 6), index=(1, 2))
s = Series.from_concat((s1, s2, s3))
self.assertEqual(s.to_pairs(),
(('a', 2), ('b', 3), ('c', 0), ('d', '10'),
('e', '20'), (1, 8), (2, 6)))
def test_series_from_concat_a(self):
s1 = Series((
2,
3,
0,
), index=list('abc'))
s2 = Series((10, 20), index=list('de'))
s3 = Series((8, 6), index=list('fg'))
s = Series.from_concat((s1, s2, s3))
self.assertEqual(s.to_pairs(),
(('a', 2), ('b', 3), ('c', 0), ('d', 10), ('e', 20),
('f', 8), ('g', 6)))
def test_frame_via_fill_value_e(self) -> None:
f1 = FrameGO(index=range(5))
f1.via_fill_value(0)['a'] = Series([10, 20], index=(2, 4))
f1.via_fill_value(-1)['b'] = Series([10, 20], index=(0, 1))
self.assertEqual(f1.to_pairs(),
(('a', ((0, 0), (1, 0), (2, 10), (3, 0), (4, 20))),
('b', ((0, 10), (1, 20), (2, -1), (3, -1),
(4, -1)))))
f2 = Frame(index=range(5))
with self.assertRaises(TypeError):
f2.via_fill_value(0)['a'] = range(5) # type: ignore #pylint: disable=E1137
def test_series_init_d(self):
# single element, when the element is a string
s1 = Series('abc', index=range(4))
self.assertEqual(s1.to_pairs(),
((0, 'abc'), (1, 'abc'), (2, 'abc'), (3, 'abc')))
# this is an array with shape == (), or a single element
s2 = Series(np.array('abc'), index=range(4))
self.assertEqual(s2.to_pairs(),
((0, 'abc'), (1, 'abc'), (2, 'abc'), (3, 'abc')))
# single element, generator index
s3 = Series(None, index=(x * 10 for x in (1, 2, 3)))
self.assertEqual(s3.to_pairs(), ((10, None), (20, None), (30, None)))
def test_series_fillna_a(self):
s1 = Series((234.3, 3.2, 6.4, np.nan), index=('a', 'b', 'c', 'd'))
s2 = Series((234.3, None, 6.4, np.nan), index=('a', 'b', 'c', 'd'))
s3 = Series((234.3, 5, 6.4, -234.3), index=('a', 'b', 'c', 'd'))
s4 = Series((234.3, None, None, None), index=('a', 'b', 'c', 'd'))
s5 = Series(('p', 'q', 'e', 'g'), index=('a', 'b', 'c', 'd'))
s6 = Series((False, True, False, True), index=('a', 'b', 'c', 'd'))
s7 = Series((10, 20, 30, 40), index=('a', 'b', 'c', 'd'))
s8 = Series((234.3, None, 6.4, np.nan, 'q'),
index=('a', 'b', 'c', 'd', 'e'))
self.assertEqual(
s1.fillna(0.0).values.tolist(), [234.3, 3.2, 6.4, 0.0])
self.assertEqual(
s1.fillna(-1).values.tolist(), [234.3, 3.2, 6.4, -1.0])
# given a float array, inserting None, None is casted to nan
self.assertEqual(
s1.fillna(None).values.tolist(), [234.3, 3.2, 6.4, None])
post = s1.fillna('wer')
self.assertEqual(post.dtype, object)
self.assertEqual(post.values.tolist(), [234.3, 3.2, 6.4, 'wer'])
post = s7.fillna(None)
self.assertEqual(post.dtype, int)
def test_series_assign_c(self):
s1 = Series(range(4), index=('a', 'b', 'c', 'd'))
self.assertEqual(s1.assign.loc['c':](0).to_pairs(),
(('a', 0), ('b', 1), ('c', 0), ('d', 0)))
self.assertEqual(s1.assign.loc['c':]((20, 30)).to_pairs(),
(('a', 0), ('b', 1), ('c', 20), ('d', 30)))
self.assertEqual(s1.assign['c':](s1['c':] * 10).to_pairs(),
(('a', 0), ('b', 1), ('c', 20), ('d', 30)))
self.assertEqual(
s1.assign['c':](Series({
'd': 40,
'c': 60
})).to_pairs(), (('a', 0), ('b', 1), ('c', 60), ('d', 40)))
def test_series_init_a(self):
s1 = Series(np.nan, index=('a', 'b', 'c', 'd'))
self.assertTrue(s1.dtype == float)
self.assertTrue(len(s1) == 4)
s2 = Series(False, index=('a', 'b', 'c', 'd'))
self.assertTrue(s2.dtype == bool)
self.assertTrue(len(s2) == 4)
s3 = Series(None, index=('a', 'b', 'c', 'd'))
self.assertTrue(s3.dtype == object)
self.assertTrue(len(s3) == 4)
def test_index_loc_to_iloc_boolen_a(self):
idx = Index(('a', 'b', 'c', 'd'))
# returns nothing as index does not match anything
post = idx.loc_to_iloc(Series([False, True, False, True]))
self.assertTrue(len(post) == 0)
post = idx.loc_to_iloc(
Series([False, True, False, True], index=('b', 'c', 'd', 'a')))
self.assertEqual(post.tolist(), [0, 2])
post = idx.loc_to_iloc(
Series([False, True, False, True], index=list('abcd')))
self.assertEqual(post.tolist(), [1, 3])
def test_series_binary_operator_d(self):
s1 = Series(range(4), index=list('abcd'))
s2 = Series(range(3), index=list('abc'))
s3 = s1 + s2
self.assertEqual(
s3.fillna(None).to_pairs(),
(('a', 0), ('b', 2), ('c', 4), ('d', None)))
s1 = Series((False, True, False, True), index=list('abcd'))
s2 = Series([True] * 3, index=list('abc'))
# NOTE: for now, we cannot resolve this case, as after reindexing we get an object array that is not compatible with Boolean array for the NaN4
with self.assertRaises(TypeError):
s3 = s1 | s2
def test_series_from_concat_d(self):
s1 = Series((
2,
3,
0,
), index=list('abc')).reindex_add_level('i')
s2 = Series(('10', '20', '100'),
index=list('abc')).reindex_add_level('ii')
s3 = Series.from_concat((s1, s2))
self.assertEqual(s3.to_pairs(),
((('i', 'a'), 2), (('i', 'b'), 3), (('i', 'c'), 0),
(('ii', 'a'), '10'), (('ii', 'b'), '20'),
(('ii', 'c'), '100')))
def test_series_relabel_b(self):
s1 = Series(range(4), index=('a', 'b', 'c', 'd'))
s2 = s1.relabel({'a': 'x', 'b': 'y', 'c': 'z', 'd': 'q'})
self.assertEqual(list(s2.items()), [('x', 0), ('y', 1), ('z', 2),
('q', 3)])
def test_series_disply_a(self):
s1 = Series((2, 3), index=list('ab'), name='alt')
match = tuple(s1.display(DisplayConfig(type_color=False)))
self.assertEqual(match, (['<Series: alt>'], ['<Index>', ''],
['a', '2'], ['b', '3'], ['<<U1>', '<int64>']))
s2 = Series(('a', 'b'),
index=Index(('x', 'y'), name='bar'),
name='foo')
match = tuple(s2.display(DisplayConfig(type_color=False)))
self.assertEqual(match, (['<Series: foo>'], ['<Index: bar>', ''],
['x', 'a'], ['y', 'b'], ['<<U1>', '<<U1>']))
def test_display_display_rows_a(self) -> None:
config_rows_12 = sf.DisplayConfig.from_default(display_rows=12,
type_color=False)
config_rows_7 = sf.DisplayConfig.from_default(display_rows=7,
type_color=False)
index = list(''.join(x)
for x in combinations(string.ascii_lowercase, 2))
s = Series(range(len(index)), index=index, dtype=np.int64)
# import ipdb; ipdb.set_trace()
self.assertEqual(
s.display(config_rows_12).to_rows(), [
'<Series>', '<Index>', 'ab 0', 'ac 1',
'ad 2', 'ae 3', 'af 4', '... ...',
'wy 320', 'wz 321', 'xy 322', 'xz 323',
'yz 324', '<<U2> <int64>'
])
self.assertEqual(
s.display(config_rows_7).to_rows(), [
'<Series>', '<Index>', 'ab 0', 'ac 1',
'ad 2', '... ...', 'xy 322', 'xz 323',
'yz 324', '<<U2> <int64>'
])
def test_index_millisecond_series_a(self) -> None:
msg = '''2016-04-28 04:22:12.226
2016-04-28 16:29:21.32
2016-04-28 17:36:13.733
2016-04-30 20:21:07.848
2016-05-01 00:00:33.483
2016-05-01 03:02:03.584
2016-05-01 09:26:43.185
2016-05-01 13:45:22.576
2016-05-01 15:25:46.15'''
idx = IndexMillisecond(msg.split('\n'))
s = Series(range(9), index=idx)
self.assertEqual(s['2016-05-01T00:00:33.483'], 4)
self.assertEqual(s['2016-05-01T00:00:33.483':].values.tolist(), # type: ignore # https://github.com/python/typeshed/pull/3024
[4, 5, 6, 7, 8])
self.assertEqual(s['2016-05'].to_pairs(),
((np.datetime64('2016-05-01T00:00:33.483'), 4), (np.datetime64('2016-05-01T03:02:03.584'), 5), (np.datetime64('2016-05-01T09:26:43.185'), 6), (np.datetime64('2016-05-01T13:45:22.576'), 7), (np.datetime64('2016-05-01T15:25:46.150'), 8)))
self.assertEqual(s['2016-05-01T09'].to_pairs(),
((np.datetime64('2016-05-01T09:26:43.185'), 6),))
def test_series_assign_d(self):
s1 = Series(tuple('pqrs'), index=('a', 'b', 'c', 'd'))
s2 = s1.assign['b'](None)
self.assertEqual(s2.to_pairs(),
(('a', 'p'), ('b', None), ('c', 'r'), ('d', 's')))
self.assertEqual(s1.assign['b':](None).to_pairs(),
(('a', 'p'), ('b', None), ('c', None), ('d', None)))
def test_series_shift_a(self):
s1 = Series((2, 3, 0, -1, 8, 6), index=list('abcdef'))
# if the shift is a noop, we reuse the same array
self.assertEqual(s1.mloc, s1.shift(0).mloc)
# default fill is NaN
self.assertEqual(s1.shift(4).dtype, np.dtype('float64'))
# import ipdb; ipdb.set_trace()
self.assertEqual(
s1.shift(4, None).to_pairs(),
(('a', None), ('b', None), ('c', None), ('d', None), ('e', 2),
('f', 3)))
self.assertEqual(
s1.shift(-4, None).to_pairs(),
(('a', 8), ('b', 6), ('c', None), ('d', None), ('e', None),
('f', None)))
self.assertEqual(
s1.shift(6, None).to_pairs(),
(('a', None), ('b', None), ('c', None), ('d', None), ('e', None),
('f', None)))
self.assertEqual(
s1.shift(-6, None).to_pairs(),
(('a', None), ('b', None), ('c', None), ('d', None), ('e', None),
('f', None)))
def test_series_dropna_a(self):
s1 = Series((234.3, 3.2, 6.4, np.nan), index=('a', 'b', 'c', 'd'))
s2 = Series((234.3, None, 6.4, np.nan), index=('a', 'b', 'c', 'd'))
s4 = Series((234.3, None, None, None), index=('a', 'b', 'c', 'd'))
s5 = Series(('p', 'q', 'e', 'g'), index=('a', 'b', 'c', 'd'))
s6 = Series((False, True, False, True), index=('a', 'b', 'c', 'd'))
self.assertEqual(s1.dropna().to_pairs(),
(('a', 234.3), ('b', 3.2), ('c', 6.4)))
self.assertEqual(list(s2.dropna().items()), [('a', 234.3), ('c', 6.4)])
self.assertEqual(s4.dropna().to_pairs(), (('a', 234.3), ))
self.assertEqual(s5.dropna().to_pairs(),
(('a', 'p'), ('b', 'q'), ('c', 'e'), ('d', 'g')))
self.assertEqual(s6.dropna().to_pairs(), (('a', False), ('b', True),
('c', False), ('d', True)))
def test_series_tail_a(self):
s1 = Series(range(100), index=reversed(range(100)))
self.assertEqual(s1.tail().to_pairs(),
((4, 95), (3, 96), (2, 97), (1, 98), (0, 99)))
self.assertEqual(s1.tail(2).to_pairs(), ((1, 98), (0, 99)))
