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_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_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_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_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)]]
)
