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