def test_frame_iter_element_c(self) -> None:
a2 = np.array([[None, None], [None, 1], [None, 5]], dtype=object)
a1 = np.array([True, False, True])
a3 = np.array([['a'], ['b'], ['c']])
tb1 = TypeBlocks.from_blocks((a3, a1, a2))
f1 = Frame(tb1,
index=self.get_letters(None, tb1.shape[0]),
columns=IndexHierarchy.from_product(('i', 'ii'),
('a', 'b')))
values = list(f1.iter_element())
self.assertEqual(
values,
['a', True, None, None, 'b', False, None, 1, 'c', True, None, 5])
f2 = f1.iter_element().apply(lambda x: str(x).lower().replace('e', ''))
self.assertEqual(
f1.columns.__class__,
f2.columns.__class__,
)
self.assertEqual(
f2.to_pairs(0),
((('i', 'a'), (('a', 'a'), ('b', 'b'), ('c', 'c'))),
(('i', 'b'), (('a', 'tru'), ('b', 'fals'), ('c', 'tru'))),
(('ii', 'a'), (('a', 'non'), ('b', 'non'), ('c', 'non'))),
(('ii', 'b'), (('a', 'non'), ('b', '1'), ('c', '5')))))
def test_display_truncate_a(self) -> None:
config_rows_12_cols_8 = sf.DisplayConfig.from_default(
display_rows=12, display_columns=8)
config_rows_7_cols_5 = sf.DisplayConfig.from_default(display_rows=7,
display_columns=5)
size = 10000
columns = 100
a1 = (np.arange(size * columns)).reshape((size, columns)) * .001
# insert random nan in very other columns
for col in range(0, 100, 2):
a1[:100, col] = np.nan
index = (hashlib.sha224(str(x).encode('utf-8')).hexdigest()
for x in range(size))
cols = (hashlib.sha224(str(x).encode('utf-8')).hexdigest()
for x in range(columns))
f = Frame(a1, index=index, columns=cols)
self.assertEqual(
len(tuple(f.display(config_rows_12_cols_8).to_rows())), 15)
self.assertEqual(len(tuple(f.display(config_rows_7_cols_5).to_rows())),
11)
def test_frame_via_fill_value_loc_h(self) -> None:
f1 = Frame(np.arange(12).reshape(4, 3),
index=tuple('abcd'),
columns=tuple('xyz'))
f2 = f1.via_fill_value(-1).loc[['d', 'e'], 'w']
self.assertEqual(f2.to_pairs(), (('d', -1), ('e', -1)))
def test_frame_via_fill_value_loc_d(self) -> None:
f1 = Frame(np.arange(12).reshape(4, 3),
index=tuple('abcd'),
columns=tuple('xyz'))
s1 = f1.via_fill_value(-1).loc['q', ['w', 'y', 'z']]
self.assertEqual(s1.to_pairs(), (('w', -1), ('y', -1), ('z', -1)))
self.assertEqual(s1.name, 'q')
def test_frame_via_fill_value_loc_b(self) -> None:
f1 = Frame(np.arange(12).reshape(4, 3),
index=tuple('abcd'),
columns=tuple('xyz'),
name='foo')
self.assertEqual(f1.via_fill_value(-1).loc['a', 'z'], 2)
self.assertEqual(f1.via_fill_value(-1).loc['a', 'w'], -1)
self.assertEqual(f1.name, 'foo')
def test_frame_via_fill_value_loc_a(self) -> None:
f1 = Frame(np.arange(12).reshape(4, 3),
index=tuple('abcd'),
columns=tuple('xyz'),
name='foo')
f2 = f1.via_fill_value(-1).loc['c':, ['w', 'x']]
self.assertEqual(f2.to_pairs(), (('w', (('c', -1), ('d', -1))),
('x', (('c', 6), ('d', 9)))))
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_frame_via_fill_value_loc_e1(self) -> None:
f1 = Frame(np.arange(12).reshape(4, 3),
index=tuple('abcd'),
columns=tuple('xyz'))
s1 = f1.via_fill_value(-1)['y']
self.assertEqual(s1.to_pairs(),
(('a', 1), ('b', 4), ('c', 7), ('d', 10)))
f2 = f1.via_fill_value(-1)[['y', 'w']]
self.assertEqual(f2.to_pairs(),
(('y', (('a', 1), ('b', 4), ('c', 7), ('d', 10))),
('w', (('a', -1), ('b', -1), ('c', -1), ('d', -1)))))
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_display_html_pre_a(self):
f = Frame(dict(a=(1, 2), b=(1.2, 3.4), c=(False, True)))
expected = f.display(
sf.DisplayConfig(display_format='html_pre', type_color=False))
html = '''<div style="white-space: pre; font-family: monospace"><Frame>
<Index> a b c <<U1>
<Index>
0 1 1.2 False
1 2 3.4 True
<int64> <int64> <float64> <bool></div>'''
self.assertEqual(html.strip(), str(expected).strip())
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_iter_array_d(self) -> None:
arrays = []
for _ in range(8):
arrays.append(list(range(8)))
f1 = Frame.from_items(zip(range(8), arrays))
# when called with a pool, values are gien the func as a single argument, which for an element iteration is a tuple of coord, value
func = lambda arg: arg[0][1]
# iter columns
post = f1.iter_element_items().apply_pool(func,
max_workers=4,
use_threads=True)
self.assertEqual(
post.to_pairs(0),
((0, ((0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0),
(7, 0))), (1, ((0, 1), (1, 1), (2, 1), (3, 1), (4, 1),
(5, 1), (6, 1), (7, 1))),
(2, ((0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2),
(7, 2))), (3, ((0, 3), (1, 3), (2, 3), (3, 3), (4, 3),
(5, 3), (6, 3), (7, 3))),
(4, ((0, 4), (1, 4), (2, 4), (3, 4), (4, 4), (5, 4), (6, 4),
(7, 4))), (5, ((0, 5), (1, 5), (2, 5), (3, 5), (4, 5),
(5, 5), (6, 5), (7, 5))),
(6, ((0, 6), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6),
(7, 6))), (7, ((0, 7), (1, 7), (2, 7), (3, 7), (4, 7),
(5, 7), (6, 7), (7, 7)))))
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_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 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_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_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_array_c(self) -> None:
arrays = []
for _ in range(8):
arrays.append(list(range(8)))
f1 = Frame.from_items(zip(range(8), arrays))
func = {x: chr(x + 65) for x in range(8)}
# iter columns
post = f1.iter_element().apply_pool(func,
max_workers=4,
use_threads=True)
self.assertEqual(post.to_pairs(0),
((0, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'))),
(1, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'))),
(2, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'))),
(3, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'))),
(4, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'))),
(5, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'))),
(6, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'))),
(7, ((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'),
(4, 'E'), (5, 'F'), (6, 'G'), (7, 'H')))))
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_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_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_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_hierarchy_frame_a(self):
OD = OrderedDict
tree = OD([
('I', OD([
('A', (1,)), ('B', (1, 2))
])
),
('II', OD([
('A', (1,)), ('B', (1, 2))
])
),
])
ih = IndexHierarchy.from_tree(tree)
data = np.arange(6*6).reshape(6, 6)
f1 = Frame(data, index=ih, columns=ih)
# self.assertEqual(len(f.to_pairs(0)), 8)
f2 = f1.assign.loc[('I', 'B', 2), ('II', 'A', 1)](200)
post = f2.to_pairs(0)
self.assertEqual(post,
((('I', 'A', 1), ((('I', 'A', 1), 0), (('I', 'B', 1), 6), (('I', 'B', 2), 12), (('II', 'A', 1), 18), (('II', 'B', 1), 24), (('II', 'B', 2), 30))), (('I', 'B', 1), ((('I', 'A', 1), 1), (('I', 'B', 1), 7), (('I', 'B', 2), 13), (('II', 'A', 1), 19), (('II', 'B', 1), 25), (('II', 'B', 2), 31))), (('I', 'B', 2), ((('I', 'A', 1), 2), (('I', 'B', 1), 8), (('I', 'B', 2), 14), (('II', 'A', 1), 20), (('II', 'B', 1), 26), (('II', 'B', 2), 32))), (('II', 'A', 1), ((('I', 'A', 1), 3), (('I', 'B', 1), 9), (('I', 'B', 2), 200), (('II', 'A', 1), 21), (('II', 'B', 1), 27), (('II', 'B', 2), 33))), (('II', 'B', 1), ((('I', 'A', 1), 4), (('I', 'B', 1), 10), (('I', 'B', 2), 16), (('II', 'A', 1), 22), (('II', 'B', 1), 28), (('II', 'B', 2), 34))), (('II', 'B', 2), ((('I', 'A', 1), 5), (('I', 'B', 1), 11), (('I', 'B', 2), 17), (('II', 'A', 1), 23), (('II', 'B', 1), 29), (('II', 'B', 2), 35))))
)
f3 = f1.assign.loc[('I', 'B', 2):, HLoc[:, :, 2]](200)
self.assertEqual(f3.to_pairs(0),
((('I', 'A', 1), ((('I', 'A', 1), 0), (('I', 'B', 1), 6), (('I', 'B', 2), 12), (('II', 'A', 1), 18), (('II', 'B', 1), 24), (('II', 'B', 2), 30))), (('I', 'B', 1), ((('I', 'A', 1), 1), (('I', 'B', 1), 7), (('I', 'B', 2), 13), (('II', 'A', 1), 19), (('II', 'B', 1), 25), (('II', 'B', 2), 31))), (('I', 'B', 2), ((('I', 'A', 1), 2), (('I', 'B', 1), 8), (('I', 'B', 2), 200), (('II', 'A', 1), 200), (('II', 'B', 1), 200), (('II', 'B', 2), 200))), (('II', 'A', 1), ((('I', 'A', 1), 3), (('I', 'B', 1), 9), (('I', 'B', 2), 15), (('II', 'A', 1), 21), (('II', 'B', 1), 27), (('II', 'B', 2), 33))), (('II', 'B', 1), ((('I', 'A', 1), 4), (('I', 'B', 1), 10), (('I', 'B', 2), 16), (('II', 'A', 1), 22), (('II', 'B', 1), 28), (('II', 'B', 2), 34))), (('II', 'B', 2), ((('I', 'A', 1), 5), (('I', 'B', 1), 11), (('I', 'B', 2), 200), (('II', 'A', 1), 200), (('II', 'B', 1), 200), (('II', 'B', 2), 200))))
)
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 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_index_level_label_widths_at_depth_b(self) -> None:
f = Frame.from_dict(
dict(a=(1,2,3,4), b=(True, False, True, False), c=list('qrst')))
f = f.set_index_hierarchy(['a', 'b'])
post1 = tuple(f.index._levels.label_widths_at_depth(0))
self.assertEqual(post1, ((1, 1), (2, 1), (3, 1), (4, 1)))
post2 = tuple(f.index._levels.label_widths_at_depth(1))
self.assertEqual(post2, ((True, 1), (False, 1), (True, 1), (False, 1)))
def test_frame_via_fill_value_c(self) -> None:
f1 = Frame(np.arange(20).reshape(4, 5), index=tuple('abcd'))
f2 = f1.via_T.via_fill_value(0) * Series((0, 2), index=tuple('bc'))
self.assertEqual(f2.to_pairs(),
((0, (('a', 0), ('b', 0), ('c', 20), ('d', 0))),
(1, (('a', 0), ('b', 0), ('c', 22), ('d', 0))),
(2, (('a', 0), ('b', 0), ('c', 24), ('d', 0))),
(3, (('a', 0), ('b', 0), ('c', 26), ('d', 0))),
(4, (('a', 0), ('b', 0), ('c', 28), ('d', 0)))))
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_matmul_j(self) -> None:
f1 = Frame.from_dict(dict(a=(1, 2, 3), b=(5, 6, 7)),
index=tuple('xyz'),
name='foo')
a1 = np.array([[5], [0]])
with self.assertRaises(RuntimeError):
_ = matmul(a1, f1)
def test_matmul_f(self) -> None:
# lhs: array 1D, rhs: array 2D, Frame
f1 = Frame.from_items((('a', (1, 2, 3)), ('b', (3, 4, 5))),
index=('x', 'y', 'z'))
self.assertEqual(matmul([3, 4, 5], f1.values).tolist(), [26, 50])
self.assertEqual(
matmul([3, 4, 5], f1).to_pairs(), (('a', 26), ('b', 50)))