def helper_test_intersect(test_case, test_series: TimeSeries):
seriesA = TimeSeries.from_series(
pd.Series(range(2, 8), index=pd.date_range('20130102',
'20130107')))
seriesB = test_series.slice_intersect(seriesA)
test_case.assertEqual(seriesB.start_time(), pd.Timestamp('20130102'))
test_case.assertEqual(seriesB.end_time(), pd.Timestamp('20130107'))
# Outside of range
seriesD = test_series.slice_intersect(
TimeSeries.from_series(
pd.Series(range(6, 13),
index=pd.date_range('20130106', '20130112'))))
test_case.assertEqual(seriesD.start_time(), pd.Timestamp('20130106'))
test_case.assertEqual(seriesD.end_time(), pd.Timestamp('20130110'))
# Small intersect
seriesE = test_series.slice_intersect(
TimeSeries.from_series(
pd.Series(range(9, 13),
index=pd.date_range('20130109', '20130112'))))
test_case.assertEqual(len(seriesE), 2)
# No intersect
with test_case.assertRaises(ValueError):
test_series.slice_intersect(
TimeSeries(
pd.Series(range(6, 13),
index=pd.date_range('20130116', '20130122'))))
def test_eq(self):
seriesA: TimeSeries = TimeSeries.from_series(self.pd_series1)
self.assertTrue(self.series1 == seriesA)
self.assertFalse(self.series1 != seriesA)
# with different dates
seriesC = TimeSeries.from_series(
pd.Series(range(10), index=pd.date_range('20130102', '20130111')))
self.assertFalse(self.series1 == seriesC)
def test_resample_timeseries(self):
times = pd.date_range('20130101', '20130110')
pd_series = pd.Series(range(10), index=times)
timeseries = TimeSeries.from_series(pd_series)
resampled_timeseries = timeseries.resample('H')
self.assertEqual(resampled_timeseries.freq_str(), 'H')
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp(
'20130101020000')], 0)
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp(
'20130102020000')], 1)
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp(
'20130109090000')], 8)
resampled_timeseries = timeseries.resample('2D')
self.assertEqual(resampled_timeseries.freq_str(), '2D')
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp('20130101')], 0)
with self.assertRaises(KeyError):
resampled_timeseries.pd_series().at[pd.Timestamp('20130102')]
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp('20130109')], 8)
def ensemble(
self,
predictions: Union[TimeSeries, Sequence[TimeSeries]],
series: Optional[Sequence[TimeSeries]] = None,
) -> Union[TimeSeries, Sequence[TimeSeries]]:
if isinstance(predictions, Sequence):
return [
TimeSeries.from_series(
p.pd_dataframe(copy=False).sum(axis=1) / len(self.models),
static_covariates=p.static_covariates,
) for p in predictions
]
else:
return TimeSeries.from_series(
predictions.pd_dataframe(copy=False).sum(axis=1) /
len(self.models),
static_covariates=predictions.static_covariates,
)
def test_short_series_creation(self):
# test missing freq argument error
with self.assertRaises(ValueError):
TimeSeries.from_times_and_values(
pd.date_range('20130101', '20130102'), range(2))
# test empty pandas series error
with self.assertRaises(ValueError):
TimeSeries.from_series(pd.Series(), freq='D')
# test frequency mismatch case
seriesA = TimeSeries.from_times_and_values(pd.date_range(
'20130101', '20130105'),
range(5),
freq='M')
self.assertEqual(seriesA.freq(), 'D')
# test successful instantiation of TimeSeries with length 2
TimeSeries.from_times_and_values(pd.date_range('20130101', '20130102'),
range(2),
freq='D')
def test_fill_missing_dates(self):
with self.assertRaises(ValueError):
# Series cannot have date holes without automatic filling
range_ = pd.date_range('20130101', '20130104').append(
pd.date_range('20130106', '20130110'))
TimeSeries.from_series(pd.Series(range(9), index=range_),
fill_missing_dates=False)
with self.assertRaises(ValueError):
# Main series should have explicit frequency in case of date holes
range_ = pd.date_range('20130101', '20130104').append(
pd.date_range('20130106', '20130110', freq='2D'))
TimeSeries.from_series(pd.Series(range(7), index=range_))
range_ = pd.date_range('20130101', '20130104').append(
pd.date_range('20130106', '20130110'))
series_test = TimeSeries.from_series(pd.Series(range(9), index=range_))
self.assertEqual(series_test.freq_str(), 'D')
range_ = pd.date_range('20130101', '20130104', freq='2D') \
.append(pd.date_range('20130107', '20130111', freq='2D'))
series_test = TimeSeries.from_series(pd.Series(range(5), index=range_))
self.assertEqual(series_test.freq_str(), '2D')
self.assertEqual(series_test.start_time(), range_[0])
self.assertEqual(series_test.end_time(), range_[-1])
self.assertTrue(math.isnan(series_test.pd_series().get('20130105')))
def test_ops(self):
seriesA = TimeSeries.from_series(
pd.Series([2 for _ in range(10)], index=self.pd_series1.index))
targetAdd = TimeSeries.from_series(
pd.Series(range(2, 12), index=self.pd_series1.index))
targetSub = TimeSeries.from_series(
pd.Series(range(-2, 8), index=self.pd_series1.index))
targetMul = TimeSeries.from_series(
pd.Series(range(0, 20, 2), index=self.pd_series1.index))
targetDiv = TimeSeries.from_series(
pd.Series([i / 2 for i in range(10)], index=self.pd_series1.index))
targetPow = TimeSeries.from_series(
pd.Series([float(i**2) for i in range(10)],
index=self.pd_series1.index))
self.assertEqual(self.series1 + seriesA, targetAdd)
self.assertEqual(self.series1 + 2, targetAdd)
self.assertEqual(2 + self.series1, targetAdd)
self.assertEqual(self.series1 - seriesA, targetSub)
self.assertEqual(self.series1 - 2, targetSub)
self.assertEqual(self.series1 * seriesA, targetMul)
self.assertEqual(self.series1 * 2, targetMul)
self.assertEqual(2 * self.series1, targetMul)
self.assertEqual(self.series1 / seriesA, targetDiv)
self.assertEqual(self.series1 / 2, targetDiv)
self.assertEqual(self.series1**2, targetPow)
with self.assertRaises(ZeroDivisionError):
# Cannot divide by a TimeSeries with a value 0.
self.series1 / self.series1
with self.assertRaises(ZeroDivisionError):
# Cannot divide by 0.
self.series1 / 0
def test_creation(self):
with self.assertRaises(ValueError):
# Index is dateTimeIndex
TimeSeries.from_series(pd.Series(range(10), range(10)))
series_test = TimeSeries.from_series(self.pd_series1)
self.assertTrue(series_test.pd_series().equals(self.pd_series1))
class TimeSeriesTestCase(unittest.TestCase):
times = pd.date_range('20130101', '20130110')
pd_series1 = pd.Series(range(10), index=times)
pd_series2 = pd.Series(range(5, 15), index=times)
pd_series3 = pd.Series(range(15, 25), index=times)
series1: TimeSeries = TimeSeries.from_series(pd_series1)
series2: TimeSeries = TimeSeries.from_series(pd_series2)
series3: TimeSeries = TimeSeries.from_series(pd_series2)
@classmethod
def setUpClass(cls):
logging.disable(logging.CRITICAL)
def test_creation(self):
with self.assertRaises(ValueError):
# Index is dateTimeIndex
TimeSeries.from_series(pd.Series(range(10), range(10)))
series_test = TimeSeries.from_series(self.pd_series1)
self.assertTrue(series_test.pd_series().equals(self.pd_series1))
def test_alt_creation(self):
with self.assertRaises(ValueError):
# Series cannot be lower than three without passing frequency as argument to constructor
index = pd.date_range('20130101', '20130102')
TimeSeries.from_times_and_values(index, self.pd_series1.values[:2])
with self.assertRaises(ValueError):
# all arrays must have same length
TimeSeries.from_times_and_values(self.pd_series1.index,
self.pd_series1.values[:-1])
# test if reordering is correct
rand_perm = np.random.permutation(range(1, 11))
index = pd.to_datetime(['201301{:02d}'.format(i) for i in rand_perm])
series_test = TimeSeries.from_times_and_values(
index, self.pd_series1.values[rand_perm - 1])
self.assertTrue(series_test.start_time() == pd.to_datetime('20130101'))
self.assertTrue(series_test.end_time() == pd.to_datetime('20130110'))
self.assertTrue(series_test.pd_series().equals(self.pd_series1))
self.assertTrue(series_test.freq() == self.series1.freq())
# TODO test over to_dataframe when multiple features choice is decided
def test_eq(self):
seriesA: TimeSeries = TimeSeries.from_series(self.pd_series1)
self.assertTrue(self.series1 == seriesA)
self.assertFalse(self.series1 != seriesA)
# with different dates
seriesC = TimeSeries.from_series(
pd.Series(range(10), index=pd.date_range('20130102', '20130111')))
self.assertFalse(self.series1 == seriesC)
def test_dates(self):
self.assertEqual(self.series1.start_time(), pd.Timestamp('20130101'))
self.assertEqual(self.series1.end_time(), pd.Timestamp('20130110'))
self.assertEqual(self.series1.duration(), pd.Timedelta(days=9))
@staticmethod
def helper_test_slice(test_case, test_series: TimeSeries):
# base case
seriesA = test_series.slice(pd.Timestamp('20130104'),
pd.Timestamp('20130107'))
test_case.assertEqual(seriesA.start_time(), pd.Timestamp('20130104'))
test_case.assertEqual(seriesA.end_time(), pd.Timestamp('20130107'))
# time stamp not in series
seriesB = test_series.slice(pd.Timestamp('20130104 12:00:00'),
pd.Timestamp('20130107'))
test_case.assertEqual(seriesB.start_time(), pd.Timestamp('20130105'))
test_case.assertEqual(seriesB.end_time(), pd.Timestamp('20130107'))
# end timestamp after series
seriesC = test_series.slice(pd.Timestamp('20130108'),
pd.Timestamp('20130201'))
test_case.assertEqual(seriesC.start_time(), pd.Timestamp('20130108'))
test_case.assertEqual(seriesC.end_time(), pd.Timestamp('20130110'))
# n points, base case
seriesD = test_series.slice_n_points_after(pd.Timestamp('20130102'),
n=3)
test_case.assertEqual(seriesD.start_time(), pd.Timestamp('20130102'))
test_case.assertTrue(len(seriesD.values()) == 3)
test_case.assertEqual(seriesD.end_time(), pd.Timestamp('20130104'))
seriesE = test_series.slice_n_points_after(
pd.Timestamp('20130107 12:00:10'), n=10)
test_case.assertEqual(seriesE.start_time(), pd.Timestamp('20130108'))
test_case.assertEqual(seriesE.end_time(), pd.Timestamp('20130110'))
seriesF = test_series.slice_n_points_before(pd.Timestamp('20130105'),
n=3)
test_case.assertEqual(seriesF.end_time(), pd.Timestamp('20130105'))
test_case.assertTrue(len(seriesF.values()) == 3)
test_case.assertEqual(seriesF.start_time(), pd.Timestamp('20130103'))
seriesG = test_series.slice_n_points_before(
pd.Timestamp('20130107 12:00:10'), n=10)
test_case.assertEqual(seriesG.start_time(), pd.Timestamp('20130101'))
test_case.assertEqual(seriesG.end_time(), pd.Timestamp('20130107'))
@staticmethod
def helper_test_split(test_case, test_series: TimeSeries):
seriesA, seriesB = test_series.split_after(pd.Timestamp('20130104'))
test_case.assertEqual(seriesA.end_time(), pd.Timestamp('20130104'))
test_case.assertEqual(seriesB.start_time(), pd.Timestamp('20130105'))
seriesC, seriesD = test_series.split_before(pd.Timestamp('20130104'))
test_case.assertEqual(seriesC.end_time(), pd.Timestamp('20130103'))
test_case.assertEqual(seriesD.start_time(), pd.Timestamp('20130104'))
test_case.assertEqual(test_series.freq_str(), seriesA.freq_str())
test_case.assertEqual(test_series.freq_str(), seriesC.freq_str())
@staticmethod
def helper_test_drop(test_case, test_series: TimeSeries):
seriesA = test_series.drop_after(pd.Timestamp('20130105'))
test_case.assertEqual(seriesA.end_time(),
pd.Timestamp('20130105') - test_series.freq())
test_case.assertTrue(
np.all(seriesA.time_index() < pd.Timestamp('20130105')))
seriesB = test_series.drop_before(pd.Timestamp('20130105'))
test_case.assertEqual(seriesB.start_time(),
pd.Timestamp('20130105') + test_series.freq())
test_case.assertTrue(
np.all(seriesB.time_index() > pd.Timestamp('20130105')))
test_case.assertEqual(test_series.freq_str(), seriesA.freq_str())
test_case.assertEqual(test_series.freq_str(), seriesB.freq_str())
@staticmethod
def helper_test_intersect(test_case, test_series: TimeSeries):
seriesA = TimeSeries.from_series(
pd.Series(range(2, 8), index=pd.date_range('20130102',
'20130107')))
seriesB = test_series.slice_intersect(seriesA)
test_case.assertEqual(seriesB.start_time(), pd.Timestamp('20130102'))
test_case.assertEqual(seriesB.end_time(), pd.Timestamp('20130107'))
# Outside of range
seriesD = test_series.slice_intersect(
TimeSeries.from_series(
pd.Series(range(6, 13),
index=pd.date_range('20130106', '20130112'))))
test_case.assertEqual(seriesD.start_time(), pd.Timestamp('20130106'))
test_case.assertEqual(seriesD.end_time(), pd.Timestamp('20130110'))
# Small intersect
seriesE = test_series.slice_intersect(
TimeSeries.from_series(
pd.Series(range(9, 13),
index=pd.date_range('20130109', '20130112'))))
test_case.assertEqual(len(seriesE), 2)
# No intersect
with test_case.assertRaises(ValueError):
test_series.slice_intersect(
TimeSeries(
pd.Series(range(6, 13),
index=pd.date_range('20130116', '20130122'))))
def test_rescale(self):
with self.assertRaises(ValueError):
self.series1.rescale_with_value(1)
seriesA = self.series3.rescale_with_value(0)
self.assertTrue(np.all(seriesA.values() == 0))
seriesB = self.series3.rescale_with_value(-5)
self.assertTrue(self.series3 * -1. == seriesB)
seriesC = self.series3.rescale_with_value(1)
self.assertTrue(self.series3 * 0.2 == seriesC)
seriesD = self.series3.rescale_with_value(
1e+20
) # TODO: test will fail if value > 1e24 due to num imprecision
self.assertTrue(self.series3 * 0.2e+20 == seriesD)
@staticmethod
def helper_test_shift(test_case, test_series: TimeSeries):
seriesA = test_case.series1.shift(0)
test_case.assertTrue(seriesA == test_case.series1)
seriesB = test_series.shift(1)
test_case.assertTrue(seriesB.time_index().equals(
test_series.time_index()[1:].append(
pd.DatetimeIndex(
[test_series.time_index()[-1] + test_series.freq()]))))
seriesC = test_series.shift(-1)
test_case.assertTrue(seriesC.time_index().equals(
pd.DatetimeIndex([
test_series.time_index()[0] - test_series.freq()
]).append(test_series.time_index()[:-1])))
with test_case.assertRaises(OverflowError):
test_series.shift(1e+6)
seriesM = TimeSeries.from_times_and_values(
pd.date_range('20130101', '20130601', freq='m'), range(5))
with test_case.assertRaises(OverflowError):
seriesM.shift(1e+4)
seriesD = TimeSeries.from_times_and_values(pd.date_range(
'20130101', '20130101'),
range(1),
freq='D')
seriesE = seriesD.shift(1)
test_case.assertEqual(seriesE.time_index()[0],
pd.Timestamp('20130102'))
@staticmethod
def helper_test_append(test_case, test_series: TimeSeries):
# reconstruct series
seriesA, seriesB = test_series.split_after(pd.Timestamp('20130106'))
test_case.assertEqual(seriesA.append(seriesB), test_series)
test_case.assertEqual(
seriesA.append(seriesB).freq(), test_series.freq())
# Creating a gap is not allowed
seriesC = test_series.drop_before(pd.Timestamp('20130107'))
with test_case.assertRaises(ValueError):
seriesA.append(seriesC)
# Changing frequence is not allowed
seriesM = TimeSeries.from_times_and_values(
pd.date_range('20130107', '20130507', freq='30D'), range(5))
with test_case.assertRaises(ValueError):
seriesA.append(seriesM)
@staticmethod
def helper_test_append_values(test_case, test_series: TimeSeries):
# reconstruct series
seriesA, seriesB = test_series.split_after(pd.Timestamp('20130106'))
test_case.assertEqual(
seriesA.append_values(seriesB.values(), seriesB.time_index()),
test_series)
test_case.assertEqual(seriesA.append_values(seriesB.values()),
test_series)
# test for equality
test_case.assertEqual(
test_series.drop_after(pd.Timestamp('20130105')).append_values(
test_series.drop_before(pd.Timestamp('20130104')).values()),
test_series)
test_case.assertEqual(seriesA.append_values([]), seriesA)
# randomize order
rd_order = np.random.permutation(range(len(seriesB.values())))
test_case.assertEqual(
seriesA.append_values(seriesB.values()[rd_order],
seriesB.time_index()[rd_order]), test_series)
# add non consecutive index
with test_case.assertRaises(ValueError):
test_case.assertEqual(
seriesA.append_values(seriesB.values(),
seriesB.time_index() + seriesB.freq()),
test_series)
# add existing indices
with test_case.assertRaises(ValueError):
test_case.assertEqual(
seriesA.append_values(
seriesB.values(),
seriesB.time_index() - 3 * seriesB.freq()), test_series)
# other frequency
with test_case.assertRaises(ValueError):
test_case.assertEqual(
seriesA.append_values(
seriesB.values(),
pd.date_range('20130107', '20130113', freq='2d')),
test_series)
def test_slice(self):
TimeSeriesTestCase.helper_test_slice(self, self.series1)
def test_split(self):
TimeSeriesTestCase.helper_test_split(self, self.series1)
def test_drop(self):
TimeSeriesTestCase.helper_test_drop(self, self.series1)
def test_intersect(self):
TimeSeriesTestCase.helper_test_intersect(self, self.series1)
def test_shift(self):
TimeSeriesTestCase.helper_test_shift(self, self.series1)
def test_append(self):
TimeSeriesTestCase.helper_test_append(self, self.series1)
def test_append_values(self):
TimeSeriesTestCase.helper_test_append_values(self, self.series1)
def test_update(self):
seriesA: TimeSeries = TimeSeries.from_times_and_values(
self.times, [0, 1, 1, 3, 4, 5, 6, 2, 8, 0])
seriesB: TimeSeries = TimeSeries.from_times_and_values(
self.times, range(10))
# change nothing
seriesC = self.series1.copy()
with self.assertRaises(ValueError):
seriesA.update(self.times)
seriesC = seriesC.update(self.times, range(10))
self.assertEqual(seriesC, self.series1)
# different len
with self.assertRaises(ValueError):
seriesA.update(self.times, [])
with self.assertRaises(ValueError):
seriesA.update(self.times, np.arange(3))
with self.assertRaises(ValueError):
seriesA.update(self.times, np.arange(4))
# change outside
seriesC = seriesA.copy()
with self.assertRaises(ValueError):
seriesC.update(self.times + 100 * seriesC.freq(), range(10))
seriesC = seriesC.update(
self.times.append(pd.date_range('20140101', '20140110')),
list(range(10)) + [0] * 10)
self.assertEqual(seriesC, self.series1)
# change random
seriesC = seriesA.copy()
seriesC = seriesC.update(
pd.DatetimeIndex(['20130108', '20130110', '20130103']), [7, 9, 2])
self.assertEqual(seriesC, self.series1)
# change one of each series
seriesD = seriesB.copy()
seriesD = seriesD.update(self.times, seriesA.pd_series().values)
seriesA = seriesA.update(
pd.DatetimeIndex(['20130103', '20130108', '20130110']), [2, 7, 9])
self.assertEqual(seriesA, self.series1)
seriesB = seriesB.update(self.times[::2], range(5))
self.assertNotEqual(seriesB, self.series2)
# use nan
new_series = np.empty(10)
new_series[:] = np.nan
new_series[[2, 7, 9]] = [2, 7, 9]
seriesD = seriesD.update(self.times, new_series)
self.assertEqual(seriesD, self.series1)
def test_ops(self):
seriesA = TimeSeries.from_series(
pd.Series([2 for _ in range(10)], index=self.pd_series1.index))
targetAdd = TimeSeries.from_series(
pd.Series(range(2, 12), index=self.pd_series1.index))
targetSub = TimeSeries.from_series(
pd.Series(range(-2, 8), index=self.pd_series1.index))
targetMul = TimeSeries.from_series(
pd.Series(range(0, 20, 2), index=self.pd_series1.index))
targetDiv = TimeSeries.from_series(
pd.Series([i / 2 for i in range(10)], index=self.pd_series1.index))
targetPow = TimeSeries.from_series(
pd.Series([float(i**2) for i in range(10)],
index=self.pd_series1.index))
self.assertEqual(self.series1 + seriesA, targetAdd)
self.assertEqual(self.series1 + 2, targetAdd)
self.assertEqual(2 + self.series1, targetAdd)
self.assertEqual(self.series1 - seriesA, targetSub)
self.assertEqual(self.series1 - 2, targetSub)
self.assertEqual(self.series1 * seriesA, targetMul)
self.assertEqual(self.series1 * 2, targetMul)
self.assertEqual(2 * self.series1, targetMul)
self.assertEqual(self.series1 / seriesA, targetDiv)
self.assertEqual(self.series1 / 2, targetDiv)
self.assertEqual(self.series1**2, targetPow)
with self.assertRaises(ZeroDivisionError):
# Cannot divide by a TimeSeries with a value 0.
self.series1 / self.series1
with self.assertRaises(ZeroDivisionError):
# Cannot divide by 0.
self.series1 / 0
def test_getitem(self):
seriesA: TimeSeries = self.series1.drop_after(pd.Timestamp("20130105"))
self.assertEqual(self.series1[pd.date_range('20130101', ' 20130104')],
seriesA)
self.assertEqual(self.series1[:4], seriesA)
self.assertTrue(self.series1[pd.Timestamp('20130101')] == TimeSeries(
self.series1.pd_dataframe()[:1], freq=self.series1.freq()))
self.assertEqual(
self.series1[pd.Timestamp('20130101'):pd.Timestamp('20130104')],
seriesA)
with self.assertRaises(IndexError):
self.series1[pd.date_range('19990101', '19990201')]
with self.assertRaises(KeyError):
self.series1['19990101']
with self.assertRaises(IndexError):
self.series1[::-1]
def test_fill_missing_dates(self):
with self.assertRaises(ValueError):
# Series cannot have date holes without automatic filling
range_ = pd.date_range('20130101', '20130104').append(
pd.date_range('20130106', '20130110'))
TimeSeries.from_series(pd.Series(range(9), index=range_),
fill_missing_dates=False)
with self.assertRaises(ValueError):
# Main series should have explicit frequency in case of date holes
range_ = pd.date_range('20130101', '20130104').append(
pd.date_range('20130106', '20130110', freq='2D'))
TimeSeries.from_series(pd.Series(range(7), index=range_))
range_ = pd.date_range('20130101', '20130104').append(
pd.date_range('20130106', '20130110'))
series_test = TimeSeries.from_series(pd.Series(range(9), index=range_))
self.assertEqual(series_test.freq_str(), 'D')
range_ = pd.date_range('20130101', '20130104', freq='2D') \
.append(pd.date_range('20130107', '20130111', freq='2D'))
series_test = TimeSeries.from_series(pd.Series(range(5), index=range_))
self.assertEqual(series_test.freq_str(), '2D')
self.assertEqual(series_test.start_time(), range_[0])
self.assertEqual(series_test.end_time(), range_[-1])
self.assertTrue(math.isnan(series_test.pd_series().get('20130105')))
def test_resample_timeseries(self):
times = pd.date_range('20130101', '20130110')
pd_series = pd.Series(range(10), index=times)
timeseries = TimeSeries.from_series(pd_series)
resampled_timeseries = timeseries.resample('H')
self.assertEqual(resampled_timeseries.freq_str(), 'H')
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp(
'20130101020000')], 0)
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp(
'20130102020000')], 1)
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp(
'20130109090000')], 8)
resampled_timeseries = timeseries.resample('2D')
self.assertEqual(resampled_timeseries.freq_str(), '2D')
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp('20130101')], 0)
with self.assertRaises(KeyError):
resampled_timeseries.pd_series().at[pd.Timestamp('20130102')]
self.assertEqual(
resampled_timeseries.pd_series().at[pd.Timestamp('20130109')], 8)
def test_short_series_creation(self):
# test missing freq argument error
with self.assertRaises(ValueError):
TimeSeries.from_times_and_values(
pd.date_range('20130101', '20130102'), range(2))
# test empty pandas series error
with self.assertRaises(ValueError):
TimeSeries.from_series(pd.Series(), freq='D')
# test frequency mismatch case
seriesA = TimeSeries.from_times_and_values(pd.date_range(
'20130101', '20130105'),
range(5),
freq='M')
self.assertEqual(seriesA.freq(), 'D')
# test successful instantiation of TimeSeries with length 2
TimeSeries.from_times_and_values(pd.date_range('20130101', '20130102'),
range(2),
freq='D')
def test_short_series_slice(self):
seriesA, seriesB = self.series1.split_after(pd.Timestamp('20130108'))
self.assertEqual(len(seriesA), 8)
self.assertEqual(len(seriesB), 2)
seriesA, seriesB = self.series1.split_after(pd.Timestamp('20130109'))
self.assertEqual(len(seriesA), 9)
self.assertEqual(len(seriesB), 1)
self.assertEqual(seriesB.time_index()[0],
self.series1.time_index()[-1])
seriesA, seriesB = self.series1.split_before(pd.Timestamp('20130103'))
self.assertEqual(len(seriesA), 2)
self.assertEqual(len(seriesB), 8)
seriesA, seriesB = self.series1.split_before(pd.Timestamp('20130102'))
self.assertEqual(len(seriesA), 1)
self.assertEqual(len(seriesB), 9)
self.assertEqual(seriesA.time_index()[-1],
self.series1.time_index()[0])
seriesC = self.series1.slice(pd.Timestamp('20130105'),
pd.Timestamp('20130105'))
self.assertEqual(len(seriesC), 1)
def test_map(self):
fn = np.sin # noqa: E731
series = TimeSeries.from_times_and_values(
pd.date_range('20000101', '20000110'), np.random.randn(10, 3))
df_0 = series.pd_dataframe()
df_2 = series.pd_dataframe()
df_01 = series.pd_dataframe()
df_012 = series.pd_dataframe()
df_0[["0"]] = df_0[["0"]].applymap(fn)
df_2[["2"]] = df_2[["2"]].applymap(fn)
df_01[["0", "1"]] = df_01[["0", "1"]].applymap(fn)
df_012 = df_012.applymap(fn)
series_0 = TimeSeries(df_0, 'D')
series_2 = TimeSeries(df_2, 'D')
series_01 = TimeSeries(df_01, 'D')
series_012 = TimeSeries(df_012, 'D')
self.assertEqual(series_0['0'], series['0'].map(fn))
self.assertEqual(series_2['2'], series['2'].map(fn))
self.assertEqual(series_01[['0', '1']], series[['0', '1']].map(fn))
self.assertEqual(series_012, series[['0', '1', '2']].map(fn))
self.assertEqual(series_012, series.map(fn))
self.assertNotEqual(series_01, series[['0', '1']].map(fn))
def test_map_with_timestamp(self):
series = linear_timeseries(start_value=1,
length=12,
freq='MS',
start_ts=pd.Timestamp('2000-01-01'),
end_value=12) # noqa: E501
zeroes = constant_timeseries(value=0.0,
length=12,
freq='MS',
start_ts=pd.Timestamp('2000-01-01'))
def function(ts, x):
return x - ts.month
new_series = series.map(function)
self.assertEqual(new_series, zeroes)
def test_map_wrong_fn(self):
series = linear_timeseries(start_value=1,
length=12,
freq='MS',
start_ts=pd.Timestamp('2000-01-01'),
end_value=12) # noqa: E501
def add(x, y, z):
return x + y + z
with self.assertRaises(ValueError):
series.map(add)
ufunc_add = np.frompyfunc(add, 3, 1)
with self.assertRaises(ValueError):
series.map(ufunc_add)