def test_fill_missing_dates(self):
"""Test fill_missing_dates function"""
_start = Date(freq='m', year=2005, month=1)
_end = Date(freq='m', year=2005, month=4)
#
dates = date_array([_start, _end], freq='M')
series = time_series([1, 2], dates)
filled_ser = fill_missing_dates(series)
#
assert_equal(filled_ser.start_date, _start)
assert_equal(filled_ser.end_date, _end)
assert(filled_ser.isfull())
assert(not filled_ser.has_duplicated_dates())
assert_equal(filled_ser.size, _end - _start + 1)
#
data = N.arange(5*24).reshape(5,24)
datelist = ['2007-07-01','2007-07-02','2007-07-03','2007-07-05','2007-07-06']
dates = date_array_fromlist(datelist, 'D')
dseries = time_series(data, dates)
ndates = date_array_fromrange(start_date=dates[0],end_date=dates[-2])
#
fseries = fill_missing_dates(dseries)
assert_equal(fseries.shape, (6,24))
assert_equal(fseries._mask[:,0], [0,0,0,1,0,0])
#
fseries = fill_missing_dates(dseries[:,0])
assert_equal(fseries.shape, (6,))
assert_equal(fseries._mask, [0,0,0,1,0,0])
#
series = time_series(data.ravel()[:4].reshape(2,2),dates=dates[:-1])
fseries = fill_missing_dates(series)
assert_equal(fseries.shape, (5,))
assert_equal(fseries._mask, [0,0,0,1,0,])
def test_on2d(self):
"Tests getitem on a 2D series"
(a,b,d) = ([1,2,3],[3,2,1], date_array(thisday('M'),length=3))
ser_x = time_series(N.column_stack((a,b)), dates=d)
assert_equal(ser_x[0,0], time_series(a[0],d[0]))
assert_equal(ser_x[0,:], time_series([(a[0],b[0])], d[0]))
assert_equal(ser_x[:,0], time_series(a, d))
assert_equal(ser_x[:,:], ser_x)
def test_fromseries (self):
"Base data definition."
(dlist, dates, data) = self.d
series = time_series(data, dlist)
dates = dates+15
series = time_series(series, dates)
assert(isinstance(series, TimeSeries))
assert_equal(series._mask, [1,0,0,0,0]*3)
assert_equal(series._series, data)
assert_equal(series._dates, dates)
assert_equal(series.freqstr, 'D')
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__timeseriescompat_multiple(self):
"Tests the compatibility of multiple time series."
seriesM_10 = time_series(N.arange(10),
date_array(
start_date=Date(freq='m', year=2005, month=1),
length=10)
)
seriesD_10 = time_series(N.arange(10),
date_array(
start_date=Date(freq='d', year=2005, month=1, day=1),
length=10)
)
seriesD_5 = time_series(N.arange(5),
date_array(
start_date=Date(freq='d', year=2005, month=1, day=1),
length=5)
)
seriesD_5_apr = time_series(N.arange(5),
date_array(
start_date=Date(freq='d', year=2005, month=4, day=1),
length=5)
)
assert(tseries._timeseriescompat_multiple(seriesM_10, seriesM_10, seriesM_10))
try:
tseries._timeseriescompat_multiple(seriesM_10, seriesD_10)
exception = False
except:
exception = True
assert(exception)
try:
tseries._timeseriescompat_multiple(seriesD_5, seriesD_10)
exception = False
except:
exception = True
assert(exception)
try:
tseries._timeseriescompat_multiple(seriesD_5, seriesD_5_apr)
exception = False
except:
exception = True
assert(exception)
def test_alignseries(self):
"Tests align_series & align_with"
(series, data, dates) = self.d
#
empty_series = time_series([], freq='d')
a, b = align_series(series, empty_series)
assert_equal(a.start_date, b.start_date)
assert_equal(a.end_date, b.end_date)
#
aseries = time_series(data, dates+10)
bseries = time_series(data, dates-10)
(a, b) = align_with(series, aseries, bseries)
assert_equal(a._dates, series._dates)
assert_equal(b._dates, series._dates)
assert_equal(a[-5:], series[:5])
assert_equal(b[:5], series[-5:])
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_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_fromrange (self):
"Base data definition."
(dlist, dates, data) = self.d
series = time_series(data, start_date=dates[0], length=15)
assert(isinstance(series, TimeSeries))
assert_equal(series._mask, [1,0,0,0,0]*3)
assert_equal(series._series, data)
assert_equal(series._dates, dates)
assert_equal(series.freqstr, 'D')
def test_ontimeseries(self):
data = time_series(self.maskeddata, start_date=thisday('D'))
for width in [3,5,7]:
k = (width-1)/2
ravg = MF.cmov_average(data,width)
assert(isinstance(ravg, MaskedArray))
assert_equal(ravg, data)
m = N.zeros(len(data), N.bool_)
m[:k] = m[-k:] = m[10-k:10+k+1] = True
assert_equal(ravg._mask, m)
assert_equal(ravg._dates, data._dates)
def test_compressed(self):
"Tests compress"
dlist = ['2007-01-%02i' % i for i in range(1,16)]
dates = date_array_fromlist(dlist)
data = masked_array(numeric.arange(15), mask=[1,0,0,0,0]*3, dtype=float_)
series = time_series(data, dlist)
#
keeper = N.array([0,1,1,1,1]*3, dtype=bool_)
c_series = series.compressed()
assert_equal(c_series._data, [1,2,3,4,6,7,8,9,11,12,13,14])
assert_equal(c_series._mask, nomask)
assert_equal(c_series._dates, dates[keeper])
#
series_st = time_series(MA.column_stack((data,data[::-1])),
dates=dates)
c_series = series_st.compressed()
d = [1,2,3,6,7,8,11,12,13]
assert_equal(c_series._data, N.c_[(d,list(reversed(d)))])
assert_equal(c_series._mask, nomask)
assert_equal(c_series._dates, dates[d])
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 tests_onmultitimeseries(self):
maskeddata = MaskedArray(N.random.random(75).reshape(25,3))
maskeddata[10] = masked
data = time_series(maskeddata, start_date=thisday('D'))
for width in [3,5,7]:
k = (width-1)/2
ravg = MF.cmov_average(data,width)
assert(isinstance(ravg, MaskedArray))
assert_almost_equal(ravg[18].squeeze(), data[18-k:18+k+1].mean(0))
m = N.zeros(data.shape, N.bool_)
m[:k] = m[-k:] = m[10-k:10+k+1] = True
assert_equal(ravg._mask, m)
assert_equal(ravg._dates, data._dates)
def test_concatenate(self):
"Tests concatenate"
dlist = ['2007-%02i' % i for i in range(1,6)]
dates = date_array_fromlist(dlist)
data = masked_array(numeric.arange(5), mask=[1,0,0,0,0], dtype=float_)
#
ser_1 = time_series(data, dates)
ser_2 = time_series(data, dates=dates+10)
newseries = concatenate_series(ser_1, ser_2)
assert_equal(newseries._data,[0,1,2,3,4,0,0,0,0,0,0,1,2,3,4])
assert_equal(newseries._mask,[1,0,0,0,0]+[1]*5+[1,0,0,0,0])
#
ser_1 = time_series(data, dates)
ser_2 = time_series(data, dates=dates+10)
newseries = concatenate_series(ser_1, ser_2, keep_gap=False)
assert_equal(newseries._data,[0,1,2,3,4,0,1,2,3,4])
assert_equal(newseries._mask,[1,0,0,0,0]+[1,0,0,0,0])
assert newseries.has_missing_dates()
#
ser_2 = time_series(data, dates=dates+3)
newseries = concatenate_series(ser_1, ser_2)
assert_equal(newseries._data,[0,1,2,0,1,2,3,4])
assert_equal(newseries._mask,[1,0,0,1,0,0,0,0])
def test_onnd(self):
"Tests getitem on a nD series"
hodie = thisday('D')
# Case 1D
series = time_series(N.arange(5), mask=[1,0,0,0,0], start_date=hodie)
assert_equal(series[0], 0)
# Case 1D + mask
series = time_series(N.arange(5), mask=[1,0,0,0,0], start_date=hodie)
assert series[0] is tsmasked
# Case 2D
series = time_series(N.arange(10).reshape(5,2), start_date=hodie)
assert_equal(len(series), 5)
assert_equal(series[0], [[0,1]])
assert_equal(series[0]._dates[0], (hodie))
assert_equal(series[:,0], [0,2,4,6,8])
assert_equal(series[:,0]._dates, series._dates)
# Case 2D + mask
series = time_series(N.arange(10).reshape(5,2), start_date=hodie,
mask=[[1,1],[0,0],[0,0],[0,0],[0,0]])
assert_equal(len(series), 5)
assert_equal(series[0], [[0,1]])
assert_equal(series[0]._mask, [[1,1]])
assert_equal(series[0]._dates[0], (hodie))
assert_equal(series[:,0]._data, [0,2,4,6,8])
assert_equal(series[:,0]._mask, [1,0,0,0,0])
assert_equal(series[:,0]._dates, series._dates)
# Case 3D
series = time_series(N.arange(30).reshape(5,3,2), start_date=hodie)
x = series[0]
assert_equal(len(series), 5)
assert_equal(series[0], [[[0,1],[2,3],[4,5]]])
assert_equal(series[0]._dates[0], (hodie))
assert_equal(series[:,0], series._data[:,0])
assert_equal(series[:,0]._dates, series._dates)
x = series[:,:,0]
assert_equal(series[:,:,0], series._data[:,:,0])
assert_equal(series[:,:,0]._dates, series._dates)
def test_unsorted(self):
"Tests that the data are properly sorted along the dates."
dlist = ['2007-01-%02i' % i for i in (3,2,1)]
data = [10,20,30]
series = time_series(data,dlist)
assert_equal(series._data,[30,20,10])
#
series = TimeSeries(data, dlist)
assert_equal(series._data,[30,20,10])
#
series = TimeSeries(data, dlist, mask=[1,0,0])
assert_equal(series._mask,[0,0,1])
#
data = masked_array([10,20,30],mask=[1,0,0])
series = TimeSeries(data, dlist)
assert_equal(series._mask,[0,0,1])
def test_fromdatearray(self):
"Tests the creation of a series from a datearray"
_, dates, _ = self.d
data = dates
#
series = time_series(data, dates)
assert(isinstance(series, TimeSeries))
assert_equal(series._dates, dates)
assert_equal(series._data, data)
assert_equal(series.freqstr, 'D')
#
series[5] = MA.masked
# ensure that series can be represented by a string after masking a value
# (there was a bug before that prevented this from working when using a
# DateArray for the data)
strrep = str(series)
def test_pickling(self):
"Tests pickling/unpickling"
(series, data, dates) = self.d
import cPickle
series_pickled = cPickle.loads(series.dumps())
assert_equal(series_pickled._dates, series._dates)
assert_equal(series_pickled._data, series._data)
assert_equal(series_pickled._mask, series._mask)
#
data = masked_array(N.matrix(range(10)).T, mask=[1,0,0,0,0]*2)
dates = date_array(start_date=thisday('D'), length=10)
series = time_series(data,dates=dates)
series_pickled = cPickle.loads(series.dumps())
assert_equal(series_pickled._dates, series._dates)
assert_equal(series_pickled._data, series._data)
assert_equal(series_pickled._mask, series._mask)
assert(isinstance(series_pickled._data, N.matrix))
def getplot():
# with open("data.json", "rb") as f:
# raw = f.read()
# data = json.loads(raw)
# metadata = data['meta'][0]
# data = data['data']
if not 'layer' in request.args:
return render_template('404.html'), 404
layer = request.args['layer']
data, dates, results = time_series([layer],
'1',
'2012-01-01',
'2014-01-1',
product="gibs",
increment='monthly',
typ="global")
# N = len(data)
# x = [entry[0]['iso_time'].split("T")[0] for entry in data] # np.linspace(0, 1, N)
# y = np.array([entry[0]['mean'] for entry in data])
# name = metadata['short_name'].replace("_", " ")
x = dates
y = data[0, :, 0] # mean
name = layer.replace('_', " ")
layout = dict(
title='Image Analytics for {}'.format(name),
xaxis=dict(title='Date'),
yaxis=dict(title=name),
height=300,
)
# Create a trace
trace = go.Scatter(x=x, y=y)
data = [trace]
fig = dict(data=data, layout=layout)
html = Markup(
plotly.offline.plot(fig, include_plotlyjs=False, output_type='div'))
return html, {'Access-Control-Allow-Origin': '*'}
def test_ontimeseries(self):
data = time_series(self.maskeddata, start_date=thisday('D'))
for Mfunc, Nfunc in self.func_pairs:
for k in [3,4,5]:
result = Mfunc(data, k)
assert(isinstance(result, MaskedArray))
for x in range(len(data)-k+1):
if result[x+k-1] is not TS.tsmasked:
assert_almost_equal(
N.asarray(result[x+k-1]),
N.asarray(Nfunc(data[x:x+k])))
result_mask = N.array([1]*(k-1)+[0]*(len(data)-k+1))
result_mask[10:10+k] = 1
assert_equal(result._mask, result_mask)
assert_equal(result._dates, data._dates)
def test_maskperiod(self):
"Test mask_period"
(series, data, dates) = self.d
series.mask = nomask
(start, end) = ('2007-01-06', '2007-01-12')
mask = mask_period(series, start, end, inside=True, include_edges=True,
inplace=False)
assert_equal(mask._mask, N.array([0,0,0,0,0,1,1,1,1,1,1,1,0,0,0]))
mask = mask_period(series, start, end, inside=True, include_edges=False,
inplace=False)
assert_equal(mask._mask, [0,0,0,0,0,0,1,1,1,1,1,0,0,0,0])
mask = mask_period(series, start, end, inside=False, include_edges=True,
inplace=False)
assert_equal(mask._mask, [1,1,1,1,1,1,0,0,0,0,0,1,1,1,1])
mask = mask_period(series, start, end, inside=False, include_edges=False,
inplace=False)
assert_equal(mask._mask, [1,1,1,1,1,0,0,0,0,0,0,0,1,1,1])
# Now w/ multivariables
data = masked_array(numeric.arange(30).reshape(-1,2), dtype=float_)
series = time_series(data, dates=dates)
mask = mask_period(series, start, end, inside=True, include_edges=True,
inplace=False)
result = N.array([0,0,0,0,0,1,1,1,1,1,1,1,0,0,0])
assert_equal(mask._mask, result.repeat(2).reshape(-1,2))
data['dates']['s'] = ts.Date(freq='s', year=2004, month=1, day=1, hour=0, minute=0, second=0)
for freq in data['dates']:
data['darrays'][freq] = ts.date_array(start_date=data['dates'][freq], length=10)
data['cser']['date_'+freq] = data['darrays'][freq]
data['cser']['bool'] = [True, False, True, False, True, True]
data['cser']['int32'] = np.arange(6).astype(np.int32)
data['cser']['int64'] = np.arange(6).astype(np.int64)
data['cser']['float32'] = np.arange(6).astype(np.float32)
data['cser']['float64'] = np.arange(6).astype(np.float64)
data['cser']['str'] = ["asdf", "aasssssssss", "zzzzzzzzzzzz", "", "blah"]
for x in data['cser']:
data['cser'][x] = ma.masked_array(data['cser'][x])
data['tser'][x] = ts.time_series(data['cser'][x], start_date=data['dates']['a'])
for freq in data['dates']:
data['freqs'][freq] = ts.time_series(np.arange(20).astype(np.float32), start_date=data['dates'][freq])
# test writing for all data types as time series and as case series
for x in data['tser']:
data['tser'][x][1] = ma.masked
data['cser'][x][1] = ma.masked
# series for testing appending data to an existing series
appendTSer = ts.time_series(np.arange(10, 15).astype(np.float32), freq='A', start_date=ts.Date(freq='A', year=2007))
appendCSer = np.arange(10, 15).astype(np.float32)
# series for testing writing over a specified range
rangeTSer = ts.time_series(np.arange(20).astype(np.float32), freq='A', start_date=ts.Date(freq='A', year=2004))
02.02.2004;24;110.84}}}
'''* END SAMPLE DATA *'''
{{{
#!python
import numpy as N
import maskedarray as M
import timeseries as ts
data = N.loadtxt("tmp.txt", dtype='|S10', skiprows=2)
dates = ts.date_array([ts.Date(freq='H',string="%s %s:00" %
(d[0],int(d[1])-1))
for d in data],
freq='H')
series = ts.time_series(data[:,-1].astype(N.float_),
dates,
mask=(data[:,-1]=='-999'))
# <markdowncell>
# ### frequencies
#
# #### Question
#
# Is there a example data set for at least one year on a high temporal
# resolution: 15min or at least 1h. Having such a common data set one
# could set up tutorials examples and debug or ask questions easier
# because all will have the same (non-confidetial) data on the disk.
#
# #### Answer
#
else:
fig = tsfigure(series=series)
# Get the current axe, or create one
sub = fig._axstack()
if sub is None:
sub = fig.add_tsplot(111,series=series,**kwargs)
try:
ret = sub.tsplot(series, *args, **kwargs)
pylab.draw_if_interactive()
except:
pylab.hold(b)
raise
pylab.hold(b)
return ret
################################################################################
if __name__ == '__main__':
da = date_array(start_date=Date(freq='B', year=2003, quarter=3, month=1, day=17),
length=10)
ser = timeseries.time_series(MA.arange(len(da)), dates=da)
# ser[4] = MA.masked
# ser_2 = timeseries.time_series(MA.arange(len(da)), dates=da.asfreq('Q'))
pylab.figure()
pylab.gcf().add_tsplot(111)
pylab.gca().tsplot(ser, 'ko-')
pylab.gca().format_dateaxis()
# pylab.gca().tsplot(ser_2, 'rs')
pylab.show()
# generate function doc strings
for fn in (x for x in __all__ if x[:4] == 'mov_' and x[4:] != 'mean'):
fdoc = _g[fn].func_doc
for prm, dc in param_doc.iteritems():
fdoc = fdoc.replace('$$'+prm+'$$', dc)
fdoc += mov_result_doc
_g[fn].func_doc = fdoc
###############################################################################
if __name__ == '__main__':
from timeseries import time_series, today
from maskedarray.testutils import assert_equal, assert_almost_equal
#
series = time_series(N.arange(10),start_date=today('D'))
#
filtered = mov_sum(series,3)
assert_equal(filtered, [0,1,3,6,9,12,15,18,21,24])
assert_equal(filtered._mask, [1,1,0,0,0,0,0,0,0,0])
assert_equal(filtered._dates, series._dates)
assert_equal(series, N.arange(10))
#
filtered = mov_average(series,3)
assert_equal(filtered, [0,1,1,2,3,4,5,6,7,8])
assert_equal(filtered._mask, [1,1,0,0,0,0,0,0,0,0])
assert_equal(filtered._dates, series._dates)
assert_equal(series, N.arange(10))
#
filtered = mov_average(series._data,3)
assert_equal(filtered, [0,1,1,2,3,4,5,6,7,8])
def __init__(self, *args, **kwds):
NumpyTestCase.__init__(self, *args, **kwds)
dlist = ['2007-01-%02i' % i for i in range(1,16)]
dates = date_array_fromlist(dlist)
data = masked_array(numeric.arange(15), mask=[1,0,0,0,0]*3)
self.d = (time_series(data, dlist), data, dates)
def read(self, name,
start_date=None, end_date=None,
start_case=None, end_case=None, max_string_len=65):
"""read specified object(s) from database
:Parameters:
- `name` (string or list of strings) : names of objects that will be
read from the database
- `start_date` (int, *[None]*) : Applies only when reading time series.
If specified, only data points on or after `start_date` will be read.
If None, data will be read from the first value of the series.
- `end_date` (int, *[None]*) : Applies only when reading time series.
If specified, only data points on or before `end_date` will be read.
If None, data will be read to the last value of the series.
- `start_case` (int, *[None]*) : Applies only when reading case series.
If specified, only data points on or after `start_case` will be read.
If None, data will be read starting from case index 1
- `end_case` (int, *[None]*) : Applies only when reading case series.
If specified, only data points on or before `end_case` will be read.
If None, data will be read to the last value of the series.
- `max_string_len` (int, *[65]*) : Applies only when readings strings
or series of strings. This is the maximum length of string that can
be read. Lower values result in less memory usage, so you should
specify this as low as is reasonable for your data.
:Return:
if `name` is a list of strings:
case insensitive dictionary of the objects
if `name` is a single string:
object from database that is stored as `name`"""
isSingle = False
if isinstance(name, str):
names = [name]
isSingle = True
else:
names = name
items = CaseInsensitiveDict()
#default to -1. This will get the entire range
_start_case = _end_case = -1
_start_date = _end_date = -1
range_freq = None
if start_date is not None:
_start_date = start_date.value - date_value_adjust[start_date.freq]
range_freq = freq_revmap[start_date.freq]
if end_date is not None:
if start_date is not None and start_date.freq != end_date.freq:
raise ValueError("start_date and end_date must be same frequency")
_end_date = end_date.value - date_value_adjust[end_date.freq]
if range_freq is None:
range_freq = freq_revmap[end_date.freq]
if start_case is not None: _start_case = start_case
if end_case is not None: _end_case = end_case
if len(set([_start_case, _end_case, _start_date, _end_date, -1])) != 1:
checkFreq = True
else:
checkFreq = False
for objName in names:
objName = objName.upper()
if checkFreq:
objFreq = self.obj_size(objName)['freq']
if objFreq == range_freq:
start_index, end_index = _start_date, _end_date
elif objFreq == HCASEX:
start_index, end_index = _start_case, _end_case
else:
start_index, end_index = -1, -1
else:
start_index, end_index = -1, -1
result = cf_read(self.dbkey, objName, start_index,
end_index, max_string_len)
if result['type'] == HBOOLN:
numpyType = numpy.bool_
else:
numpyType = fametype_tonumpy(result['type'])
if result['type'] == HNAMEL:
pyObj = [x for x in result['data'][1:-1].split(", ") \
if x != '']
elif result['class'] == HSCALA:
if isinstance(result['data'], str):
if result['mask']:
pyObj = None
else:
pyObj = result['data']
else:
if result['mask'][0]:
pyObj = None
else:
pyObj = result['data'][0]
if result['type'] >= 8: # date type
value = pyObj+ \
date_value_adjust[freq_map[result['type']]]
pyObj = ts.Date(
freq=freq_map[result['type']],
value=value)
else:
pyObj = numpyType(pyObj)
elif result['class'] == HSERIE:
if 'data' in result:
vals = result['data']
mask = result['mask']
if not mask.any(): mask = ma.nomask
else:
vals = []
mask = ma.nomask
if result['type'] >= 8: # date type
valadj = date_value_adjust[freq_map[result['type']]]
if len(vals) > 0: vals += valadj
data = ts.DateArray(vals,
freq=freq_map[result['type']])
else:
data = numpy.array(vals, dtype=numpyType)
if result['freq'] == HCASEX:
pyObj = ma.array(data, mask=mask)
else:
observed = observed_map[result['observed']]
freq = freq_map[result['freq']]
if 'data' in result:
start_date = ts.Date(
freq=freq,
value=result['startindex']+date_value_adjust[freq])
else:
start_date = None
pyObj = ts.time_series(data, freq=freq,
start_date=start_date,
observed=observed, mask=mask)
items[objName] = pyObj
if isSingle:
return items.values()[0]
return items
def test_datafromlist(self):
"Check the creation of a time series from a list of data."
(_, dates, _) = self.d
data = list(range(15))
series = time_series(data, dates)
assert_equal(series._data.size, 15)
def _test_write_empty_tser(self):
"test writing a time series with no data"
emptySer = ts.time_series([], freq='A')
self.db.write_tser('$emptyTSer', emptySer)