def test_index_levels_equals_a(self) -> None:
OD = OrderedDict
tree1 = OD([
(('I', 'I'), OD([('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))])),
(('II', 'II'), OD([('A', (1, )), ('B', (1, ))])),
])
levels1 = IndexLevel.from_tree(tree1)
tree2 = OD([
(('I', 'I'), OD([('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))])),
(('II', 'II'), OD([('A', (1, )), ('B', (1, ))])),
])
levels2 = IndexLevel.from_tree(tree2)
tree3 = OD([
(('I', 'I'), OD([('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))])),
(
('II', 'II'),
OD([
('A', (1, )),
('B', (0, )) # diff
])),
])
levels3 = IndexLevel.from_tree(tree3)
self.assertTrue(levels1.equals(levels1))
self.assertTrue(levels1.equals(levels2))
self.assertTrue(levels2.equals(levels1))
self.assertFalse(levels2.equals(levels3))
def test_index_level_depth_a(self) -> None:
levels1 = IndexLevel(Index(()), targets=None, depth_reference=3)
self.assertEqual(levels1.depth, 3)
levels1 = IndexLevel(Index(()), targets=None, depth_reference=1)
self.assertEqual(levels1.depth, 1)
levels1 = IndexLevel(Index((3, 4)), targets=None)
self.assertEqual(levels1.depth, 1)
def test_index_levels_equals_e(self) -> None:
tree1 = {
"I": {"A": (1, 2), "B": (1, 2, 3)},
"II": {"D": (1, 2, 3), "E": (1,)},
}
lvl1 = IndexLevel.from_tree(tree1)
tree2 = {
"I": {"A": (1, 2), "B": (1, 2, 3)},
"II": (1, 2, 3),
}
lvl2 = IndexLevel.from_tree(tree2)
self.assertFalse(lvl1.equals(lvl2))
def test_index_level_labels_at_depth_a(self) -> None:
OD = OrderedDict
tree = OD([
('I', OD([
('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))
])
),
('II', OD([
('A', (1,)), ('B', (1,))
])
),
('III', OD([
('A', (1, 2, 3)), ('B', (1,))
])
),
])
levels = IndexLevel.from_tree(tree)
self.assertEqual(tuple(levels.labels_at_depth(0)),
('I', 'I', 'I', 'I', 'I', 'I', 'I', 'II', 'II', 'III', 'III', 'III', 'III'))
self.assertEqual(tuple(levels.labels_at_depth(1)),
('A', 'A', 'B', 'B', 'B', 'C', 'C', 'A', 'B', 'A', 'A', 'A', 'B'))
self.assertEqual(tuple(levels.labels_at_depth(2)),
(1, 2, 1, 2, 3, 2, 3, 1, 1, 1, 2, 3, 1))
def test_index_level_label_widths_at_depth_a(self) -> None:
OD = OrderedDict
tree = OD([
('I', OD([
('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))
])
),
('II', OD([
('A', (1,)), ('B', (1,))
])
),
('III', OD([
('A', (1, 2, 3)), ('B', (1,))
])
),
])
levels = IndexLevel.from_tree(tree)
post0 = tuple(levels.label_widths_at_depth(0))
post1 = tuple(levels.label_widths_at_depth(1))
post2 = tuple(levels.label_widths_at_depth(2))
self.assertEqual(post0, (('I', 7), ('II', 2), ('III', 4)))
self.assertEqual(post1,
(('A', 2), ('B', 3), ('C', 2), ('A', 1), ('B', 1), ('A', 3), ('B', 1))
)
self.assertEqual(post2,
(((1, 1), (2, 1), (1, 1), (2, 1), (3, 1), (2, 1), (3, 1), (1, 1), (1, 1), (1, 1), (2, 1), (3, 1), (1, 1)))
)
def test_index_level_label_widths_at_depth_e(self) -> None:
tree = {
"I": {"A": (1, 2), "B": (1, 2, 3), "C": (2, 3)},
"II": {"D": (1, 2, 3), "E": (1,)},
}
lvl = IndexLevel.from_tree(tree)
widths = tuple(lvl.label_widths_at_depth(1))
self.assertEqual(widths, (('A', 2), ('B', 3), ('C', 2), ('D', 3), ('E', 1)))
def test_index_level_label_widths_at_depth_f(self) -> None:
tree = {
"I": {"A": (1, 2), "B": (1, 2, 3),},
"II": {"D": (1, 2, 3), "E": (1,)},
}
lvl = IndexLevel.from_tree(tree)
widths = tuple(lvl.label_widths_at_depth(0))
self.assertEqual(widths, (('I', 5), ('II', 4)))
def test_index_levels_equals_c(self) -> None:
OD = OrderedDict
tree1 = OD([
('I', OD([
('A', (1, 2)), ('B', (1, 2)),
])
),
('II', OD([
('A', (1, 2)),
])
),
])
levels1 = IndexLevel.from_tree(tree1)
tree2 = OD([
('I', OD([
('A', (1, 2)),
])
),
('II', OD([
('A', (1, 2)),
])
),
])
levels2 = IndexLevel.from_tree(tree2)
tree3 = OD([
('I', (1, 2)),
('II', (1, 2)),
])
levels3 = IndexLevel.from_tree(tree3)
self.assertFalse(levels1.equals(levels1.values, compare_class=True))
self.assertFalse(levels1.equals(levels1.values, compare_class=False))
# differing length
self.assertFalse(levels1.equals(levels2))
# differeing depth
self.assertFalse(levels2.equals(levels3))
def test_index_levels_with_tuple_a(self) -> None:
OD = OrderedDict
tree = OD([
(('I', 'I'), OD([('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))])),
(('II', 'II'), OD([('A', (1, )), ('B', (1, ))])),
])
levels = IndexLevel.from_tree(tree)
self.assertEqual(levels.depth, 3)
self.assertEqual(levels.loc_to_iloc((('II', 'II'), 'B', 1)), 8)
def test_index_level_leaf_loc_to_iloc_d(self) -> None:
OD = OrderedDict
tree = OD([
('I', OD([('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))])),
('II', OD([('A', (1, 2, 3)), ('B', (1, ))])),
])
levels = IndexLevel.from_tree(tree)
with self.assertRaises(KeyError):
levels.leaf_loc_to_iloc(('II', 'B', 1, 'a'))
def test_index_level_repr_a(self) -> None:
"""Small tree"""
tree = {
"I": {"A": (1, 2), "B": (1, 2, 3), "C": (2, 3)},
"II": {"D": (1, 2, 3), "E": (1,)},
}
lvl = IndexLevel.from_tree(tree)
msg = repr(lvl)
self.assertEqual(len(msg.split()), 52)
num_ellipsis = re.findall(r"\.\.\.", msg)
num_labels = re.findall(r"IndexLevel", msg)
self.assertEqual(len(num_ellipsis), 0)
self.assertEqual(len(num_labels), 8)
def test_index_level_iter_b(self) -> None:
OD = OrderedDict
tree = OD([
('I', OD([('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))])),
('II', OD([('A', (1, 2, 3)), ('B', (1, ))])),
])
levels = IndexLevel.from_tree(tree)
tuples = tuple(levels)
self.assertEqual(tuples,
(('I', 'A', 1), ('I', 'A', 2), ('I', 'B', 1),
('I', 'B', 2), ('I', 'B', 3), ('I', 'C', 2),
('I', 'C', 3), ('II', 'A', 1), ('II', 'A', 2),
('II', 'A', 3), ('II', 'B', 1)))
def test_index_level_iter_a(self) -> None:
OD = OrderedDict
tree = OD([
('I', OD([('A', (1, 2)), ('B', (1, 2, 3)), ('C', (2, 3))])),
('II', OD([('A', (1, 2, 3)), ('B', (1, ))])),
])
levels = IndexLevel.from_tree(tree)
post = list(levels.label_nodes_at_depth(0))
self.assertEqual(post, ['I', 'II'])
post = list(levels.label_nodes_at_depth(1))
self.assertEqual(post, ['A', 'B', 'C', 'A', 'B'])
post = list(levels.label_nodes_at_depth(2))
self.assertEqual(post, [1, 2, 1, 2, 3, 2, 3, 1, 2, 3, 1])
def test_index_level_traverse(self) -> None:
tree = {
"I": {"A": (1, 2), "B": (1, 2, 3), "C": (2, 3)},
"II": {"D": (1, 2, 3), "E": (1,)},
}
lvl = IndexLevel.from_tree(tree)
tree = lvl.traverse() # type: ignore
self.assertEqual(tuple(tree), ("I", "II"))
self.assertEqual(tuple(tree["I"]), ("A", "B", "C"))
self.assertEqual(tuple(tree["II"]), ("D", "E"))
self.assertTrue(tree["I"]["A"].equals(lvl.targets[0].targets[0].index)) # type: ignore
self.assertTrue(tree["I"]["B"].equals(lvl.targets[0].targets[1].index)) # type: ignore
self.assertTrue(tree["I"]["C"].equals(lvl.targets[0].targets[2].index)) # type: ignore
self.assertTrue(tree["II"]["D"].equals(lvl.targets[1].targets[0].index)) # type: ignore
self.assertTrue(tree["II"]["E"].equals(lvl.targets[1].targets[1].index)) # type: ignore
def test_index_level_from_tree_a(self) -> None:
OD = OrderedDict
tree = OD([
(0, OD([
(8, (1, 2)), (9, (1, 2, 3)), (10, (2, 3))
])
),
(1, OD([
(3, (1,)), (5, (1, 2))
])
),
])
levels = IndexLevel.from_tree(tree, index_constructors=IndexSecond)
dt = datetime.datetime
self.assertEqual(levels.to_type_blocks().values.tolist(),
[[dt(1970, 1, 1, 0, 0), dt(1970, 1, 1, 0, 0, 8), dt(1970, 1, 1, 0, 0, 1)], [dt(1970, 1, 1, 0, 0), dt(1970, 1, 1, 0, 0, 8), dt(1970, 1, 1, 0, 0, 2)], [dt(1970, 1, 1, 0, 0), dt(1970, 1, 1, 0, 0, 9), dt(1970, 1, 1, 0, 0, 1)], [dt(1970, 1, 1, 0, 0), dt(1970, 1, 1, 0, 0, 9), dt(1970, 1, 1, 0, 0, 2)], [dt(1970, 1, 1, 0, 0), dt(1970, 1, 1, 0, 0, 9), dt(1970, 1, 1, 0, 0, 3)], [dt(1970, 1, 1, 0, 0), dt(1970, 1, 1, 0, 0, 10), dt(1970, 1, 1, 0, 0, 2)], [dt(1970, 1, 1, 0, 0), dt(1970, 1, 1, 0, 0, 10), dt(1970, 1, 1, 0, 0, 3)], [dt(1970, 1, 1, 0, 0, 1), dt(1970, 1, 1, 0, 0, 3), dt(1970, 1, 1, 0, 0, 1)], [dt(1970, 1, 1, 0, 0, 1), dt(1970, 1, 1, 0, 0, 5), dt(1970, 1, 1, 0, 0, 1)], [dt(1970, 1, 1, 0, 0, 1), dt(1970, 1, 1, 0, 0, 5), dt(1970, 1, 1, 0, 0, 2)]]
)
def test_index_level_depth_reference_a(self) -> None:
dtype = np.dtype
lvl1 = IndexLevel(Index(()), depth_reference=3)
self.assertEqual(lvl1.depth, 3)
self.assertEqual(tuple(lvl1.dtype_per_depth()),
(dtype('float64'), dtype('float64'), dtype('float64')))
self.assertEqual(tuple(lvl1.index_array_at_depth(0)), (EMPTY_ARRAY,))
self.assertEqual(lvl1.values_at_depth(0).tolist(), EMPTY_ARRAY.tolist())
tb = lvl1.to_type_blocks()
self.assertEqual(tb.shape, (0, 3))
def test_index_level_from_depth_a(self) -> None:
lvl1 = IndexLevel.from_depth(4)
self.assertEqual(lvl1.depth, 4)
self.assertEqual(len(lvl1), 0)
def test_index_level_contains_a(self) -> None:
level0 = IndexLevel(index=Index(('a', 'b')), targets=None)
self.assertFalse(('c',) in level0)
self.assertTrue(('a',) in level0)
def test_index_levels_to_type_blocks_c(self) -> None:
levels1 = IndexLevel(Index(()), targets=None, depth_reference=3)
tb = levels1.to_type_blocks()
self.assertEqual(tb.shape, (0, 3))
def test_index_levels_to_type_blocks_a(self) -> None:
levels1 = IndexLevel(Index(()), targets=None, depth_reference=3)
tb = levels1.to_type_blocks()
# NOTE: this will be updated to (0, 0) with IndexLevel support for zero size
self.assertEqual(tb.shape, (0, 3))
def test_index_level_leaf_loc_to_iloc_b(self) -> None:
level0 = IndexLevel(index=Index(('a', 'b')), targets=None)
self.assertEqual(level0.leaf_loc_to_iloc(('b',)), 1)
self.assertEqual(level0.leaf_loc_to_iloc(ILoc[1]), 1)
def test_index_level_leaf_loc_to_iloc_a(self):
groups = Index(('A', 'B', 'C'))
dates = IndexDate.from_date_range('2018-01-01', '2018-01-04')
observations = Index(('x', 'y'))
lvl2a = IndexLevel(index=observations)
lvl2b = IndexLevel(index=observations, offset=2)
lvl2c = IndexLevel(index=observations, offset=4)
lvl2d = IndexLevel(index=observations, offset=6)
lvl2_targets = ArrayGO((lvl2a, lvl2b, lvl2c, lvl2d))
lvl1a = IndexLevel(index=dates,
targets=lvl2_targets, offset=0)
lvl1b = IndexLevel(index=dates,
targets=lvl2_targets, offset=len(lvl1a))
lvl1c = IndexLevel(index=dates,
targets=lvl2_targets, offset=len(lvl1a) * 2)
# we need as many targets as len(index)
lvl0 = IndexLevel(index=groups,
targets=ArrayGO((lvl1a, lvl1b, lvl1c)))
self.assertEqual(lvl0.leaf_loc_to_iloc(('B', '2018-01-04', 'y'),), 15)
self.assertEqual(lvl0.leaf_loc_to_iloc(('A', '2018-01-01', 'y')), 1)
def test_index_level_dtypes_at_depth_a(self) -> None:
levels1 = IndexLevel(Index(()), targets=None, depth_reference=3)
with self.assertRaises(RuntimeError):
_ = tuple(levels1.dtypes_at_depth(10))
def test_index_level_b(self) -> None:
with self.assertRaises(ErrorInitIndexLevel):
_ = IndexLevel(('A', 'B')) #type: ignore
def test_index_level_leaf_loc_to_iloc_c(self) -> None:
groups = Index(('A', 'B', 'C'))
dates = IndexDate.from_date_range('2018-01-01', '2018-01-04')
observations = Index(('x', 'y'))
lvl2a = IndexLevel(index=observations)
lvl2b = IndexLevel(index=observations, offset=2)
lvl2c = IndexLevel(index=observations, offset=4)
lvl2d = IndexLevel(index=observations, offset=6)
lvl2_targets = ArrayGO((lvl2a, lvl2b, lvl2c, lvl2d))
lvl1a = IndexLevel(index=dates,
targets=lvl2_targets, offset=0)
lvl1b = IndexLevel(index=dates,
targets=lvl2_targets, offset=len(lvl1a))
lvl1c = IndexLevel(index=dates,
targets=lvl2_targets, offset=len(lvl1a) * 2)
lvl0 = IndexLevel(index=groups,
targets=ArrayGO((lvl1a, lvl1b, lvl1c)))
with self.assertRaises(KeyError):
lvl0.leaf_loc_to_iloc(('A'))
self.assertEqual(lvl0.leaf_loc_to_iloc(('A', '2018-01-01', 'y')), 1)
def test_index_level_loc_to_iloc_b(self) -> None:
level0 = IndexLevel(index=Index(('a', 'b')), targets=None)
with self.assertRaises(KeyError):
level0.loc_to_iloc(HLoc['c',])
def test_index_level_dtypes_c(self) -> None:
level0 = IndexLevel(index=Index(('a', 'b')), targets=None)
post = tuple(level0.dtype_per_depth())
self.assertEqual(post[0], np.dtype('<U1'))
self.assertEqual(len(post), 1)
def test_index_level_dtypes_all_a(self) -> None:
level0 = IndexLevel(index=Index(('a', 'b')), targets=None)
post = tuple(level0.dtypes_iter())
self.assertEqual(post[0], np.dtype('<U1'))
self.assertEqual(len(post), 1)
self.assertEqual(level0.depth, next(level0.depths()))
def test_hierarchy_loc_to_iloc_a(self):
groups = Index(('A', 'B', 'C'))
dates = IndexDate.from_date_range('2018-01-01', '2018-01-04')
observations = Index(('x', 'y'))
lvl2a = IndexLevel(index=observations)
lvl2b = IndexLevel(index=observations, offset=2)
lvl2c = IndexLevel(index=observations, offset=4)
lvl2d = IndexLevel(index=observations, offset=6)
lvl2_targets = ArrayGO((lvl2a, lvl2b, lvl2c, lvl2d))
lvl1a = IndexLevel(index=dates, targets=lvl2_targets, offset=0)
lvl1b = IndexLevel(index=dates,
targets=lvl2_targets,
offset=len(lvl1a))
lvl1c = IndexLevel(index=dates,
targets=lvl2_targets,
offset=len(lvl1a) * 2)
# we need as many targets as len(index)
lvl0 = IndexLevel(index=groups, targets=ArrayGO((lvl1a, lvl1b, lvl1c)))
self.assertEqual(len(lvl2a), 2)
self.assertEqual(len(lvl1a), 8)
self.assertEqual(len(lvl0), 24)
self.assertEqual(list(lvl2a.depths()), [1])
self.assertEqual(list(lvl1a.depths()), [2, 2, 2, 2])
self.assertEqual(list(lvl0.depths()),
[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3])
ih = IndexHierarchy(lvl0)
self.assertEqual(len(ih), 24)
post = ih.loc_to_iloc(HLoc[['A', 'B', 'C'],
slice('2018-01-01', '2018-01-04'),
['x', 'y']])
# this will break if we recognize this can be a slice
self.assertEqual(post, list(range(len(ih))))
post = ih.loc_to_iloc(HLoc[['A', 'B', 'C'],
slice('2018-01-01', '2018-01-04'), 'x'])
self.assertEqual(post, list(range(0, len(ih), 2)))
post = ih.loc_to_iloc(HLoc['C', '2018-01-03', 'y'])
self.assertEqual(post, 21)
post = ih.loc_to_iloc(HLoc['B', '2018-01-03':, 'y'])
self.assertEqual(post, [13, 15])
post = ih.loc_to_iloc(HLoc[['B', 'C'], '2018-01-03'])
self.assertEqual(post, [12, 13, 20, 21])
post = ih.loc_to_iloc(HLoc[['A', 'C'], :, 'y'])
self.assertEqual(post, [1, 3, 5, 7, 17, 19, 21, 23])
post = ih.loc_to_iloc(HLoc[['A', 'C'], :, 'x'])
self.assertEqual(post, [0, 2, 4, 6, 16, 18, 20, 22])
def test_index_levels_equals_d(self) -> None:
levels1 = IndexLevel(Index(('a', 'b', 'c')), targets=None)
levels2 = IndexLevel(Index(('a', 'b', 'c')), targets=None)
self.assertTrue(levels1.equals(levels2))
