def test_index_date_h(self) -> None:
index = IndexDate.from_date_range('2017-12-15', '2018-02-15')
post = index.loc[
'2018':
'2018-01-15'] # type: ignore # https://github.com/python/typeshed/pull/3024
self.assertEqual(len(post), 15)
self.assertEqual(post[0], np.datetime64('2018-01-01')) #type: ignore
self.assertEqual(post[-1], np.datetime64('2018-01-15')) #type: ignore
def test_index_datetime_init_a(self) -> None:
dates = [
datetime.date(*x) for x in product((2017, ), (
4,
5,
), range(1, 4))
]
s1 = Series(range(len(dates)), index=IndexDate(dates))
with self.assertRaises(ErrorInitIndex):
index = IndexYearMonth(s1.index)
with self.assertRaises(ErrorInitIndex):
index = IndexYear(s1.index) #type: ignore
# can reuse the map if going from dt64 index to normal index
# idx2 = Index(s1.index)
# self.assertTrue(id(idx2._map) == id(s1.index._map)) #type: ignore
idx3 = IndexDate(s1.index)
self.assertTrue(id(idx3._map) == id(s1.index._map)) #type: ignore
with self.assertRaises(ErrorInitIndex):
index = IndexYear(idx3) #type: ignore
# from a date to a finer resolution has to create a new map
idx4 = IndexMinute(idx3)
self.assertTrue(id(idx4._map) != id(s1.index._map)) #type: ignore
# a GO has to create a new map
idx5 = IndexDateGO(s1.index)
self.assertTrue(id(idx4._map) != id(s1.index._map)) #type: ignore
# supplying a dtype to coerce the labels
with self.assertRaises(ErrorInitIndex):
idx6 = Index(s1.index, dtype='datetime64[Y]')
with self.assertRaises(ErrorInitIndex):
idx7 = Index(s1.index.values.astype('datetime64[Y]'))
# final resolution from a normal index
idx8 = IndexMinute(s1.index)
self.assertTrue(id(idx8._map) != id(s1.index._map)) #type: ignore
def test_index_date_n(self) -> None:
index = IndexDate.from_date_range('2017-11-15', '2018-02-15')
# NOTE: this type of selection should possibly not be permitted
post = index.loc[['2017-12', '2018-02']]
self.assertEqual(len(post), 46)
self.assertEqual(post[0], np.datetime64('2017-12-01'))
self.assertEqual(post[-1], np.datetime64('2018-02-15'))
self.assertEqual(set(post.values.astype('datetime64[M]')),
{np.datetime64('2018-02'),
np.datetime64('2017-12')})
def test_index_date_loc_to_iloc_a(self):
index = IndexDate.from_date_range('2018-01-01', '2018-03-01')
self.assertEqual(index.loc_to_iloc(np.datetime64('2018-02-11')), 41)
self.assertEqual(index.loc_to_iloc('2018-02-11'), 41)
self.assertEqual(index.loc_to_iloc(slice('2018-02-11', '2018-02-24')),
slice(41, 55, None))
def test_index_date_loc_to_iloc_b(self) -> None:
index = IndexDate.from_date_range('2018-01-01', '2018-03-01')
# with self.assertRaises(RuntimeError):
# _ = index.loc_to_iloc(['2017-12-01', '2018-01-01', '2018-02-01'])
post = index._loc_to_iloc(['2017-12-01', '2018-01-01', '2018-02-01'],
partial_selection=True)
self.assertEqual(post, [0, 31])
def test_index_datetime_loc(self) -> None:
idx1 = IndexDate(())
idx2 = idx1.iloc[[]]
self.assertEqual(idx2.__class__, IndexDate)
self.assertEqual(len(idx2), 0)
idx3 = idx1.loc[[]]
self.assertEqual(idx3.__class__, IndexDate)
self.assertEqual(len(idx3), 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_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_many_set_a(self) -> None:
idx0 = Index(('1997-01-01', '1997-01-02'), name='foo')
idx1 = IndexDate(('2020-01-01', '2020-01-02'), name='foo')
idx2 = IndexDate(('2020-01-02', '2020-01-03'))
post1 = index_many_set((idx0, idx1), Index, union=True)
assert isinstance(post1, Index)
self.assertEqual(post1.name, 'foo')
self.assertEqual(post1.__class__, Index)
# self.assertEqual(set(post1.values),
# {'1997-01-02',
# '1997-01-01',
# np.datetime64('2020-01-01'),
# np.datetime64('2020-01-02')})
# the result of this operation is an unstable ordering
values = set(post1.values)
self.assertTrue('1997-01-01' in values)
self.assertTrue('1997-01-02' in values)
self.assertTrue(datetime.date(2020, 1, 1) in values)
self.assertTrue(datetime.date(2020, 1, 2) in values)
post2 = index_many_set((idx1, idx2), Index, union=True)
assert isinstance(post2, Index)
self.assertEqual(post2.name, None)
self.assertEqual(post2.__class__, IndexDate)
self.assertEqual(post2.values.tolist(), [
datetime.date(2020, 1, 1),
datetime.date(2020, 1, 2),
datetime.date(2020, 1, 3)
])
post3 = index_many_set((idx1, idx2), Index, union=False)
assert isinstance(post3, Index)
self.assertEqual(post3.name, None)
self.assertEqual(post3.__class__, IndexDate)
self.assertEqual(post3.values.tolist(), [datetime.date(2020, 1, 2)])
def test_index_datetime_iloc_searchsorted_a(self) -> None:
dt64 = np.datetime64
idx = IndexDate.from_date_range('2020-01-01', '2020-01-31')
self.assertEqual(idx.iloc_searchsorted(dt64('2020-01-05')), 4)
self.assertEqual(
idx.iloc_searchsorted([dt64('2020-01-05'),
dt64('2020-01-31')]).tolist(), [4, 30])
self.assertEqual(
idx.iloc_searchsorted(
[dt64('2020-01-05'), dt64('2020-01-31')],
side_left=False).tolist(), [5, 31])
def test_index_many_concat_a1(self) -> None:
idx0 = Index(('1997-01-01', '1997-01-02'), name='foo')
idx1 = IndexDate(('2020-01-01', '2020-01-02'), name='foo')
idx2 = IndexDate(('2020-02-01', '2020-02-02'))
post1 = index_many_concat((idx0, idx1), Index)
assert isinstance(post1, Index)
post1b = index_many_concat((idx0, idx1), Index, IndexDate)
assert isinstance(post1b, IndexDate)
post1c = index_many_concat((idx0, idx1, idx2), Index, IndexDate)
assert isinstance(post1c, IndexDate)
self.assertEqual(post1.values.tolist(), [
'1997-01-01', '1997-01-02',
datetime.date(2020, 1, 1),
datetime.date(2020, 1, 2)
])
self.assertEqual(post1.name, 'foo')
self.assertEqual(post1.__class__, Index)
def test_index_date_series_a(self):
s = Series(range(62),
index=IndexDate.from_year_month_range('2017-12', '2018-01'))
self.assertEqual(s.sum(), 1891)
self.assertEqual(s.loc[s.index == '2018-01'].sum(), 1426)
self.assertEqual(s.loc[s.index == '2017-12'].sum(), 465)
self.assertEqual(s['2018-01-24'], 54)
self.assertEqual(s['2018-01-28':].to_pairs(),
((np.datetime64('2018-01-28'), 58),
(np.datetime64('2018-01-29'), 59),
(np.datetime64('2018-01-30'), 60),
(np.datetime64('2018-01-31'), 61)))
def test_frame_iter_array_f(self) -> None:
f = sf.Frame(np.arange(12).reshape(3,4),
index=IndexDate.from_date_range('2020-01-01', '2020-01-03'))
post = f.iter_array(axis=0).apply(np.sum, name='foo')
self.assertEqual(post.name, 'foo')
self.assertEqual(
f.iter_array(axis=0).apply(np.sum).to_pairs(),
((0, 12), (1, 15), (2, 18), (3, 21))
)
self.assertEqual(
f.iter_array(axis=1).apply(np.sum).to_pairs(),
((np.datetime64('2020-01-01'), 6), (np.datetime64('2020-01-02'), 22), (np.datetime64('2020-01-03'), 38))
)
def test_index_hierarchy_label_widths_at_depth(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(tuple(hidx.label_widths_at_depth(0)),
(('A', 8), ('B', 8)))
self.assertEqual(tuple(hidx.label_widths_at_depth(1)),
((np.datetime64('2019-01-05'), 2),
(np.datetime64('2019-01-06'), 2),
(np.datetime64('2019-01-07'), 0),
(np.datetime64('2019-01-08'), 2),
(np.datetime64('2019-01-05'), 2),
(np.datetime64('2019-01-06'), 2),
(np.datetime64('2019-01-07'), 0),
(np.datetime64('2019-01-08'), 2)))
self.assertEqual(tuple(hidx.label_widths_at_depth(2)),
((1, 1), (2, 1), (1, 1), (2, 1), (1, 1), (2, 1),
(1, 1), (2, 1), (1, 1), (2, 1), (1, 1), (2, 1),
(1, 1), (2, 1), (1, 1), (2, 1)))
