def _test_dict_cser(self):
"test writing multiple case series at once using write_cser_dict"
self.db.write_cser_dict({'$cser_1':data['cser']['float32'],
'$cser_2':data['cser']['float32']})
result = self.db.read(['$cser_1', '$cser_2'])
assert_array_equal(result['$cser_1'], data['cser']['float32'])
assert_array_equal(result['$cser_2'], data['cser']['float32'])
def test_empty_timeseries(self):
"Tests that empty TimeSeries are handled properly"
empty_ts = time_series([], freq='b')
assert_array_equal(empty_ts, empty_ts + 1)
assert_array_equal(empty_ts, empty_ts + empty_ts)
assert_equal(empty_ts.start_date, None)
assert_equal(empty_ts.end_date, None)
def _test_verify_write_range_cser(self):
"verify that _test_write_range_write_cser worked as expected"
ser = self.db.read('$rangeCSer')
result = ma.arange(9).astype(np.float32)
result[:4] = ma.masked
assert_array_equal(ser, result)
def _test_verify_write_range_tser(self):
"verify that _test_write_range_write_tser worked as expected"
ser = self.db.read('$rangeTSer')
sDate = ts.Date(freq='A', year=2008)
eDate = ts.Date(freq='A', year=2012)
assert_array_equal(ser, rangeTSer[sDate:eDate+1])
def _test_read_append_tser(self):
"test reading of appended time series"
result = ts.adjust_endpoints(data['tser']['float32'],
start_date=data['tser']['float32'].start_date,
end_date=appendTSer.end_date)
result[appendTSer.start_date:appendTSer.end_date+1] = appendTSer
ser = self.db.read('$appendTSer')
assert_array_equal(result, ser)
def _test_copy_rename(self):
"test copying and renaming an object"
db2 = fame.FameDb("testdb2.db", 'o')
self.db.copy_obj(db2, "$tser_float32", "$copied_obj")
orig_obj = self.db.read("$tser_float32")
copied_obj = db2.read("$copied_obj")
assert_array_equal(orig_obj, copied_obj)
db2.rename_obj("$copied_obj", "$renamed_obj")
assert(db2.obj_exists("$renamed_obj"))
assert(not db2.obj_exists("$copied_obj"))
db2.close()
def test_tshift(self):
"Test tshift function"
series = self.d[0]
shift_negative = series.tshift(-1)
result_data = [999] + [0,1,2,3,4,5,6,7,8,9,10,11,12,13]
result_mask = [1 ] + [1,0,0,0,0,1,0,0,0,0,1, 0, 0, 0 ]
shift_negative_result = time_series(result_data, series._dates, mask=result_mask)
shift_positive = series.tshift(1)
result_data = [1,2,3,4,5,6,7,8,9,10,11,12,13,14] + [999]
result_mask = [0,0,0,0,1,0,0,0,0,1, 0, 0, 0, 0 ] + [1 ]
shift_positive_result = time_series(result_data, series._dates, mask=result_mask)
assert_array_equal(shift_negative, shift_negative_result)
assert_array_equal(shift_positive, shift_positive_result)
def test_convert(self):
"""Test convert function
Just check basic functionality. The details of the actual
date conversion algorithms already tested by asfreq in the
test_dates test suite.
"""
lowFreqSeries = time_series(N.arange(10),
start_date=Date(freq='m', year=2005, month=6))
highFreqSeries = time_series(N.arange(100),
start_date=Date(freq='b', year=2005, month=6, day=1))
ndseries = time_series(N.arange(124).reshape(62,2),
start_date=Date(freq='d', year=2005, month=7, day=1))
lowToHigh_start = lowFreqSeries.convert('B', position='START')
assert_equal(lowToHigh_start.start_date,
Date(freq='m', year=2005, month=6).asfreq("B", relation="BEFORE"))
assert_equal(lowToHigh_start.end_date,
(Date(freq='m', year=2005, month=6) + 9).asfreq("B", relation="AFTER"))
assert_equal(lowToHigh_start._mask[0], False)
assert_equal(lowToHigh_start._mask[-1], True)
lowToHigh_end = lowFreqSeries.convert('B', position='END')
assert_equal(lowToHigh_end.start_date,
Date(freq='m', year=2005, month=6).asfreq("B", relation="BEFORE"))
assert_equal(lowToHigh_end.end_date,
(Date(freq='m', year=2005, month=6) + 9).asfreq("B", relation="AFTER"))
assert_equal(lowToHigh_end._mask[0], True)
assert_equal(lowToHigh_end._mask[-1], False)
highToLow = highFreqSeries.convert('M', func=None)
assert_equal(highToLow.ndim, 2)
assert_equal(highToLow.shape[1], 23)
assert_equal(highToLow.start_date,
Date(freq='b', year=2005, month=6, day=1).asfreq('M'))
assert_equal(highToLow.end_date,
(Date(freq='b', year=2005, month=6, day=1) + 99).asfreq('M'))
assert_array_equal(lowFreqSeries, lowFreqSeries.convert("M"))
assert_equal(ndseries.convert('M',sum), [[930,961],[2852,2883]])
def _test_read_range_tser(self):
"test reading a time series over specified ranges"
src = data['tser']['float32']
s1 = src.start_date+2
s2 = src.start_date-2
e1 = src.end_date+2
e2 = src.end_date-2
dateList = [(s1, e1),
(s1, e2),
(s2, e1),
(s2, e2)]
for s, e in dateList:
res = ts.adjust_endpoints(src, start_date=s, end_date=e)
ser = self.db.read('$tser_float32', start_date=s, end_date=e)
assert_array_equal(res, ser)
def test_split(self):
"""Test the split function."""
ms = time_series(N.arange(62).reshape(31,2),
start_date=Date(freq='d', year=2005, month=7, day=1))
d1,d2 = split(ms)
assert_array_equal(d1.data, ms.data[:,0])
assert_array_equal(d1.dates, ms.dates)
assert_array_equal(d2.data, ms.data[:,1])
series = self.d[0]
ss = split(series)[0]
assert_array_equal(series, ss)
def _test_read_range_cser(self):
"test reading case series over specified ranges"
src = data['cser']['float32']
s1 = 3
s2 = 1
e1 = 8
e2 = 4
caseList = [(s1, e1),
(s1, e2),
(s2, e1),
(s2, e2)]
for s, e in caseList:
size = (e - s + 1)
res = ma.array([0]*size , np.float32, mask=[1]*size )
if e < src.size: _e = size
else: _e = size - max(e-size, 0, size - src.size)
res[0:_e] = src[s-1:min(e, src.size)]
ser = self.db.read('$cser_float32', start_case=s, end_case=e)
assert_array_equal(res, ser)
def _test_overwrite_cser(self):
"test overwriting a case series"
self.db.write_cser('$cser_float32', data['cser']['bool'], overwrite=True)
ser = self.db.read('$cser_float32')
assert_array_equal(ser, data['cser']['bool'])
def _test_read_append_cser(self):
"test reading of appended case series"
result = ma.concatenate([data['cser']['float32'][:3], appendCSer])
ser = self.db.read('$appendCSer')
assert_array_equal(result, ser)
