def test_index_levels_equals_b(self) -> None:
idx1 = Index(('a', 'b', 'c', 'd', 'e'))
idx2 = Index(range(10))
levels1 = IndexHierarchy.from_product(idx1, idx2)._levels
idx3 = Index(('a', 'b', 'c', 'd', 'e'))
idx4 = Index(range(10))
levels2 = IndexHierarchy.from_product(idx3, idx4)._levels
self.assertTrue(levels1.equals(levels2))
def test_index_hierarchy_pickle_a(self) -> None:
a = IndexHierarchy.from_product((10, 20), (3, 7))
b = IndexHierarchy.from_product(('a', 'b'), ('x', 'y'))
for index in (a, b):
# force creating of ._labels
self.assertTrue(len(index.values), len(index))
pbytes = pickle.dumps(index)
index_new = pickle.loads(pbytes)
for v in index: # iter labels (arrays here)
self.assertFalse(index_new._labels.flags.writeable)
self.assertEqual(index_new.loc[tuple(v)], index.loc[tuple(v)])
def test_index_hierarchy_sort_a(self) -> None:
ih1 = IndexHierarchy.from_product((1, 2), (30, 70))
self.assertEqual(
ih1.sort(ascending=False).values.tolist(),
[[2, 70], [2, 30], [1, 70], [1, 30]])
def test_hierarchy_extract_a(self) -> None:
idx = IndexHierarchy.from_product(['A', 'B'], [1, 2])
self.assertEqual(idx.iloc[1], ('A', 2))
self.assertEqual(idx.loc[('B', 1)], ('B', 1))
self.assertEqual(idx[2], ('B', 1)) #pylint: disable=E1136
self.assertEqual(idx.loc[HLoc['B', 1]], ('B', 1))
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_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_index_level_index_types_a(self) -> None:
idx1 = Index(('A', 'B'))
idx2 = IndexDate.from_date_range('2019-01-05', '2019-01-08')
idx3 = Index((1, 2))
hidx = IndexHierarchy.from_product(idx1, idx2, idx3)
self.assertEqual([it.__name__ for it in hidx._levels.index_types()],
['Index', 'IndexDate', 'Index'])
def test_hierarchy_from_product_a(self):
groups = Index(('A', 'B', 'C'))
dates = IndexDate.from_date_range('2018-01-01', '2018-01-04')
observations = Index(('x', 'y'))
ih = IndexHierarchy.from_product(groups, dates, observations)
def test_hierarchy_extract_a(self):
idx = IndexHierarchy.from_product(['A', 'B'], [1, 2])
self.assertEqual(idx.iloc[1], ('A', 2))
self.assertEqual(idx.loc[('B', 1)], ('B', 1))
self.assertEqual(idx[2], ('B', 1))
self.assertEqual(idx.loc[HLoc['B', 1]], ('B', 1))
def test_hierarchy_name_a(self):
idx1 = IndexHierarchy.from_product(list('ab'), list('xy'), name='q')
self.assertEqual(idx1.name, 'q')
idx2 = idx1.rename('w')
self.assertEqual(idx2.name, 'w')
def test_build_key_indexers_from_key_a(self) -> None:
ih = IndexHierarchy.from_product(range(3), range(4, 7), tuple('ABC'))
hlmapA = ih._map
hlmapB = deepcopy(ih._map)
hlmapB.encoding_can_overflow = True
def check(
key: tuple, # type: ignore
expected: tp.List[tp.List[int]],
) -> None:
resultA = hlmapA.build_key_indexers(key, indices=ih._indices)
self.assertEqual(resultA.dtype, np.uint64)
self.assertListEqual(resultA.tolist(), expected)
resultB = hlmapB.build_key_indexers(key, indices=ih._indices)
self.assertEqual(resultB.dtype, object)
self.assertListEqual(resultB.tolist(), expected)
check((0, 5, 'A'), [0, 1, 0]) # type: ignore
check((0, 5, ['A']), [[0, 1, 0]])
check(([0, 1], 5, ['B']), [[0, 1, 1], [1, 1, 1]])
check(([0, 1], 5, 'A'), [[0, 1, 0], [1, 1, 0]])
check(
([0, 1], [4, 5, 6], 'C'),
[[0, 0, 2], [0, 1, 2], [0, 2, 2], [1, 0, 2], [1, 1, 2], [1, 2, 2]])
def test_index_hierarchy_dtypes_b(self) -> None:
idx1 = Index(('A', 'B'), name='a')
idx2 = IndexDate.from_date_range('2019-01-05', '2019-01-08', name='b')
idx3 = Index((1, 2), name='c')
hidx = IndexHierarchy.from_product(idx1, idx2, idx3)
self.assertEqual([(x, y.kind) for x, y in hidx.dtypes.to_pairs()],
[('a', 'U'), ('b', 'M'), ('c', 'i')])
def test_index_init_b(self) -> None:
idx1 = IndexHierarchy.from_product(['A', 'B'], [1, 2])
idx2 = Index(idx1)
self.assertEqual(idx2.values.tolist(), [('A', 1), ('A', 2), ('B', 1),
('B', 2)])
def test_hierarchy_to_pandas_a(self):
idx1 = IndexHierarchy.from_product(list('ab'), list('xy'), name='q')
pdidx = idx1.to_pandas()
# NOTE: pandas .values on a hierarchical index returns an array of tuples
self.assertEqual(idx1.values.tolist(),
[list(x) for x in pdidx.values.tolist()])
def test_index_hierarchy_isin_b(self) -> None:
ih1 = IndexHierarchy.from_product((1, 2), (30, 70), (2, 5))
with self.assertRaises(RuntimeError):
ih1.isin([3, 4, 5]) # type: ignore # not an iterable of iterables
post = ih1.isin(([3, 4], [2, 5, 1, 5]))
self.assertEqual(post.sum(), 0)
def test_hierarchy_name_a(self) -> None:
idx1 = IndexHierarchy.from_product(list('ab'), list('xy'), name='q')
self.assertEqual(idx1.name, 'q')
idx2 = idx1.rename('w')
self.assertEqual(idx2.name, 'w')
# will provide one for each level
self.assertEqual(idx2.names, ('w', '__index1__'))
def test_hierarchy_display_a(self):
idx1 = IndexHierarchy.from_product(list('ab'), list('xy'), name='q')
match = tuple(idx1.display(DisplayConfig(type_color=False)))
self.assertEqual(match,
(['<IndexHierarchy: q>', ''], ['a', 'x'], ['a', 'y'],
['b', 'x'], ['b', 'y'], ['<<U1>', '<<U1>']))
def test_series_to_pandas_a(self):
s1 = Series(range(4),
index=IndexHierarchy.from_product(('a', 'b'), ('x', 'y')))
df = s1.to_pandas()
self.assertEqual(df.index.values.tolist(), [('a', 'x'), ('a', 'y'),
('b', 'x'), ('b', 'y')])
self.assertEqual(df.values.tolist(), [0, 1, 2, 3])
def test_hierarchy_cumprod_a(self):
ih1 = IndexHierarchy.from_product((10, 20), (3, 7))
# sum applies to the labels
self.assertEqual(ih1.sum().tolist(), [60, 20])
self.assertEqual(ih1.cumprod().tolist(),
[[10, 3], [100, 21], [2000, 63], [40000, 441]])
def test_index_hierarchy_roll_a(self) -> None:
ih1 = IndexHierarchy.from_product((1, 2), (30, 70))
with self.assertRaises(RuntimeError):
ih1.roll(1) # result in invalid tree form
self.assertEqual(
ih1.roll(2).values.tolist(), [[2, 30], [2, 70], [1, 30], [1, 70]])
def test_index_hierarchy_index_types_a(self) -> None:
idx1 = Index(('A', 'B'))
idx2 = IndexDate.from_date_range('2019-01-05', '2019-01-08')
idx3 = Index((1, 2))
hidx = IndexHierarchy.from_product(idx1, idx2, idx3)
self.assertEqual([(x, y.__name__)
for x, y in hidx.index_types.to_pairs()],
[(0, 'Index'), (1, 'IndexDate'), (2, 'Index')])
def test_index_level_dtypes_b(self) -> None:
idx1 = Index(('A', 'B'))
idx2 = IndexDate.from_date_range('2019-01-05', '2019-01-08')
idx3 = Index((1, 2))
hidx = IndexHierarchy.from_product(idx1, idx2, idx3)
self.assertEqual([dt.kind for dt in hidx._levels.dtype_per_depth()],
['U', 'M', 'i'],
)
def test_hierarchy_to_html_datatables(self) -> None:
ih1 = IndexHierarchy.from_product(list('ab'), list('xy'), name='q')
with temp_file('.html', path=True) as fp:
ih1.to_html_datatables(fp, show=False)
with open(fp) as file:
data = file.read()
self.assertTrue('SFTable' in data)
self.assertTrue(len(data) > 1000)
def test_index_level_repr_b(self) -> None:
"""Very deep tree"""
index = IndexHierarchy.from_product(*(range(i, i+2) for i in range(0, 20, 2)))
msg = repr(index._levels)
self.assertEqual(len(msg.split()), 67)
num_ellipsis = re.findall(r"\.\.\.", msg)
num_labels = re.findall(r"IndexLevel", msg)
self.assertEqual(len(num_ellipsis), 8)
self.assertEqual(len(num_labels), 15)
def test_series_reindex_b(self):
s1 = Series(range(4),
index=IndexHierarchy.from_product(('a', 'b'), ('x', 'y')))
s2 = Series(range(4),
index=IndexHierarchy.from_product(('b', 'c'), ('x', 'y')))
s3 = s1.reindex(s2.index, fill_value=None)
self.assertEqual(s3.to_pairs(),
((('b', 'x'), 2), (('b', 'y'), 3), (('c', 'x'), None),
(('c', 'y'), None)))
# can reindex with a different dimensionality if no matches
self.assertEqual(
s1.reindex((3, 4, 5, 6), fill_value=None).to_pairs(),
((3, None), (4, None), (5, None), (6, None)))
self.assertEqual(
s1.reindex((('b', 'x'), 4, 5, ('a', 'y')),
fill_value=None).to_pairs(),
((('b', 'x'), 2), (4, None), (5, None), (('a', 'y'), 1)))
def test_hierarchy_from_pandas_b(self):
import pandas
idx = IndexHierarchy.from_product(('I', 'II'), ('A', 'B'), (1, 2))
self.assertEqual(list(idx.iter_label(0)), ['I', 'II'])
self.assertEqual(list(idx.iter_label(1)), ['A', 'B', 'A', 'B'])
self.assertEqual(list(idx.iter_label(2)), [1, 2, 1, 2, 1, 2, 1, 2])
post = idx.iter_label(1).apply(lambda x: x.lower())
self.assertEqual(post.to_pairs(),
((0, 'a'), (1, 'b'), (2, 'a'), (3, 'b')))
def test_index_level_repr_c(self) -> None:
"""Very wide tree"""
index = IndexHierarchy.from_product(range(10), range(10, 20))
msg = repr(index._levels)
self.assertEqual(len(msg.split()), 70)
num_ellipsis = re.findall(r"\.\.\.", msg)
num_labels = re.findall(r"IndexLevel", msg)
self.assertEqual(len(num_ellipsis), 1)
self.assertEqual(len(num_labels), 5)
def test_index_hierarchy_isin_c(self) -> None:
ih1 = IndexHierarchy.from_product((1, 2), ('a', 'b'), (2, 5))
# multiple matches
post1 = ih1.isin([(1, 'a', 5), (2, 'b', 2)])
self.assertEqual(
post1.tolist(),
[False, True, False, False, False, False, True, False])
post2 = ih1.isin(ih1.keys())
self.assertEqual(post2.sum(), len(ih1))
def test_hierarchy_rehierarch_a(self) -> None:
ih1 = IndexHierarchy.from_product(('I', 'II'), ('B', 'A'), (2, 1))
ih2 = ih1.rehierarch((1, 0, 2))
self.assertEqual(
ih2.values.tolist(),
[['B', 'I', 2], ['B', 'I', 1], ['B', 'II', 2], ['B', 'II', 1],
['A', 'I', 2], ['A', 'I', 1], ['A', 'II', 2], ['A', 'II', 1]])
ih3 = ih1.rehierarch((2, 1, 0))
self.assertEqual(
ih3.values.tolist(),
[[2, 'B', 'I'], [2, 'B', 'II'], [2, 'A', 'I'], [2, 'A', 'II'],
[1, 'B', 'I'], [1, 'B', 'II'], [1, 'A', 'I'], [1, 'A', 'II']])
def test_index_hierarchy_isin_a(self) -> None:
ih1 = IndexHierarchy.from_product((1, 2), (30, 70), (2, 5))
post = ih1.isin([
(2, 30, 2),
])
self.assertEqual(post.dtype, bool)
self.assertEqual(
post.tolist(),
[False, False, False, False, True, False, False, False])
extract = ih1.loc[post]
self.assertEqual(extract.values.shape, (1, 3))