def test__apply__on_other_time_series_with_different_length(self):
# Prepare test
val_1 = 21
val_2 = 3
ts_1 = TimeSeries.create("01-2020", "02-2020", "H").fill(val_1)
ts_2 = TimeSeries.create("01-2020", "04-2020", "H").fill(val_2)
# Method at test
with self.assertRaises(AssertionError):
ts = ts_1.apply(lambda x, y: x * y, ts_2)
def test__create__with_freq_as_time_series(self):
ts_freq = TimeSeries.create("01-01-2020", "02-01-2020", "H")
ts = TimeSeries.create("01-01-2020", "02-01-2020", ts_freq)
self.assertIsInstance(ts, TimeSeries)
# Test if all elements are NaNs
self.assertTrue(ts.series.isna().all().values[0])
# Test if frequency is daily
self.assertEqual(ts.series.index.inferred_freq,
ts_freq.series.index.inferred_freq)
def test__append(self):
# Create series
tsd = TimeSeriesDataset()
ts_1 = TimeSeries.create("01-2020", "02-2020", "H")
ts_2 = TimeSeries.create("01-2020", "03-2020", "H")
# Test
self.assertTrue(len(tsd) == 0)
tsd.append(ts_1)
self.assertTrue(len(tsd) == 1)
tsd.append(ts_2)
self.assertTrue(len(tsd) == 2)
def test__apply__on_other_time_series(self):
# Prepare test
val_1 = 21
val_2 = 3
ts_1 = TimeSeries.create("01-2020", "02-2020", "H").fill(val_1)
ts_2 = TimeSeries.create("01-2020", "02-2020", "H").fill(val_2)
# Method at test
ts = ts_1.apply(lambda x, y: x * y, ts_2)
# Test
for i in ts:
self.assertEqual(i, val_1 * val_2)
def test__copy__shallow(self):
# params
ts_1 = TimeSeries.create("01-2020", "03-2020", "H")
ts_2 = TimeSeries.create("02-2020", "04-2020", "min")
my_arr = [ts_1, ts_2]
# object creation
tsd = TimeSeriesDataset(my_arr)
# test
copy = tsd.copy(deep=False)
self.assertNotEqual(id(tsd), id(copy))
for i in range(len(copy)):
self.assertEqual(id(tsd[i]), id(copy[i]))
def test__del(self):
# Create series
ts_1 = TimeSeries.create("01-2020", "02-2020", "H")
ts_2 = TimeSeries.create("01-2020", "03-2020", "H")
my_arr = [ts_1, ts_2]
tsd = TimeSeriesDataset(my_arr)
# Test
self.assertTrue(len(tsd) == 2)
del tsd[-1]
self.assertTrue(len(tsd) == 1)
del tsd[-1]
self.assertTrue(len(tsd) == 0)
def test__merge(self):
# Prepare test
ts1 = TimeSeries.create("01-2020", "03-2020", "H")
ts2 = TimeSeries.create("02-2020", "04-2020", "H")
# Call function
ts = ts1.merge(ts2)
# Test if index is monotonic increasing
self.assertTrue(ts.series.index.is_monotonic_increasing)
# Test if all values are there
len1 = len(ts1) + len(ts2)
len2 = len(ts)
self.assertTrue(len1 == len2)
def test__pad_left(self):
goal_right = "2020-01-10 00:00:00"
# Create series
ts1 = TimeSeries.create("01-02-2020", "01-08-2020", "1D")
ts2 = TimeSeries.create("01-04-2020", "01-09-2020", "1D")
tsd = TimeSeriesDataset([ts1, ts2])
tsd_padded = tsd.pad(limit=goal_right)
# check if all have the same left boundary
self.assertTrue(all([str(ts.boundaries()[1]) == goal_right for ts in tsd_padded]))
def test__to_text__without_metadata(self):
path = self.target_dir + "/to_text_without_metadata"
my_time_series = TimeSeries(self.my_series)
my_time_series.to_text(path)
data_csv_path = "{}/{}.{}".format(path, TIME_SERIES_FILENAME,
TIME_SERIES_EXT)
does_data_csv_exist = os_path.exists(data_csv_path)
self.assertTrue(does_data_csv_exist)
meta_json_path = "{}/{}.{}".format(path, METADATA_FILENAME,
METADATA_EXT)
does_meta_json_exist = os_path.exists(meta_json_path)
self.assertFalse(does_meta_json_exist)
def test__merge(self):
# Create the time series
ts1 = TimeSeries.create("01-01-2020", "01-02-2020", "H").fill(0)
ts2 = TimeSeries.create("01-01-2020", "01-03-2020", "H").fill(0)
ts3 = TimeSeries.create("01-01-2020", "01-04-2020", "H").fill(0)
ts4 = TimeSeries.create("01-02-2020", "01-05-2020", "H").fill(0)
tsd1 = TimeSeriesDataset([ts1, ts2])
tsd2 = TimeSeriesDataset([ts3, ts4])
# Call the function
tsd = tsd1.merge(tsd2)
# Test the beginnings and the ends
self.assertTrue(ts1.start() == tsd[0].start())
self.assertTrue(ts3.end() == tsd[0].end())
self.assertTrue(ts2.start() == tsd[1].start())
self.assertTrue(ts4.end() == tsd[1].end())
def test__init__with_DataFrame_input_many_columns__with_values(self):
index = DatetimeIndex(
['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04'])
my_series = Series([0.4, 1.0, 0.7, 0.6], index=index)
df = DataFrame({TIME_SERIES_VALUES: my_series, "two": my_series})
ts = TimeSeries(df)
self.assertIsInstance(ts, TimeSeries)
def test__to_text(self):
ts = TimeSeries.create("01-01-1990", "01-03-1990", "1D")
# prepare data
ts.series[TIME_SERIES_VALUES] = [0, 1, 2]
ts.series["label_test"] = [0, None, 2]
ts.class_label = "Test"
tsd = TimeSeriesDataset([ts, ts, ts])
tsd.to_text(self.outdir)
# preparte test variables
goal_length = len(tsd)
# check that it created the three folder
folders = glob(f"{self.outdir}/[0-9]")
self.assertEqual(len(folders), goal_length)
# check that all folders have a data.csv and a metadata.json
check = True
for dir in folders:
check &= os.path.isfile(f'{dir}/data.csv')
check &= os.path.isfile(f'{dir}/meta.json')
self.assertTrue(check)
# clean up
shutil.rmtree(self.outdir)
# check if cleaned
self.assertFalse(os.path.isdir(self.outdir))
def test__init__with_DataFrame_input_many_columns__without_values(self):
index = DatetimeIndex(
['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04'])
my_series = Series([0.4, 1.0, 0.7, 0.6], index=index)
df = DataFrame({"one": my_series, "two": my_series})
with self.assertRaises(AssertionError):
ts = TimeSeries(df)
def test__init__with_Series_input(self):
index = DatetimeIndex(
['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04'])
my_series = Series([0.4, 1.0, 0.7, 0.6], index=index)
ts = TimeSeries(my_series)
self.assertTrue(TIME_SERIES_VALUES in ts.series.columns)
self.assertIsInstance(ts, TimeSeries)
def test__pad(self):
def is_regular(ts):
# test if double timestamps in ts
no_duration_diff = ts.index.to_series().diff().diff()[2:] == \
Timedelta(0)
return no_duration_diff.eq(True).all()
def is_monotonic(ts):
# test if monotonic
return ts.series.index.is_monotonic
def is_freq_similar(ts_before, ts_after):
# test if freq is the same
return ts_before.frequency() == ts_after.frequency()
# Create TimeSeries
ts_1 = TimeSeries.create("04-2020", "05-2020", "D")
# Pad before
ts_1_padded_before = ts_1.pad("03-2020")["2020-03-31":"2020-04-02"]
self.assertTrue(is_regular(ts_1_padded_before))
self.assertTrue(is_monotonic(ts_1_padded_before))
self.assertTrue(is_freq_similar(ts_1, ts_1_padded_before))
# Pad after
ts_1_padded_after = ts_1.pad("06-2020")["2020-05-29":"2020-06-02"]
self.assertTrue(is_regular(ts_1_padded_after))
self.assertTrue(is_monotonic(ts_1_padded_after))
self.assertTrue(is_freq_similar(ts_1, ts_1_padded_after))
# Pad during (wrong case)
with self.assertRaises(ValueError):
ts_1.pad("2020-04-15")
def test__empty(self):
ts = TimeSeries.create("01-01-2020", "03-01-2020", "H")
# method at test
ts = ts.empty()
# test
for i in ts:
self.assertTrue(np.isnan(i))
def test__to_darts__type_check(self):
ts = TimeSeries.create("01-2020", "02-2020", "H")
ts = ts.fill(np.random.randint(0, 1000, len(ts)))
self.assertIsInstance(ts, TimeSeries)
dts = ts.to_darts()
from darts import TimeSeries as DartsTimeSeries
self.assertIsInstance(dts, DartsTimeSeries)
def test__trim(self):
# Create series
ts1 = TimeSeries.create("02-01-2020", "06-01-2020", "H").fill(0)
ts2 = TimeSeries.create("01-01-2020", "04-01-2020", "H").fill(0)
# Add Nones
ts1.series[:21] = None
ts1.series[-4:] = None
ts2.series[:2] = None
ts2.series[-14:] = None
# Make the TSD
tsd = TimeSeriesDataset([ts1, ts2])
# Call the function to test
tsd = tsd.trim()
# Test
for ts in tsd:
for i in ts.series[TIME_SERIES_VALUES]:
self.assertFalse(np.isnan(i))
def test__fill(self):
ts = TimeSeries.create("01-01-2020", "03-01-2020", "H")
val = 42
# method at test
ts = ts.fill(val)
# test
for i in ts:
self.assertEqual(val, i)
def setUp(self) -> None:
# Create a time indexed series
index = DatetimeIndex(
['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04'])
self.my_series = Series([0.4, 1.0, 0.7, 0.6], index=index)
# Create metadata
my_unit = {"name": "power", "symbol": "W", "data_type": "float"}
my_coordinates = {"lat": 46.796611, "lon": 7.147563}
my_dict = {"unit": my_unit, "coordinates": my_coordinates}
self.my_metadata = Metadata(my_dict)
self.my_time_series = TimeSeries(self.my_series, self.my_metadata)
# Define a target directory
self.target_dir = "data/test-export"
def test__init__with_DataFrame_input_single_column(self):
index = DatetimeIndex(
['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04'])
my_series = Series([0.4, 1.0, 0.7, 0.6], index=index)
df = DataFrame(data=my_series)
ts = TimeSeries(df)
self.assertTrue(TIME_SERIES_VALUES in ts.series.columns)
self.assertIsInstance(ts, TimeSeries)
def test__apply__on_self(self):
# Prepare test
val = 21
ts = TimeSeries.create("01-2020", "02-2020", "H").fill(val)
# Method at test
ts = ts.apply(lambda x: x * 2)
# Test
for i in ts:
self.assertEqual(i, val * 2)
def test__init__contains_metadata(self):
# Add some data
index = DatetimeIndex(
['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04'])
my_series = DataFrame([0.4, 1.0, 0.7, 0.6], index=index)
my_metadata = Metadata()
my_ts = TimeSeries(my_series, my_metadata)
# Check types
self.assertNotEqual(my_ts.metadata, None,
"The TimeSeries Metadata is probably None")
def test__split_in_chunks(self):
ts = TimeSeries.create("01-01-2020", "03-01-2020", "H")
chunk_len = 5
# method at test
chunks = ts.split_in_chunks(chunk_len)
# test all element but last
for ts_chunk in chunks[:-1]:
self.assertEqual(len(ts_chunk), chunk_len)
# test last element
self.assertLessEqual(len(chunks[-1]), chunk_len)
def test__regularize_right(self):
# The goal of the right boundary
goal_right = "2019-01-10 00:00:00"
# setup data
ts_1 = TimeSeries.create('2019-01-03', '2019-01-05', "1D")
ts_1.series[TIME_SERIES_VALUES] = [3, 4, 5]
ts_2 = TimeSeries.create('2019-01-01', '2019-01-05', "1D")
ts_2.series[TIME_SERIES_VALUES] = [1, 2, 3, 4, 5]
ts_3 = TimeSeries.create('2019-01-05', '2019-01-10', "1D")
ts_3.series[TIME_SERIES_VALUES] = [5, 6, 7, 8, 9, 10]
ts_4 = TimeSeries.create('2019-01-03', '2019-01-07', "1D")
ts_4.series[TIME_SERIES_VALUES] = [3, 4, 5, 6, 7]
tsd = TimeSeriesDataset([ts_1, ts_2, ts_3, ts_4])
# regularize to the right
tsd = tsd.regularize(side="]]")
# assert that all TS in TSD end in right_goal
self.assertTrue(all([str(ts.boundaries()[1]) == goal_right for ts in tsd]))
def test__create_with_freq_as_time_series(self):
# params
length = 3
start = "01-01-2020"
end = "02-01-2020"
freq = TimeSeries.create("01-01-2020", "01-02-2020", "H")
# object creation
tsd = TimeSeriesDataset.create(length, start, end, freq)
# test
for ts in tsd:
# if equal, all ts in tsd have an hourly frequency
self.assertEqual(ts.frequency(), freq.frequency())
def test__merge_by_label(self):
# Create TSD
ts_1 = TimeSeries.create('2019-01-01', '2019-01-02', "1D")
ts_1.series[TIME_SERIES_VALUES] = [0, 1]
ts_1.class_label = "Sensor1"
ts_2 = TimeSeries.create('2019-01-03', '2019-01-03', "1D")
ts_2.series[TIME_SERIES_VALUES] = [2]
ts_2.class_label = "Sensor1"
tsd1 = TimeSeriesDataset([ts_1, ts_2])
ts_3 = TimeSeries.create('2019-01-01', '2019-01-03', "1D")
ts_3.series[TIME_SERIES_VALUES] = [0, 1, 2]
ts_3.class_label = "Sensor2"
tsd2 = TimeSeriesDataset([ts_3])
tsd_merged = tsd1.merge_by_label(tsd2)
self.assertIsInstance(tsd_merged, TimeSeriesDataset)
# Create Goal
ts_goal_1 = TimeSeries.create('2019-01-01', '2019-01-03', "1D")
ts_goal_1.series[TIME_SERIES_VALUES] = [0, 1, 2]
ts_goal_1.class_label = "Sensor1"
ts_goal_2 = TimeSeries.create('2019-01-01', '2019-01-03', "1D")
ts_goal_2.series[TIME_SERIES_VALUES] = [0, 1, 2]
ts_goal_2.class_label = "Sensor2"
tsd_goal = TimeSeriesDataset([ts_goal_1, ts_goal_2])
check = True
for i, ts in enumerate(tsd_goal):
check &= ts.series.equals(tsd_merged[i].series)
check &= (ts.class_label == tsd_merged[i].class_label)
self.assertTrue(check)
def test__init__has_right_types(self):
# Add some data
index = DatetimeIndex(
['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04'])
my_series = DataFrame([0.4, 1.0, 0.7, 0.6], index=index)
my_metadata = Metadata()
my_ts = TimeSeries(my_series, my_metadata)
# Check types
self.assertIsInstance(
my_ts.series, DataFrame,
"The TimeSeries series is not a Pandas DataFrame")
self.assertIsInstance(
my_ts.metadata, Metadata,
"The TimeSeries Metadata hasn't got the right type")
def test__resample(self):
# Create series
ts_1 = TimeSeries.create("01-2020", "02-2020", "H")
ts_2 = TimeSeries.create("01-2020", "03-2020", "min")
my_arr = [ts_1, ts_2]
tsd = TimeSeriesDataset(my_arr)
# Test lowest
tsd_freq_before = tsd.frequency()
lowest_freq = max([to_offset(f) for f in tsd_freq_before])
tsd_res = tsd.resample(freq="lowest")
for ts in tsd_res:
current_offset = to_offset(ts.frequency())
self.assertEqual(current_offset, lowest_freq)
# Test highest
tsd_freq_before = tsd.frequency()
highest_freq = min([to_offset(f) for f in tsd_freq_before])
tsd_res = tsd.resample(freq="highest")
for ts in tsd_res:
current_offset = to_offset(ts.frequency())
self.assertEqual(current_offset, highest_freq)
# Test Dateoffset str
offest_str = "15min"
tsd_res = tsd.resample(freq=offest_str)
for ts in tsd_res:
current_offset = to_offset(ts.frequency())
self.assertEqual(current_offset, offest_str)
# Test TimeSeries as arg
offset_str_arg = "30min"
ts_arg = TimeSeries.create("01-2020", "03-2020", offset_str_arg)
tsd_res = tsd.resample(freq=ts_arg)
for ts in tsd_res:
current_offset = to_offset(ts.frequency())
self.assertEqual(current_offset, offset_str_arg)
def test__trim__both_side_by_default(self):
# Prepare TimeSeries with int as values
start = Timestamp("01-01-2020")
end = Timestamp("03-01-2020")
ts_initial = TimeSeries.create(start, end, "H")
ts_initial = ts_initial.fill(42)
# Pad the TimeSeries with np.nans
ts_pad = ts_initial.pad("01-12-2019").pad("05-01-2020")
# Method at test
ts_trimmed = ts_pad.trim()
# test if no NaNs
self.assertFalse(ts_trimmed.series.isna().values.any())
# test boundaries
new_start, new_end = ts_trimmed.boundaries()
self.assertEqual(start, new_start)
self.assertEqual(end, new_end)
