def test_index_intersection_a(self):
idx1 = Index(('a', 'b', 'c', 'd', 'e'))
a1 = np.array(['c', 'dd', 'b', 'a'])
idx2 = idx1.intersection(a1)
self.assertEqual(idx2.values.tolist(), ['a', 'b', 'c'])
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)
lvl = hidx._levels
self.assertEqual([it.__name__ for it in lvl.index_types()],
['Index', 'IndexDate', 'Index'])
self.assertEqual(lvl.depth, next(lvl.depths()))
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_difference_c(self) -> None:
obj = object()
idx1 = Index((1, None, '3', np.nan, 4.4, obj))
idx2 = Index((2, 3, '4', 'five', 6.6, object()))
idx3 = idx1.difference(idx2)
self.assertEqual(set(idx3.values.tolist()),
set([np.nan, 1, 4.4, obj, '3',
None])) # Note: order is lost...
def test_hierarchy_series_a(self) -> None:
f1 = IndexHierarchy.from_tree
s1 = Series(23, index=f1(dict(a=(1, 2, 3))))
self.assertEqual(s1.values.tolist(), [23, 23, 23])
f2 = IndexHierarchy.from_product
s2 = Series(3, index=f2(Index(('a', 'b')), Index((1, 2))))
self.assertEqual(s2.to_pairs(), ((('a', 1), 3), (('a', 2), 3),
(('b', 1), 3), (('b', 2), 3)))
def test_index_roll_a(self) -> None:
idx = Index(('a', 'b', 'c', 'd'))
self.assertEqual(idx.roll(-2).values.tolist(),
['c', 'd', 'a', 'b'])
self.assertEqual(idx.roll(1).values.tolist(),
['d', 'a', 'b', 'c'])
def test_index_hierarchy_index_types_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.__name__)
for x, y in hidx.index_types.to_pairs()],
[('a', 'Index'), ('b', 'IndexDate'), ('c', 'Index')])
def test_index_name_a(self) -> None:
idx1 = Index(('a', 'b', 'c', 'd'), name='foo')
self.assertEqual(idx1.name, 'foo')
self.assertEqual(idx1.names, ('foo',))
idx2 = idx1.rename('bar')
self.assertEqual(idx2.name, 'bar')
self.assertEqual(idx2.names, ('bar',))
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_difference_d(self) -> None:
obj = object()
idx1 = Index((1, None, '3', np.nan, 4.4, obj)) # type: ignore
idx2 = Index((2, 1, '3', 'five', object()))
idx3 = idx1.difference(idx2)
self.assertEqual(set(idx3.values.tolist()),
set([np.nan, None, 4.4,
obj])) # Note: order is lost...
def test_index_intersection_b(self) -> None:
idx1 = Index(('c', 'b', 'a'))
idx2 = Index(('c', 'b', 'a'))
idx3 = idx1.intersection(idx2)
self.assertEqual(idx3.values.tolist(),
['c', 'b', 'a']
)
def test_index_sort_a(self) -> None:
index = Index(('a', 'c', 'd', 'e', 'b'))
self.assertEqual(
[index.sort().loc_to_iloc(x) for x in sorted(index.values)],
[0, 1, 2, 3, 4])
self.assertEqual(
[index.sort(ascending=False).loc_to_iloc(x) for x in sorted(index.values)],
[4, 3, 2, 1, 0])
def test_index_display(self, index: Index) -> None:
d1 = index.display()
self.assertTrue(len(d1) > 0)
d2 = index.display_tall()
self.assertTrue(len(d2) > 0)
d3 = index.display_wide()
self.assertTrue(len(d3) > 0)
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_index_correspondence_a(self):
idx0 = Index([0, 1, 2, 3, 4], loc_is_iloc=True)
idx1 = Index(
[0, 1, 2, 3, 4, '100185', '100828', '101376', '100312', '101092'],
dtype=object)
ic = IndexCorrespondence.from_correspondence(idx0, idx1)
self.assertFalse(ic.is_subset)
self.assertTrue(ic.has_common)
# this is an array, due to loc_is_iloc being True
self.assertEqual(ic.iloc_src.tolist(), [0, 1, 2, 3, 4])
self.assertEqual(ic.iloc_dst, [0, 1, 2, 3, 4])
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_isin_b(self) -> None:
idx = Index(('a', 'b', 'c'))
self.assertEqual(
idx.isin(('b','c')).tolist(),
[False, True, True]
)
self.assertEqual(
idx.isin(('b', 'c', 'b', 'c')).tolist(),
[False, True, True]
)
def test_index_intersection_c(self) -> None:
idx1 = Index((10, 20))
with self.assertRaises(RuntimeError):
# raises as it identifies labelled data
_ = idx1.intersection(Series([20, 30]))
idx2 = idx1.intersection(Series([20, 30]).values)
self.assertEqual(idx2.values.tolist(), [20])
idx3 = idx1.intersection([20, 30])
self.assertEqual(idx3.values.tolist(), [20])
def test_hierarchy_from_index_items_a(self) -> None:
idx1 = Index(('A', 'B', 'C'))
idx2 = Index(('x', 'y'))
idx3 = Index((4, 5, 6))
ih = IndexHierarchy.from_index_items(
dict(a=idx1, b=idx2, c=idx3).items())
self.assertEqual(ih.values.tolist(),
[['a', 'A'], ['a', 'B'], ['a', 'C'], ['b', 'x'],
['b', 'y'], ['c', 4], ['c', 5], ['c', 6]])
def test_index_drop_a(self) -> None:
index = Index(list('abcdefg'))
self.assertEqual(index._drop_loc('d').values.tolist(),
['a', 'b', 'c', 'e', 'f', 'g'])
self.assertEqual(index._drop_loc(['a', 'g']).values.tolist(),
['b', 'c', 'd', 'e', 'f'])
self.assertEqual(index._drop_loc(slice('b', None)).values.tolist(), # type: ignore
['a'])
def test_requires_reindex(self) -> None:
a = Index([1, 2, 3])
b = Index([1, 2, 3])
c = Index([1, 3, 2])
d = Index([1, 2, 3, 4])
e = Index(['a', 2, 3])
self.assertFalse(_requires_reindex(a, b))
self.assertTrue(_requires_reindex(a, c))
self.assertTrue(_requires_reindex(a, c))
self.assertTrue(_requires_reindex(a, d))
self.assertTrue(_requires_reindex(a, e))
def test_index_pickle_a(self) -> None:
a = Index([('a', 'b'), ('b', 'c'), ('c', 'd')])
b = Index([1, 2, 3, 4])
c = IndexYear.from_date_range('2014-12-15', '2018-03-15')
for index in (a, b, c):
pbytes = pickle.dumps(index)
index_new = pickle.loads(pbytes)
for v in index: # iter labels
# import ipdb; ipdb.set_trace()
# this compares Index objects
self.assertFalse(index_new._labels.flags.writeable)
self.assertEqual(index_new.loc[v], index.loc[v])
def test_index_iloc_map_a(self, index: Index) -> None:
# We can't handle NaNs
if any(map(isna_element, index.values)):
return
np.random.seed(0)
ilocs = np.arange(len(index)) # Need new array, will shuffle in-place
np.random.shuffle(ilocs)
other = tp.cast(Index, index.iloc[ilocs])
expected = index.iter_label().apply(other._loc_to_iloc)
post = index._index_iloc_map(other)
self.assertEqual(post.tolist(), expected.tolist())
def test_display_cell_align_left_a(self) -> None:
config_right = sf.DisplayConfig.from_default(cell_align_left=False,
type_color=False)
config_left = sf.DisplayConfig.from_default(cell_align_left=True,
type_color=False)
index = Index((x for x in 'abc'))
self.assertEqual(
index.display(config=config_left).to_rows(),
['<Index>', 'a', 'b', 'c', '<<U1>'])
self.assertEqual(
index.display(config=config_right).to_rows(),
['<Index>', ' a', ' b', ' c', ' <<U1>'])
def test_index_loc_to_iloc_boolen_a(self):
idx = Index(('a', 'b', 'c', 'd'))
# returns nothing as index does not match anything
post = idx.loc_to_iloc(Series([False, True, False, True]))
self.assertTrue(len(post) == 0)
post = idx.loc_to_iloc(
Series([False, True, False, True], index=('b', 'c', 'd', 'a')))
self.assertEqual(post.tolist(), [0, 2])
post = idx.loc_to_iloc(
Series([False, True, False, True], index=list('abcd')))
self.assertEqual(post.tolist(), [1, 3])
def test_index_equals_e(self) -> None:
a = Index([1, 2, 3])
b = Index([1, 2, 3])
c = Index([1, 3, 2])
d = Index([1, 2, 3, 4])
e = Index(['a', 2, 3])
self.assertFalse(not a.equals(b))
self.assertTrue(not a.equals(c))
self.assertTrue(not a.equals(c))
self.assertTrue(not a.equals(d))
self.assertTrue(not a.equals(e))
def test_index_reversed_b(self) -> None:
labels = tuple('acdeb')
index = Index(labels=labels)
index_reversed_generator = reversed(index)
self.assertEqual(tuple(index_reversed_generator),
tuple(reversed(labels)))
def test_index_attributes_a(self) -> None:
idx = Index(('a', 'b', 'c', 'd'))
self.assertEqual(idx.shape, (4, ))
self.assertEqual(idx.dtype.kind, 'U')
self.assertEqual(idx.ndim, 1)
self.assertEqual(idx.nbytes, 16)
def test_index_equals_c(self) -> None:
idx1 = IndexDate.from_year_range('2010', '2011')
idx2 = Index(idx1.values)
self.assertFalse(idx1.equals(idx2, compare_class=True))
self.assertTrue(idx1.equals(idx2, compare_class=False), )
def from_pandas(cls, value, *, 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
if is_go:
return IndexHierarchyGO.from_labels(value)
return IndexHierarchy.from_labels(value)
elif isinstance(value, pandas.DatetimeIndex):
if is_go:
raise NotImplementedError(
'No grow-only version of IndexDate yet exists')
return IndexDate(value)
if is_go:
return IndexGO(value)
return Index(value)
