def test_index_to_html_a(self) -> None:
idx1 = IndexGO(('a', 'b', 'c'))
self.assertEqual(
idx1.to_html(),
'<table border="1"><thead></thead><tbody><tr><td>a</td></tr><tr><td>b</td></tr><tr><td>c</td></tr></tbody></table>'
)
def test_index_to_series_a(self) -> None:
idx1 = IndexGO(('a', 'b', 'c', 'd'), name='foo')
s1 = idx1.to_series()
self.assertFalse(s1.values.flags.writeable)
self.assertEqual(s1.to_pairs(),
((0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')))
def test_index_copy_a(self) -> None:
idx1 = IndexGO(('a', 'b', 'c'))
idx1.append('d')
idx2 = idx1.copy()
idx2.append('e')
self.assertEqual(idx2.values.tolist(), ['a', 'b', 'c', 'd', 'e'])
self.assertEqual(idx1.values.tolist(), ['a', 'b', 'c', 'd'])
def from_pandas(cls,
value: 'pd.DataFrame',
*,
is_go: bool = False) -> 'IndexBase':
'''
Given a Pandas index, return the appropriate IndexBase derived class.
'''
import pandas
from static_frame import Index
from static_frame import IndexGO
from static_frame import IndexDate
from static_frame import IndexHierarchy
from static_frame import IndexHierarchyGO
if isinstance(value, pandas.MultiIndex):
# iterating over a hierarchucal index will iterate over labels
name = tuple(value.names)
if is_go:
return IndexHierarchyGO.from_labels(value, name=name)
return IndexHierarchy.from_labels(value, name=name)
elif isinstance(value, pandas.DatetimeIndex):
if is_go:
raise NotImplementedError(
'No grow-only version of IndexDate yet exists')
return IndexDate(value, name=value.name)
if is_go:
return IndexGO(value, name=value.name)
return Index(value, name=value.name)
def test_index_creation_a(self):
idx = Index(('a', 'b', 'c', 'd'))
#idx2 = idx['b':'d']
self.assertEqual(idx.values.tolist(), ['a', 'b', 'c', 'd'])
self.assertEqual(idx[2:].values.tolist(), ['c', 'd'])
self.assertEqual(idx.loc['b':].values.tolist(), ['b', 'c', 'd'])
self.assertEqual(idx.loc['b':'d'].values.tolist(), ['b', 'c', 'd'])
self.assertEqual(idx.loc_to_iloc(['b', 'b', 'c']), [1, 1, 2])
self.assertEqual(idx.loc['c'], 'c')
idxgo = IndexGO(('a', 'b', 'c', 'd'))
self.assertEqual(idxgo.values.tolist(), ['a', 'b', 'c', 'd'])
idxgo.append('e')
self.assertEqual(idxgo.values.tolist(), ['a', 'b', 'c', 'd', 'e'])
idxgo.extend(('f', 'g'))
self.assertEqual(idxgo.values.tolist(),
['a', 'b', 'c', 'd', 'e', 'f', 'g'])
def test_index_go_append(self, values):
index = IndexGO(values[:-1])
length_start = len(index)
index.append(values[-1])
length_end = len(index)
self.assertEqual(length_start + 1, length_end)
def test_index_level_append_b(self) -> None:
groups = IndexGO(('A', 'B'))
observations = IndexGO(('x', 'y'))
lvl2a = IndexLevelGO(index=observations)
lvl2b = IndexLevelGO(index=observations, offset=2)
lvl2_targets = ArrayGO((lvl2a, lvl2b))
lvl1a = IndexLevelGO(index=groups, targets=lvl2_targets, offset=0)
with self.assertRaises(RuntimeError):
lvl1a.append((1, 2, 3))
lvl1a.append((1, 2))
self.assertEqual(
lvl1a.values.tolist(),
[['A', 'x'], ['A', 'y'], ['B', 'x'], ['B', 'y'], [1, 2]])
def test_index_go_append(self, values: tp.Sequence[tp.Hashable]) -> None:
index = IndexGO(values[:-1])
length_start = len(index)
index.append(values[-1])
length_end = len(index)
self.assertEqual(length_start + 1, length_end)
def test_index_cumprod_a(self) -> None:
idx1 = IndexGO(range(1, 11, 2))
# sum applies to the labels
self.assertEqual(idx1.sum(), 25)
self.assertEqual(idx1.cumprod().tolist(), [1, 3, 15, 105, 945])
def test_index_creation_a(self) -> None:
idx = Index(('a', 'b', 'c', 'd'))
#idx2 = idx['b':'d']
self.assertEqual(idx.values.tolist(), ['a', 'b', 'c', 'd'])
self.assertEqual(idx[2:].values.tolist(), ['c', 'd'])
self.assertEqual(
idx.loc['b':].values.tolist(),
['b', 'c', 'd'
]) # type: ignore # https://github.com/python/typeshed/pull/3024
self.assertEqual(
idx.loc['b':'d'].values.tolist(),
['b', 'c', 'd'
]) # type: ignore # https://github.com/python/typeshed/pull/3024
self.assertEqual(idx.loc_to_iloc(['b', 'b', 'c']), [1, 1, 2])
self.assertEqual(idx.loc['c'], 'c')
idxgo = IndexGO(('a', 'b', 'c', 'd'))
self.assertEqual(idxgo.values.tolist(), ['a', 'b', 'c', 'd'])
idxgo.append('e')
self.assertEqual(idxgo.values.tolist(), ['a', 'b', 'c', 'd', 'e'])
idxgo.extend(('f', 'g'))
self.assertEqual(idxgo.values.tolist(),
['a', 'b', 'c', 'd', 'e', 'f', 'g'])
def test_index_go_b(self) -> None:
index = IndexGO(('a', 'b', 'c'))
index.append('d')
self.assertEqual(len(index.__slots__), 8)
self.assertFalse(index.STATIC)
self.assertEqual(index._IMMUTABLE_CONSTRUCTOR, Index)
self.assertEqual(Index._MUTABLE_CONSTRUCTOR, IndexGO)
def test_index_extract_iloc_a(self) -> None:
idx = IndexGO(('a', 'b', 'c', 'd'))
idx.append('e')
post = idx._extract_iloc(slice(None))
self.assertEqual(
post.values.tolist(), #type: ignore
['a', 'b', 'c', 'd', 'e'])
def test_index_iter_label_a(self) -> None:
idx1 = IndexGO(('a', 'b', 'c', 'd'), name='foo')
self.assertEqual(list(idx1.iter_label(0)), ['a', 'b', 'c', 'd'])
post = idx1.iter_label(0).apply(lambda x: x.upper())
self.assertEqual(post.to_pairs(),
((0, 'A'), (1, 'B'), (2, 'C'), (3, 'D')))
def test_index_to_html_a(self):
idx1 = IndexGO(('a', 'b', 'c'))
self.assertEqual(
idx1.to_html(),
'<table border="1"><thead><tr><th><span style="color: #777777"><IndexGO></span></th></tr></thead><tbody><tr><td>a</td></tr><tr><td>b</td></tr><tr><td>c</td></tr></tbody></table>'
)
def test_index_via_str_b(self) -> None:
idx1 = IndexGO(('a', 'b', 'c', 'd', 'e'))
idx1.append('f')
idx1.append('g')
a1 = idx1.via_str.upper()
self.assertEqual(a1.tolist(), ['A', 'B', 'C', 'D', 'E', 'F', 'G'])
def test_index_fillna_b(self) -> None:
idx1 = Index(('a', 'b', 'c'))
idx2 = idx1.fillna('d')
self.assertEqual(id(idx1), id(idx2))
idx3 = IndexGO(('a', 'b', 'c'))
idx4 = idx3.fillna('d')
self.assertNotEqual(id(idx3), id(idx4))
def test_index_values_at_depth_b(self) -> None:
idx1 = IndexGO(('a', 'b', 'c', 'd', 'e'))
with self.assertRaises(RuntimeError):
idx1.values_at_depth([3, 4])
post = idx1.values_at_depth([0])
self.assertEqual(post.tolist(), ['a', 'b', 'c', 'd', 'e'])
def test_index_to_html_datatables_a(self) -> None:
idx1 = IndexGO(('a', 'b', 'c'))
sio = StringIO()
post = idx1.to_html_datatables(sio, show=False)
self.assertEqual(post, None)
self.assertTrue(len(sio.read()) > 1200)
def test_index_level_get_labels_a(self):
groups = IndexGO(('A', 'B'))
observations = IndexGO(('x', 'y'))
targets = ArrayGO(
(IndexLevelGO(index=observations), IndexLevelGO(observations, offset=2)))
level0 = IndexLevelGO(index=groups, targets=targets)
self.assertEqual(level0.get_labels().tolist(),
[['A', 'x'], ['A', 'y'], ['B', 'x'], ['B', 'y']])
self.assertEqual(level0.get_labels().dtype.kind, 'U')
groups = IndexGO((1, 2))
observations = IndexGO((10, 20))
targets = ArrayGO(
(IndexLevelGO(index=observations), IndexLevelGO(observations, offset=2)))
level1 = IndexLevelGO(index=groups, targets=targets)
self.assertEqual(level1.get_labels().dtype.kind, 'i')
def test_index_unique(self) -> None:
with self.assertRaises(ErrorInitIndex):
idx = Index(('a', 'b', 'c', 'a'))
with self.assertRaises(ErrorInitIndex):
idx = IndexGO(('a', 'b', 'c', 'a'))
with self.assertRaises(ErrorInitIndex):
idx = Index(['a', 'a'])
with self.assertRaises(ErrorInitIndex):
idx = IndexGO(['a', 'a'])
with self.assertRaises(ErrorInitIndex):
idx = Index(np.array([True, False, True], dtype=bool))
with self.assertRaises(ErrorInitIndex):
idx = IndexGO(np.array([True, False, True], dtype=bool))
# acceptable but not advisiable
idx = Index([0, '0'])
def test_index_level_deepcopy_a(self) -> None:
groups = IndexGO(('A', 'B'))
observations = IndexGO(('x', 'y'))
lvl2a = IndexLevelGO(index=observations)
lvl2b = IndexLevelGO(index=observations, offset=2)
lvl2_targets = ArrayGO((lvl2a, lvl2b))
assert id(lvl2a.index) != id(lvl2b.index)
lvl1a = IndexLevelGO(index=groups,
targets=lvl2_targets,
offset=0)
post = copy.deepcopy(lvl1a)
self.assertEqual(lvl1a.values.tolist(), post.values.tolist())
self.assertEqual(
id(post.targets[0].index._labels), #type: ignore
id(post.targets[1].index._labels)) #type: ignore
def test_index_level_extend_d(self) -> None:
tree = {
"I": {"A": (1, 2), "B": (1, 2, 3), "C": (2, 3)},
"II": {"D": (1, 2, 3), "E": (1,)},
}
lvl0 = IndexLevelGO.from_tree(tree)
lvl1 = IndexLevelGO(index=IndexGO(()), targets=None, depth_reference=3)
# RuntimeError: found IndexLevel with None as targets
with self.assertRaises(RuntimeError):
lvl1.extend(lvl0)
def test_index_union_a(self) -> None:
idx1 = IndexGO(('a', 'b', 'c', 'd', 'e'))
idx1.append('f')
a1 = np.array(['c', 'dd', 'b', 'a'])
idx2 = idx1.union(a1)
self.assertEqual(idx2.values.tolist(),
['a', 'b', 'c', 'd', 'dd', 'e', 'f'])
def test_index_from_optional_constructor_a(self) -> None:
idx1 = index_from_optional_constructor([1, 3, 4],
default_constructor=Index)
self.assertEqual(idx1.__class__, Index)
# given a mutable index and an immutable default, get immutable version
idx2 = index_from_optional_constructor(IndexGO((1, 3, 4)),
default_constructor=Index)
self.assertEqual(idx2.__class__, Index)
# given a mutable index and an immutable default, get immutable version
idx3 = index_from_optional_constructor(IndexGO((1, 3, 4)),
default_constructor=IndexGO)
self.assertEqual(idx3.__class__, IndexGO)
# given a mutable index and an immutable default, get immutable version
idx4 = index_from_optional_constructor(IndexSecond((1, 3, 4)),
default_constructor=Index)
self.assertEqual(idx4.__class__, IndexSecond)
def test_index_equals_a(self) -> None:
idx1 = IndexGO(('a', 'b', 'c', 'd', 'e'))
idx2 = Index(('a', 'b', 'c', 'd', 'e'))
idx3 = IndexGO(('a', 'b', 'c', 'd', 'e'), name='foo')
idx4 = IndexGO(('a', 'b', 'c', 'd', 'e'))
idx5 = IndexGO(('a', 'b', 'c', 'd'))
self.assertEqual(idx1.equals(3), False)
self.assertEqual(idx1.equals(False), False)
self.assertEqual(idx1.equals([3, 4, 5]), False)
self.assertEqual(idx1.equals(idx2, compare_class=True), False)
self.assertEqual(idx1.equals(idx2, compare_class=False), True)
self.assertEqual(idx1.equals(idx3, compare_name=True), False)
self.assertEqual(idx1.equals(idx3, compare_name=False), True)
self.assertEqual(idx1.equals(idx5), False)
self.assertEqual(idx1.equals(idx1), True)
self.assertEqual(idx1.equals(idx4), True)
def test_index_name_c(self) -> None:
idx1 = IndexGO(('a', 'b', 'c', 'd'), name='foo')
self.assertEqual(idx1.name, 'foo')
idx2 = idx1.rename('bar')
self.assertEqual(idx2.name, 'bar')
idx1.append('e')
idx2.append('x')
self.assertEqual(idx1.values.tolist(), ['a', 'b', 'c', 'd', 'e'])
self.assertEqual(idx2.values.tolist(), ['a', 'b', 'c', 'd', 'x'])
def test_index_level_append_c(self) -> None:
levels1 = IndexLevelGO(IndexGO(()), depth_reference=3)
levels1.append(('III', 'A', 1))
self.assertEqual(len(tuple(levels1.dtypes_at_depth(0))), 1)
self.assertEqual(len(tuple(levels1.dtypes_at_depth(1))), 1)
self.assertEqual(len(tuple(levels1.dtypes_at_depth(2))), 1)
self.assertEqual(levels1.values.tolist(), [['III', 'A', 1]])
levels1.append(('III', 'A', 2))
self.assertEqual(levels1.values.tolist(),
[['III', 'A', 1], ['III', 'A', 2]])
def test_index_level_a(self):
groups = IndexGO(('A', 'B'))
observations = IndexGO(('x', 'y'))
targets = np.array(
(IndexLevelGO(index=observations), IndexLevelGO(observations, offset=2)))
level0 = IndexLevelGO(index=groups, targets=ArrayGO(targets))
level1 = level0.to_index_level()
groups = IndexGO(('C', 'D'))
observations = IndexGO(('x', 'y', 'z'))
targets = np.array(
(IndexLevelGO(index=observations), IndexLevelGO(observations, offset=3)))
level2 = IndexLevelGO(index=groups, targets=ArrayGO(targets))
level0.extend(level2)
self.assertEqual(len(level0.get_labels()), 10)
self.assertEqual(len(level1.get_labels()), 4)
self.assertEqual(len(level2.get_labels()), 6)
# import ipdb; ipdb.set_trace()
self.assertEqual([lvl.offset for lvl in level0.targets], [0, 2, 4, 7])
def test_index_go_e(self) -> None:
index = IndexGO((), loc_is_iloc=True)
index.append(0)
self.assertTrue(index._map is None)
index.append(1)
self.assertTrue(1 in index)
self.assertFalse('a' in index)
self.assertTrue(index._map is None)
index.append(-1)
self.assertFalse(index._map is None)
self.assertTrue(-1 in index)
self.assertTrue(1 in index)
def from_pandas(
cls,
value: 'pandas.Index',
) -> 'IndexBase':
'''
Given a Pandas index, return the appropriate IndexBase derived class.
'''
import pandas
if not isinstance(value, pandas.Index):
raise ErrorInitIndex(
f'from_pandas must be called with a Pandas Index object, not: {type(value)}'
)
from static_frame import Index
from static_frame import IndexGO
from static_frame import IndexHierarchy
from static_frame import IndexHierarchyGO
from static_frame import IndexNanosecond
from static_frame import IndexNanosecondGO
from static_frame.core.index_datetime import IndexDatetime
if isinstance(value, pandas.MultiIndex):
# iterating over a hierarchical index will iterate over labels
name: tp.Optional[tp.Tuple[tp.Hashable, ...]] = tuple(value.names)
# if not assigned Pandas returns None for all components, which will raise issue if trying to unset this index.
if all(n is None for n in name): #type: ignore
name = None
depth = value.nlevels
if not cls.STATIC:
return IndexHierarchyGO.from_labels(value,
name=name,
depth_reference=depth)
return IndexHierarchy.from_labels(value,
name=name,
depth_reference=depth)
elif isinstance(value, pandas.DatetimeIndex):
# if IndexDatetime, use cls, else use IndexNanosecond
if issubclass(cls, IndexDatetime):
return cls(value, name=value.name)
else:
if not cls.STATIC:
return IndexNanosecondGO(value, name=value.name)
return IndexNanosecond(value, name=value.name)
if not cls.STATIC:
return IndexGO(value, name=value.name)
return Index(value, name=value.name)