def test_frame_iter_group_labels_a(self) -> None:
records = (
(2, 2, 'a', False, False),
(30, 34, 'b', True, False),
(2, 95, 'c', False, False),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('x', 'y', 'z'))
with self.assertRaises(TypeError):
f1.iter_group_labels(3, 4)
with self.assertRaises(TypeError):
f1.iter_group_labels(foo=4)
post = tuple(f1.iter_group_labels(0, axis=0))
self.assertEqual(len(post), 3)
self.assertEqual(
f1.iter_group_labels(
0,
axis=0).apply(lambda x: x[['p', 'q']].values.sum()).to_pairs(),
(('x', 4), ('y', 64), ('z', 97)))
def test_frame_iter_group_items_e(self) -> None:
columns = tuple('pqrst')
index = tuple('zxwy')
records = (('A', 1, 'a', False, False), ('A', 2, 'b', True, False),
('B', 1, 'c', False, False), ('B', 2, 'd', True, True))
f = Frame.from_records(records,
columns=columns,
index=index,
name='foo')
# using an array to select
self.assertEqual(
tuple(k for k, v in f.iter_group_items(f.columns == 's')),
((False, ), (True, )))
self.assertEqual(
tuple(k
for k, v in f.iter_group_items(f.columns.isin(('p', 't')))),
(('A', False), ('B', False), ('B', True)))
self.assertEqual(tuple(k for k, v in f.iter_group_items(['s', 't'])),
((False, False), (True, False), (True, True)))
self.assertEqual(
tuple(k for k, v in f.iter_group_items(slice('s', 't'))),
((False, False), (True, False), (True, True)))
def test_display_type_show_a(self):
config_type_show_true = sf.DisplayConfig.from_default(type_show=True,
type_color=False)
config_type_show_false = sf.DisplayConfig.from_default(
type_show=False, type_color=False)
records = (
(2, 2, 'a', False, False),
(30, 34, 'b', True, False),
(2, 95, 'c', False, False),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('w', 'x', 'y'))
self.assertEqual(
f1.display(config_type_show_false).to_rows(), [
'<Frame>',
'<Index> p q r s t',
'<Index>',
'w 2 2 a False False',
'x 30 34 b True False',
'y 2 95 c False False',
])
self.assertEqual(
f1.display(config_type_show_true).to_rows(), [
'<Frame>', '<Index> p q r s t <<U1>',
'<Index>', 'w 2 2 a False False',
'x 30 34 b True False',
'y 2 95 c False False',
'<<U1> <int64> <int64> <<U1> <bool> <bool>'
])
def test_frame_axis_window_items_b(self) -> None:
base = np.array([1, 2, 3, 4])
records = (base * n for n in range(1, 21))
f1 = Frame.from_records(records,
columns=list('ABCD'),
index=self.get_letters(20))
post0 = tuple(f1._axis_window_items(size=2, axis=0, as_array=True))
self.assertEqual(len(post0), 19)
self.assertEqual(post0[0][0], 'b')
self.assertEqual(post0[0][1].__class__, np.ndarray)
self.assertEqual(post0[0][1].shape, (2, 4))
self.assertEqual(post0[-1][0], 't')
self.assertEqual(post0[-1][1].__class__, np.ndarray)
self.assertEqual(post0[-1][1].shape, (2, 4))
post1 = tuple(f1._axis_window_items(size=2, axis=1, as_array=True))
self.assertEqual(len(post1), 3)
self.assertEqual(post1[0][0], 'B')
self.assertEqual(post1[0][1].__class__, np.ndarray)
self.assertEqual(post1[0][1].shape, (20, 2))
self.assertEqual(post1[-1][0], 'D')
self.assertEqual(post1[-1][1].__class__, np.ndarray)
self.assertEqual(post1[-1][1].shape, (20, 2))
def test_frame_axis_interface_b(self) -> None:
# reindex both axis
records = (
(2, 2, 'a', False, False),
(30, 34, 'b', True, False),
(2, 95, 'c', False, False),
(30, 73, 'd', True, True),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('w', 'x', 'y', 'z'))
post = list(f1.iter_group_items('s', axis=0))
self.assertEqual(post[0][1].to_pairs(0),
(('p', (('w', 2), ('y', 2))),
('q', (('w', 2), ('y', 95))), ('r', (('w', 'a'),
('y', 'c'))),
('s', (('w', False), ('y', False))),
('t', (('w', False), ('y', False)))))
self.assertEqual(post[1][1].to_pairs(0),
(('p', (('x', 30), ('z', 30))),
('q', (('x', 34), ('z', 73))), ('r', (('x', 'b'),
('z', 'd'))),
('s', (('x', True), ('z', True))),
('t', (('x', False), ('z', True)))))
s1 = f1.iter_group('p', axis=0).apply(lambda f: f['q'].values.sum())
self.assertEqual(list(s1.items()), [(2, 97), (30, 107)])
def test_display_display_columns_b(self) -> None:
config_columns_4 = sf.DisplayConfig.from_default(display_columns=4,
type_color=False)
config_columns_5 = sf.DisplayConfig.from_default(display_columns=5,
type_color=False)
records = (
(2, 2, 'a', False, False),
(30, 34, 'b', True, False),
(2, 95, 'c', False, False),
)
f = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('w', 'x', 'y'))
self.assertEqual(
f.display(config_columns_4).to_rows(), [
'<Frame>', '<Index> p ... t <<U1>',
'<Index> ...', 'w 2 ... False',
'x 30 ... False', 'y 2 ... False',
'<<U1> <int64> ... <bool>'
])
# at one point the columns woiuld be truncated shorter than the frame when the max xolumns was the same
self.assertEqual(
f.display(config_columns_5).to_rows(), [
'<Frame>', '<Index> p q r s t <<U1>',
'<Index>', 'w 2 2 a False False',
'x 30 34 b True False',
'y 2 95 c False False',
'<<U1> <int64> <int64> <<U1> <bool> <bool>'
])
def test_frame_group_b(self) -> None:
# reindex both axis
records = (
(2, 2, 'a', False, False),
(30, 34, 'b', True, False),
(2, 95, 'c', False, False),
(30, 73, 'd', True, True),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('w', 'x', 'y', 'z'))
# column iter, group by row 0
post = list(f1._axis_group_iloc_items(0, axis=1))
self.assertEqual(post[0][0], 2)
self.assertEqual(post[0][1].to_pairs(0),
(('p', (('w', 2), ('x', 30), ('y', 2), ('z', 30))),
('q', (('w', 2), ('x', 34), ('y', 95), ('z', 73)))))
self.assertEqual(post[1][0], 'a')
self.assertEqual(post[1][1].to_pairs(0),
(('r', (('w', 'a'), ('x', 'b'), ('y', 'c'),
('z', 'd'))), ))
self.assertEqual(post[2][0], False)
self.assertEqual(post[2][1].to_pairs(0),
(('s', (('w', False), ('x', True), ('y', False),
('z', True))),
('t', (('w', False), ('x', False), ('y', False),
('z', True)))))
def test_frame_group_a(self) -> None:
# reindex both axis
records = (
(2, 2, 'a', False, False),
(30, 34, 'b', True, False),
(2, 95, 'c', False, False),
(30, 73, 'd', True, True),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('w', 'x', 'y', 'z'))
post = tuple(f1._axis_group_iloc_items(
4, axis=0)) # row iter, group by column 4
group1, group_frame_1 = post[0]
group2, group_frame_2 = post[1]
self.assertEqual(group1, False)
self.assertEqual(group2, True)
self.assertEqual(group_frame_1.to_pairs(0),
(('p', (('w', 2), ('x', 30), ('y', 2))),
('q', (('w', 2), ('x', 34), ('y', 95))),
('r', (('w', 'a'), ('x', 'b'), ('y', 'c'))),
('s', (('w', False), ('x', True), ('y', False))),
('t', (('w', False), ('x', False), ('y', False)))))
self.assertEqual(group_frame_2.to_pairs(0),
(('p', (('z', 30), )), ('q', (('z', 73), )),
('r', (('z', 'd'), )), ('s', (('z', True), )),
('t', (('z', True), ))))
def test_display_html_index_b(self) -> None:
records = (
(2, 'a', False),
(30, 'b', False),
)
f = Frame.from_records(records,
columns=('p', 'q', 'r'),
index=('w', 'x'))
f = f.set_index_hierarchy(('p', 'q'))
# this uses cell width normaliz
post = f.display(
sf.DisplayConfig(display_format=DisplayFormats.HTML_PRE,
cell_max_width_leftmost=20)).to_rows()
self.assertEqual(
post[2],
'<span style="color: #777777"><IndexHierarchy: ...</span>')
post = f.display(
sf.DisplayConfig(display_format=DisplayFormats.HTML_PRE,
cell_max_width_leftmost=36)).to_rows()
self.assertEqual(
post[2],
'<span style="color: #777777"><IndexHierarchy: ('p', 'q')></span>'
)
def test_frame_iter_group_items_a(self) -> None:
# testing a hierarchical index and columns, selecting column with a tuple
records = (('a', 999999, 0.1), ('a', 201810, 0.1), ('b', 999999, 0.4),
('b', 201810, 0.4))
f1 = Frame.from_records(records, columns=list('abc'))
f1 = f1.set_index_hierarchy(['a', 'b'], drop=False)
f1 = f1.relabel_level_add(columns='i')
groups = list(f1.iter_group_items(('i', 'a'), axis=0))
self.assertEqual(groups[0][0], 'a')
self.assertEqual(
groups[0][1].to_pairs(0),
((('i', 'a'), ((('a', 999999), 'a'), (('a', 201810), 'a'))),
(('i', 'b'), ((('a', 999999), 999999), (('a', 201810), 201810))),
(('i', 'c'), ((('a', 999999), 0.1), (('a', 201810), 0.1)))))
self.assertEqual(groups[1][0], 'b')
self.assertEqual(
groups[1][1].to_pairs(0),
((('i', 'a'), ((('b', 999999), 'b'), (('b', 201810), 'b'))),
(('i', 'b'), ((('b', 999999), 999999), (('b', 201810), 201810))),
(('i', 'c'), ((('b', 999999), 0.4), (('b', 201810), 0.4)))))
def test_frame_iter_group_labels_b(self) -> None:
records = (
(2, 2, 'a', 'q', False, False),
(30, 34, 'b', 'c', True, False),
(2, 95, 'c', 'd', False, False),
)
f1 = Frame.from_records(records,
columns=IndexHierarchy.from_product(
(1, 2, 3), ('a', 'b')),
index=('x', 'y', 'z'))
# with axis 1, we are grouping based on columns while maintain the index
post_tuple = tuple(f1.iter_group_labels(1, axis=1))
self.assertEqual(len(post_tuple), 2)
post = f1[HLoc[f1.columns[0]]]
self.assertEqual(post.__class__, Series)
self.assertEqual(post.to_pairs(), (('x', 2), ('y', 30), ('z', 2)))
post = f1.loc[:, HLoc[f1.columns[0]]]
self.assertEqual(post.__class__, Series)
self.assertEqual(post.to_pairs(), (('x', 2), ('y', 30), ('z', 2)))
self.assertEqual(
f1.iter_group_labels(
1, axis=1).apply(lambda x: x.iloc[:, 0].sum()).to_pairs(),
(('a', 34), ('b', 131)))
def to_frame(self):
'''
Return the index as a Frame.
'''
from static_frame import Frame
return Frame.from_records(self.__iter__(),
columns=range(self._depth),
index=None)
def test_frame_iter_element_e(self) -> None:
f1 = Frame.from_records(np.arange(9).reshape(3, 3))
self.assertEqual(list(f1.iter_element(axis=1)),
[0, 3, 6, 1, 4, 7, 2, 5, 8])
mapping = {x: x * 3 for x in range(9)}
f2 = f1.iter_element(axis=1).map_all(mapping)
self.assertEqual([d.kind for d in f2.dtypes.values], ['i', 'i', 'i'])
def test_frame_iter_a(self) -> None:
records = ((1, 2, 'a', False, True), (30, 50, 'b', True, False))
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('x', 'y'))
self.assertEqual((f1.keys() == f1.columns).all(), True)
self.assertEqual([x for x in f1.columns], ['p', 'q', 'r', 's', 't'])
self.assertEqual([x for x in f1], ['p', 'q', 'r', 's', 't'])
def test_frame_reversed(self) -> None:
columns = tuple('pqrst')
index = tuple('zxwy')
records = ((2, 2, 'a', False, False), (30, 34, 'b', True, False),
(2, 95, 'c', False, False), (30, 73, 'd', True, True))
f = Frame.from_records(records,
columns=columns,
index=index,
name='foo')
self.assertTrue(tuple(reversed(f)) == tuple(reversed(columns)))
def test_display_html_table_b(self) -> None:
records = (
(2, 'a', False),
(30, 'b', False),
)
f = Frame.from_records(records,
columns=('p', 'q', 'r'),
index=('w', 'x'))
self.assertEqual(
f._repr_html_(),
'<table border="1"><thead><tr><th></th><th>p</th><th>q</th><th>r</th></tr></thead><tbody><tr><th>w</th><td>2</td><td>a</td><td>False</td></tr><tr><th>x</th><td>30</td><td>b</td><td>False</td></tr></tbody></table>'
)
def test_frame_to_clipboard_a(self) -> None:
records = (
(2, 'a', False),
(3, 'b', False),
)
f1 = Frame.from_records(records,
columns=('r', 's', 't'),
index=('w', 'x'))
f1.to_clipboard()
f2 = Frame.from_clipboard(index_depth=1)
self.assertTrue(f2.equals(f1, compare_dtype=True))
def test_display_html_series_a(self):
records = (
(2, 'a', False),
(30, 'b', False),
)
f = Frame.from_records(records,
columns=('p', 'q', 'r'),
index=('w', 'x'))
self.assertEqual(
f['q']._repr_html_(),
'<table border="1"><thead><tr><th><span style="color: #777777"><Series: q></span></th><th></th></tr><tr><th><span style="color: #777777"><Index></span></th><th></th></tr></thead><tbody><tr><th>w</th><td>a</td></tr><tr><th>x</th><td>b</td></tr></tbody></table>'
)
def test_frame_iter_group_b(self) -> None:
columns = tuple('pqrst')
index = tuple('zxwy')
records = (('A', 1, 'a', False, False), ('A', 2, 'b', True, False),
('B', 1, 'c', False, False), ('B', 2, 'd', True, True))
f = Frame.from_records(records,
columns=columns,
index=index,
name='foo')
post = f.iter_group(['p', 'q']).apply(len)
self.assertEqual(post.to_pairs(), ((('A', 1), 1), (('A', 2), 1),
(('B', 1), 1), (('B', 2), 1)))
def test_frame_iter_array_a(self) -> None:
records = ((1, 2, 'a', False, True), (30, 50, 'b', True, False))
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('x', 'y'))
self.assertEqual(next(iter(f1.iter_array(axis=0))).tolist(), [1, 30])
self.assertEqual(
next(iter(f1.iter_array(axis=1))).tolist(),
[1, 2, 'a', False, True])
def test_display_html_series_a(self) -> None:
records = (
(2, 'a', False),
(30, 'b', False),
)
f = Frame.from_records(records,
columns=('p', 'q', 'r'),
index=('w', 'x'))
self.assertEqual(
f['q']._repr_html_(),
'<table><tbody><tr><th>w</th><td>a</td></tr><tr><th>x</th><td>b</td></tr></tbody></table>'
)
def test_frame_iter_group_labels_array_a(self) -> None:
columns = tuple('pqrs')
index = tuple('zxwy')
records = (('A', 1, False, False), ('A', 2, True, False),
('B', 1, False, False), ('B', 2, True, True))
f = Frame.from_records(records, columns=columns, index=index)
f = f.set_index_hierarchy(('p', 'q'), drop=True)
post1 = tuple(f.iter_group_labels_array(0))
self.assertEqual(len(post1), 2)
self.assertEqual([a.__class__ for a in post1],
[np.ndarray, np.ndarray])
self.assertEqual([a.shape for a in post1], [(2, 2), (2, 2)])
def test_frame_iter_group_items_b(self) -> None:
columns = tuple('pqrst')
index = tuple('zxwy')
records = (('A', 1, 'a', False, False), ('A', 2, 'b', True, False),
('B', 1, 'c', False, False), ('B', 2, 'd', True, True))
f = Frame.from_records(records,
columns=columns,
index=index,
name='foo')
f = f.set_index_hierarchy(('p', 'q'), drop=True)
post = f.iter_group_items('s').apply(lambda k, x: f'{k}: {len(x)}')
self.assertEqual(post.to_pairs(),
((False, 'False: 2'), (True, 'True: 2')))
def test_frame_axis_interface_a(self) -> None:
# reindex both axis
records = (
(1, 2, 'a', False, True),
(30, 34, 'b', True, False),
(54, 95, 'c', False, False),
(65, 73, 'd', True, True),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('w', 'x', 'y', 'z'))
self.assertEqual(f1.to_pairs(1),
(('w', (('p', 1), ('q', 2), ('r', 'a'), ('s', False),
('t', True))), ('x', (('p', 30), ('q', 34),
('r', 'b'), ('s', True),
('t', False))),
('y', (('p', 54), ('q', 95), ('r', 'c'),
('s', False), ('t', False))),
('z', (('p', 65), ('q', 73), ('r', 'd'), ('s', True),
('t', True)))))
for x in f1.iter_tuple(axis=0):
self.assertTrue(len(x), 4)
for x in f1.iter_tuple(axis=1):
self.assertTrue(len(x), 5)
f2 = f1[['p', 'q']]
s1 = f2.iter_array(axis=0).apply(np.sum)
self.assertEqual(list(s1.items()), [('p', 150), ('q', 204)])
s2 = f2.iter_array(axis=1).apply(np.sum)
self.assertEqual(list(s2.items()), [('w', 3), ('x', 64), ('y', 149),
('z', 138)])
def sum_if(idx: tp.Hashable,
vals: tp.Iterable[int]) -> tp.Optional[int]:
if idx in ('x', 'z'):
return tp.cast(int, np.sum(vals))
return None
s3 = f2.iter_array_items(axis=1).apply(sum_if)
self.assertEqual(list(s3.items()), [('w', None), ('x', 64),
('y', None), ('z', 138)])
def test_display_cell_align_left_b(self) -> None:
config_right = sf.DisplayConfig.from_default(cell_align_left=False,
type_color=False)
config_left = sf.DisplayConfig.from_default(cell_align_left=True,
type_color=False)
s = Series(range(3), index=('a', 'b', 'c'), dtype=np.int64)
self.assertEqual(
s.display(config_right).to_rows(), [
'<Series>', ' <Index>', ' a 0', ' b 1',
' c 2', ' <<U1> <int64>'
])
self.assertEqual(
s.display(config_left).to_rows(), [
'<Series>', '<Index>', 'a 0', 'b 1',
'c 2', '<<U1> <int64>'
])
records = (
(2, 2, 'a', False, False),
(30, 34, 'b', True, False),
(2, 95, 'c', False, False),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r', 's', 't'),
index=('w', 'x', 'y'))
self.assertEqual(
f1.display(config_left).to_rows(), [
'<Frame>', '<Index> p q r s t <<U1>',
'<Index>', 'w 2 2 a False False',
'x 30 34 b True False',
'y 2 95 c False False',
'<<U1> <int64> <int64> <<U1> <bool> <bool>'
])
self.assertEqual(
f1.display(config_right).to_rows(), [
'<Frame>', '<Index> p q r s t <<U1>',
'<Index>', ' w 2 2 a False False',
' x 30 34 b True False',
' y 2 95 c False False',
' <<U1> <int64> <int64> <<U1> <bool> <bool>'
])
def test_frame_iter_window_a(self) -> None:
base = np.array([1, 2, 3, 4])
records = (base * n for n in range(1, 21))
f1 = Frame.from_records(records,
columns=list('ABCD'),
index=self.get_letters(20))
self.assertEqual(
f1.iter_window(size=3).apply(lambda f: f['B'].sum()).to_pairs(),
(('c', 12), ('d', 18), ('e', 24), ('f', 30), ('g', 36), ('h', 42), ('i', 48), ('j', 54), ('k', 60), ('l', 66), ('m', 72), ('n', 78), ('o', 84), ('p', 90), ('q', 96), ('r', 102), ('s', 108), ('t', 114))
)
post = list(f1.iter_window(size=3))
self.assertEqual(len(post), 18)
self.assertTrue(all(f.shape == (3, 4) for f in post))
def test_frame_iter_group_labels_f(self) -> None:
columns = tuple('pqrst')
index = tuple('zxwy')
records = (('A', 1, 'a', False, 4), (None, 2, 'b', True, 3),
('B', 1, 'c', False, 2), ('B', None, 'd', True, 1))
f = Frame.from_records(records,
columns=columns,
index=index,
name='foo')
f = f.set_index_hierarchy(('p', 'q'), drop=True)
post = tuple(f.iter_group_labels_items(0, axis=0))
self.assertEqual([p[0] for p in post], ['A', None, 'B'])
self.assertEqual([p[1].values.tolist() for p in post],
[[['a', False, 4]], [['b', True, 3]],
[['c', False, 2], ['d', True, 1]]])
def test_frame_iter_group_a(self) -> None:
columns = tuple('pqrst')
index = tuple('zxwy')
records = (('A', 1, 'a', False, False), ('A', 2, 'b', True, False),
('B', 1, 'c', False, False), ('B', 2, 'd', True, True))
f = Frame.from_records(records,
columns=columns,
index=index,
name='foo')
f = f.set_index_hierarchy(('p', 'q'), drop=True)
with self.assertRaises(AxisInvalid):
_ = f.iter_group('s', axis=-1).apply(lambda x: x.shape)
post = f.iter_group('s').apply(lambda x: x.shape)
self.assertEqual(post.to_pairs(), ((False, (2, 3)), (True, (2, 3))))
self.assertEqual(post.index.name, 's')
def test_hierarchy_boolean_loc(self):
records = (
('a', 999999, 0.1),
('a', 201810, 0.1),
('b', 999999, 0.4),
('b', 201810, 0.4))
f1 = Frame.from_records(records, columns=list('abc'))
f1 = f1.set_index_hierarchy(['a', 'b'], drop=False)
f2 = f1.loc[f1['b'] == 999999]
self.assertEqual(f2.to_pairs(0),
(('a', ((('a', 999999), 'a'), (('b', 999999), 'b'))), ('b', ((('a', 999999), 999999), (('b', 999999), 999999))), ('c', ((('a', 999999), 0.1), (('b', 999999), 0.4)))))
f3 = f1.loc[Series([False, True], index=(('b', 999999), ('b', 201810)))]
self.assertEqual(f3.to_pairs(0),
(('a', ((('b', 201810), 'b'),)), ('b', ((('b', 201810), 201810),)), ('c', ((('b', 201810), 0.4),))))
def test_display_max_width_a(self) -> None:
records = (
(2, 'a', False),
(30, 'b', False),
)
f1 = Frame.from_records(records,
columns=('p', 'q', 'r'),
index=('w', 'x'))
f2 = f1.set_index_hierarchy(('p', 'q'))
post = f2.display(
sf.DisplayConfig(type_color=False,
cell_max_width_leftmost=20)).to_rows()
self.assertEqual(post[2], '<IndexHierarchy: ...')
post = f2.display(
sf.DisplayConfig(type_color=False,
cell_max_width_leftmost=30)).to_rows()
self.assertEqual(post[2], "<IndexHierarchy: ('p', 'q')>")