def test_get(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert( 'test', t/2, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get( 'test', 'minute', timestamp=_time(100) )
assert_equals( [_time(60)], interval.keys() )
keys = list(range(30,60))
assert_equals( keys, interval[_time(60)].keys() )
for k in keys:
assert_equals( 2, interval[_time(60)][k] )
# no matching interval, returns no with empty value list
interval = self.series.get( 'test', 'minute' )
assert_equals( 1, len(interval) )
assert_equals( 0, len(interval.values()[0]) )
###
### with resolution, optionally condensed
###
interval = self.series.get( 'test', 'hour', timestamp=_time(100) )
keys = list(range(30,60))
assert_equals( 60, len(interval) )
assert_equals( keys, interval[_time(60)].keys() )
interval = self.series.get( 'test', 'hour', timestamp=_time(100), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( list(range(0,1800)), interval[_time(0)].keys() )
def test_get(self):
# 2 hours worth of data
for t in xrange(1, 7200):
self.series.insert( 'test', 1, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get( 'test', 'minute', timestamp=_time(100) )
assert_equals( map(_time, [60]), interval.keys() )
assert_equals( 60, interval[_time(60)] )
# no matching interval, returns no with empty value list
interval = self.series.get( 'test', 'minute' )
assert_equals( 1, len(interval) )
assert_equals( 0, interval.values()[0] )
###
### with resolution, optionally condensed
###
interval = self.series.get( 'test', 'hour', timestamp=_time(100) )
assert_equals( 60, len(interval) )
assert_equals( 60, interval[_time(60)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(100), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( 3599, interval[_time(0)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(4000), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( 3600, interval[_time(3600)] )
def test_get(self):
# 2 hours worth of data. Trim some bits from data resolution to assert
# proper set behavior
for t in xrange(1, 7200):
self.series.insert( 'test', t/15, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get( 'test', 'minute', timestamp=_time(100) )
assert_equals( map(_time, [60]), interval.keys() )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
# no matching interval, returns no with empty value list
interval = self.series.get( 'test', 'minute' )
assert_equals( 1, len(interval) )
assert_equals( set(), interval.values()[0] )
###
### with resolution, optionally condensed
###
interval = self.series.get( 'test', 'hour', timestamp=_time(100) )
assert_equals( 60, len(interval) )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(100), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( set(range(0,240)), interval[_time(0)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(4000), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( set(range(240,480)), interval[_time(3600)] )
def test_get(self):
# 2 hours worth of data. Trim some bits from data resolution to assert
# proper set behavior
for t in xrange(1, 7200):
self.series.insert( 'test', t/15, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get( 'test', 'minute', timestamp=_time(100) )
assert_equals( map(_time, [60]), interval.keys() )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
# no matching interval, returns no with empty value list
interval = self.series.get( 'test', 'minute' )
assert_equals( 1, len(interval) )
assert_equals( set(), interval.values()[0] )
###
### with resolution, optionally condensed
###
interval = self.series.get( 'test', 'hour', timestamp=_time(100) )
assert_equals( 60, len(interval) )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(100), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( set(range(1,240)), interval[_time(0)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(4000), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( set(range(240,480)), interval[_time(3600)] )
def test_get(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert('test', t / 2, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get('test', 'minute', timestamp=_time(100))
assert_equals([_time(60)], interval.keys())
keys = list(range(30, 60))
assert_equals(keys, interval[_time(60)].keys())
for k in keys:
assert_equals(2, interval[_time(60)][k])
# no matching interval, returns no with empty value list
interval = self.series.get('test', 'minute')
assert_equals(1, len(interval))
assert_equals(0, len(interval.values()[0]))
###
### with resolution, optionally condensed
###
interval = self.series.get('test', 'hour', timestamp=_time(100))
keys = list(range(30, 60))
assert_equals(60, len(interval))
assert_equals(keys, interval[_time(60)].keys())
interval = self.series.get('test',
'hour',
timestamp=_time(100),
condensed=True)
assert_equals(1, len(interval))
assert_equals(list(range(0, 1800)), interval[_time(0)].keys())
def test_list(self):
self.series.insert('test', 32, timestamp=_time(0))
self.series.insert('test1', 32, timestamp=_time(0))
self.series.insert('test2', 32, timestamp=_time(0))
self.series.insert('test', 32, timestamp=_time(0))
res = sorted(self.series.list())
assert_equals(['test', 'test1', 'test2'], res)
self.series.delete('test')
self.series.delete('test1')
self.series.delete('test2')
def test_list(self):
self.series.insert( 'test', 32, timestamp=_time(0) )
self.series.insert( 'test1', 32, timestamp=_time(0) )
self.series.insert( 'test2', 32, timestamp=_time(0) )
self.series.insert( 'test', 32, timestamp=_time(0) )
res = sorted(self.series.list())
assert_equals( ['test', 'test1', 'test2'], res )
self.series.delete('test')
self.series.delete('test1')
self.series.delete('test2')
def test_properties(self):
self.series.insert( 'test', 32, timestamp=_time(0) )
self.series.insert( 'test', 32, timestamp=_time(60) )
self.series.insert( 'test', 32, timestamp=_time(600) )
res = self.series.properties('test')
assert_equals( _time(0), res['minute']['first'] )
assert_equals( _time(600), res['minute']['last'] )
assert_equals( _time(0), res['hour']['first'] )
assert_equals( _time(0), res['hour']['last'] )
self.series.delete('test')
def test_properties(self):
self.series.insert('test', 32, timestamp=_time(0))
self.series.insert('test', 32, timestamp=_time(60))
self.series.insert('test', 32, timestamp=_time(600))
res = self.series.properties('test')
assert_equals(_time(0), res['minute']['first'])
assert_equals(_time(600), res['minute']['last'])
assert_equals(_time(0), res['hour']['first'])
assert_equals(_time(0), res['hour']['last'])
self.series.delete('test')
def test_get(self):
# 2 hours worth of data
for t in xrange(1, 7200):
self.series.insert('test', 1, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get('test', 'minute', timestamp=_time(100))
assert_equals(map(_time, [60]), interval.keys())
assert_equals(60, interval[_time(60)])
# no matching interval, returns no with empty value list
interval = self.series.get('test', 'minute')
assert_equals(1, len(interval))
assert_equals(0, interval.values()[0])
###
### with resolution, optionally condensed
###
interval = self.series.get('test', 'hour', timestamp=_time(100))
assert_equals(60, len(interval))
assert_equals(60, interval[_time(60)])
interval = self.series.get('test',
'hour',
timestamp=_time(100),
condensed=True)
assert_equals(1, len(interval))
assert_equals(3599, interval[_time(0)])
interval = self.series.get('test',
'hour',
timestamp=_time(4000),
condensed=True)
assert_equals(1, len(interval))
assert_equals(3600, interval[_time(3600)])
def test_insert_multiple_intervals_before(self):
ts1 = _time(0)
ts2 = self.series._intervals['minute']['i_calc'].normalize(ts1, -1)
ts3 = self.series._intervals['minute']['i_calc'].normalize(ts1, -2)
assert_not_equals(ts1, ts2)
self.series.insert('test', 32, timestamp=ts1, intervals=-1)
interval_1 = self.series.get('test', 'minute', timestamp=ts1)
assert_equals([32], interval_1[ts1])
interval_2 = self.series.get('test', 'minute', timestamp=ts2)
assert_equals([32], interval_2[ts2])
self.series.insert('test', 42, timestamp=ts1, intervals=-2)
interval_1 = self.series.get('test', 'minute', timestamp=ts1)
assert_equals([32, 42], interval_1[ts1])
interval_2 = self.series.get('test', 'minute', timestamp=ts2)
assert_equals([32, 42], interval_2[ts2])
interval_3 = self.series.get('test', 'minute', timestamp=ts3)
assert_equals([42], interval_3[ts3])
def test_insert_multiple_intervals_before(self):
ts1 = _time(0)
ts2 = self.series._intervals['minute']['i_calc'].normalize(ts1, -1)
ts3 = self.series._intervals['minute']['i_calc'].normalize(ts1, -2)
assert_not_equals( ts1, ts2 )
self.series.insert( 'test', 32, timestamp=ts1, intervals=-1 )
interval_1 = self.series.get( 'test', 'minute', timestamp=ts1 )
assert_equals( [32], interval_1[ts1] )
interval_2 = self.series.get( 'test', 'minute', timestamp=ts2 )
assert_equals( [32], interval_2[ts2] )
self.series.insert( 'test', 42, timestamp=ts1, intervals=-2 )
interval_1 = self.series.get( 'test', 'minute', timestamp=ts1 )
assert_equals( [32,42], interval_1[ts1] )
interval_2 = self.series.get( 'test', 'minute', timestamp=ts2 )
assert_equals( [32,42], interval_2[ts2] )
interval_3 = self.series.get( 'test', 'minute', timestamp=ts3 )
assert_equals( [42], interval_3[ts3] )
def test_insert_multiple_intervals_after(self):
ts1 = _time(0)
ts2 = self.series._intervals['weekly']['i_calc'].normalize(ts1, 1)
ts3 = self.series._intervals['weekly']['i_calc'].normalize(ts1, 2)
assert_not_equals( ts1, ts2 )
self.series.insert( 'test', 32, timestamp=ts1, intervals=1 )
interval_1 = self.series.get( 'test', 'weekly', timestamp=ts1 )
assert_equals( [32], interval_1[ts1] )
interval_2 = self.series.get( 'test', 'weekly', timestamp=ts2 )
assert_equals( [32], interval_2[ts2] )
self.series.insert( 'test', 42, timestamp=ts1, intervals=2 )
interval_1 = self.series.get( 'test', 'weekly', timestamp=ts1 )
assert_equals( [32,42], interval_1[ts1] )
interval_2 = self.series.get( 'test', 'weekly', timestamp=ts2 )
assert_equals( [32,42], interval_2[ts2] )
interval_3 = self.series.get( 'test', 'weekly', timestamp=ts3 )
assert_equals( [42], interval_3[ts3] )
def test_insert_multiple_intervals_after(self):
ts1 = _time(0)
ts2 = self.series._intervals['weekly']['i_calc'].normalize(ts1, 1)
ts3 = self.series._intervals['weekly']['i_calc'].normalize(ts1, 2)
assert_not_equals(ts1, ts2)
self.series.insert('test', 32, timestamp=ts1, intervals=1)
interval_1 = self.series.get('test', 'weekly', timestamp=ts1)
assert_equals([32], interval_1[ts1])
interval_2 = self.series.get('test', 'weekly', timestamp=ts2)
assert_equals([32], interval_2[ts2])
self.series.insert('test', 42, timestamp=ts1, intervals=2)
interval_1 = self.series.get('test', 'weekly', timestamp=ts1)
assert_equals([32, 42], interval_1[ts1])
interval_2 = self.series.get('test', 'weekly', timestamp=ts2)
assert_equals([32, 42], interval_2[ts2])
interval_3 = self.series.get('test', 'weekly', timestamp=ts3)
assert_equals([42], interval_3[ts3])
def test_bulk_insert(self):
inserts = {
None : { 'test1':[1,2,3], 'test2':[4,5,6] },
_time(0) : { 'test1':[1,2,3], 'test2':[4,5,6], 'test3':[7,8,9] },
_time(30) : { 'test1':[1,2,3], 'test2':[4,5,6] },
_time(60) : { 'test1':[1,2,3], 'test3':[7,8,9] }
}
self.series.bulk_insert( inserts )
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals( {1:2, 2:2, 3:2}, t1_i1[_time(0)] )
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals( {4:2, 5:2, 6:2}, t2_i1[_time(0)] )
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals( {7:1, 8:1, 9:1}, t3_i1[_time(0)] )
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(60))
assert_equals( {1:1, 2:1, 3:1}, t1_i2[_time(60)] )
def test_bulk_insert_intervals_before(self):
a,b,c,d,e,f = 10,11,12,13,14,15
inserts = OrderedDict( (
(None , { 'test1':[1,2,3], 'test2':[4,5,6] } ),
(_time(0) , { 'test1':[1,2,3], 'test2':[4,5,6], 'test3':[7,8,9] } ),
(_time(30), { 'test1':[1,2,3], 'test2':[4,5,6] } ),
(_time(60), { 'test1':[a,b,c], 'test3':[d,e,f] })
) )
self.series.bulk_insert( inserts, intervals=-3 )
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals( [1,2,3,1,2,3,a,b,c], t1_i1[_time(0)] )
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals( [4,5,6,4,5,6], t2_i1[_time(0)] )
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals( [7,8,9,d,e,f], t3_i1[_time(0)] )
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(-60))
assert_equals( [1,2,3,1,2,3,a,b,c], t1_i2[_time(-60)] )
t3_i3 = self.series.get('test3', 'minute', timestamp=_time(-120))
assert_equals( [7,8,9,d,e,f], t3_i3[_time(-120)] )
t3_i4 = self.series.get('test3', 'minute', timestamp=_time(-180))
assert_equals( [7,8,9], t3_i4[_time(-180)] )
def test_bulk_insert(self):
inserts = {
None : { 'test1':[1,2,3], 'test2':[4,5,6] },
_time(0) : { 'test1':[1,2,3], 'test2':[4,5,6], 'test3':[7,8,9] },
_time(30) : { 'test1':[1,2,3], 'test2':[4,5,6] },
_time(60) : { 'test1':[1,2,3], 'test3':[7,8,9] }
}
self.series.bulk_insert( inserts )
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals( [1,2,3,1,2,3], t1_i1[_time(0)] )
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals( [4,5,6,4,5,6], t2_i1[_time(0)] )
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals( [7,8,9], t3_i1[_time(0)] )
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(60))
assert_equals( [1,2,3], t1_i2[_time(60)] )
def test_bulk_insert_intervals_after(self):
a,b,c,d,e,f = 10,11,12,13,14,15
inserts = OrderedDict( (
(None , { 'test1':[1,2,3], 'test2':[4,5,6] } ),
(_time(0) , { 'test1':[1,2,3], 'test2':[4,5,6], 'test3':[7,8,9] } ),
(_time(30), { 'test1':[1,2,3], 'test2':[4,5,6] } ),
(_time(60), { 'test1':[a,b,c], 'test3':[d,e,f] })
) )
self.series.bulk_insert( inserts, intervals=3 )
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals( 1+2+3+1+2+3, t1_i1[_time(0)] )
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals( 4+5+6+4+5+6, t2_i1[_time(0)] )
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals( 7+8+9, t3_i1[_time(0)] )
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(60))
assert_equals( 1+2+3+1+2+3+a+b+c, t1_i2[_time(60)] )
t3_i3 = self.series.get('test3', 'minute', timestamp=_time(120))
assert_equals( 7+8+9+d+e+f, t3_i3[_time(120)] )
t3_i4 = self.series.get('test3', 'minute', timestamp=_time(180))
assert_equals( 7+8+9+d+e+f, t3_i4[_time(180)] )
def test_series_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
self.series.delete('test1')
self.series.delete('test2')
for t in xrange(1, 120):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(3600, 3720):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(120, 240):
self.series.insert( 'test1', t, timestamp=_time(t) )
for t in xrange(3720, 3840):
self.series.insert( 'test1', t, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250) )
assert_equals( map(_time,[0,60,120,180,240]), interval.keys() )
assert_equals( list(range(1,60))+list(range(1,60)), interval[_time(0)] )
assert_equals( list(range(60,120))+list(range(60,120)), interval[_time(60)] )
assert_equals( list(range(120,180)), interval[_time(120)] )
assert_equals( list(range(180,240)), interval[_time(180)] )
assert_equals( [], interval[_time(240)] )
# no matching interval, returns no with empty value list
interval = self.series.series( ['test1','test2'], 'minute', start=time.time(), steps=2 )
assert_equals( 2, len(interval) )
assert_equals( [], interval.values()[0] )
# with transforms
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250), transform=['min','count'] )
assert_equals( map(_time,[0,60,120,180,240]), interval.keys() )
assert_equals( {'min':1, 'count':118}, interval[_time(0)] )
assert_equals( {'min':60, 'count':120}, interval[_time(60)] )
assert_equals( {'min':120, 'count':60}, interval[_time(120)] )
assert_equals( {'min':180, 'count':60}, interval[_time(180)] )
assert_equals( {'min':0, 'count':0}, interval[_time(240)] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250), collapse=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240)),
interval[_time(0)] )
# with tranforms and collapsed
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250), transform=['min','max', 'count'], collapse=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( {'min':1, 'max':239, 'count':358}, interval[_time(0)] )
###
### with resolution, optionally condensed
###
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( map(_time,[0,60,120,180]), interval[_time(0)].keys() )
assert_equals( 4, len(interval[_time(0)]) )
assert_equals( list(range(1,60))+list(range(1,60)), interval[_time(0)][_time(0)] )
assert_equals( list(range(60,120))+list(range(60,120)), interval[_time(0)][_time(60)] )
assert_equals( list(range(120,180)), interval[_time(0)][_time(120)] )
assert_equals( list(range(180,240)), interval[_time(0)][_time(180)] )
# condensed
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250), condensed=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240)),
interval[_time(0)] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240))+\
list(range(3600,3660))+list(range(3600,3660))+list(range(3660,3720))+list(range(3660,3720))+\
list(range(3720,3780))+list(range(3780,3840)),
interval[_time(0)] )
# with transforms collapsed
interval = self.series.series( ['test1','test2'], 'hour', condensed=True, end=_time(4200), steps=2, collapse=True, transform=['min','max','count'] )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( {'min':1,'max':3839,'count':718}, interval[_time(0)] )
def test_get_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
self.series.delete('test1')
self.series.delete('test2')
for t in xrange(1, 120):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(3600, 3720):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(120, 240):
self.series.insert( 'test1', t, timestamp=_time(t) )
for t in xrange(3721, 3840):
self.series.insert( 'test1', t, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
# interval with 2 series worth of data
interval = self.series.get( ['test1','test2'], 'minute', timestamp=_time(100) )
assert_equals( [_time(60)], interval.keys() )
assert_equals( list(range(60,120))+list(range(60,120)), interval[_time(60)] )
# interval with 1 series worth of data
interval = self.series.get( ['test1','test2'], 'minute', timestamp=_time(122) )
assert_equals( [_time(120)], interval.keys() )
assert_equals( list(range(120,180)), interval[_time(120)] )
# no matching interval, returns no with empty value list
interval = self.series.get( ['test1','test2'], 'minute' )
assert_equals( 1, len(interval) )
assert_equals( 0, len(interval.values()[0]) )
###
### with resolution, optionally condensed
###
interval = self.series.get( ['test1','test2'], 'hour', timestamp=_time(100) )
assert_equals( map(_time,[0,60,120,180]), interval.keys() )
assert_equals( list(range(1,60))+list(range(1,60)), interval[_time(0)] )
assert_equals( list(range(60,120))+list(range(60,120)), interval[_time(60)] )
assert_equals( list(range(120,180)), interval[_time(120)] )
assert_equals( list(range(180,240)), interval[_time(180)] )
interval = self.series.get( ['test1','test2'], 'hour', timestamp=_time(100), condensed=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240)),
interval[_time(0)] )
# with transforms
interval = self.series.get( ['test1','test2'], 'hour', timestamp=_time(100), transform='count' )
assert_equals( 120, interval[_time(60)] )
interval = self.series.get( ['test1','test2'], 'hour', timestamp=_time(100), transform=['min','max','count'], condensed=True )
assert_equals( {'min':1, 'max':239, 'count':358}, interval[_time(0)] )
def test_iterate(self):
self.series.insert('test', 32, timestamp=_time(0))
self.series.insert('test', 42, timestamp=_time(60))
self.series.insert('test', 52, timestamp=_time(600))
# There should be a result for every possible step between first and last
res = list(self.series.iterate('test', 'minute'))
assert_equals(11, len(res))
assert_equals((_time(0), [32]), res[0])
assert_equals((_time(60), [42]), res[1])
assert_equals((_time(120), []), res[2])
assert_equals((_time(600), [52]), res[-1])
# With resolutions, there should be a result only for where there's data
res = list(self.series.iterate('test', 'hour'))
assert_equals(3, len(res))
assert_equals((_time(0), [32]), res[0])
assert_equals((_time(60), [42]), res[1])
assert_equals((_time(600), [52]), res[2])
# Without resolutions, there should be a single result
res = list(self.series.iterate('test', 'bulk-hour'))
assert_equals(1, len(res))
assert_equals((_time(0), [32, 42, 52]), res[0])
self.series.delete('test')
def test_get_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
for t in xrange(1, 120):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(3600, 3720):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(120, 240):
self.series.insert( 'test1', t, timestamp=_time(t) )
for t in xrange(3721, 3840):
self.series.insert( 'test1', t, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
# interval with 2 series worth of data
interval = self.series.get( ['test1','test2'], 'minute', timestamp=_time(100) )
assert_equals( [_time(60)], interval.keys() )
assert_equals( 119, interval[_time(60)] )
# interval with 1 series worth of data
interval = self.series.get( ['test1','test2'], 'minute', timestamp=_time(122) )
assert_equals( [_time(120)], interval.keys() )
assert_equals( 179, interval[_time(120)] )
# no matching interval, returns no with empty value list
interval = self.series.get( ['test1','test2'], 'minute' )
assert_equals( 1, len(interval) )
assert_equals( None, interval.values()[0] )
###
### with resolution, optionally condensed
###
interval = self.series.get( ['test1','test2'], 'hour', timestamp=_time(100) )
assert_equals( map(_time,[0,60,120,180]), interval.keys() )
assert_equals( 59, interval[_time(0)] )
assert_equals( 119, interval[_time(60)] )
assert_equals( 179, interval[_time(120)] )
assert_equals( 239, interval[_time(180)] )
interval = self.series.get( ['test1','test2'], 'hour', timestamp=_time(100), condensed=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( 239, interval[_time(0)] )
def test_bulk_insert_intervals_before(self):
a,b,c,d,e,f = 10,11,12,13,14,15
inserts = OrderedDict( (
(None , { 'test1':[1,2,3], 'test2':[4,5,6] } ),
(_time(0) , { 'test1':[1,2,3], 'test2':[4,5,6], 'test3':[7,8,9] } ),
(_time(30), { 'test1':[1,2,3], 'test2':[4,5,6] } ),
(_time(60), { 'test1':[a,b,c], 'test3':[d,e,f] })
) )
self.series.bulk_insert( inserts, intervals=-3 )
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals( {1:2, 2:2, 3:2, a:1, b:1, c:1}, t1_i1[_time(0)] )
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals( {4:2, 5:2, 6:2}, t2_i1[_time(0)] )
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals( {7:1, 8:1, 9:1, d:1, e:1, f:1}, t3_i1[_time(0)] )
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(-60))
assert_equals( {1:2, 2:2, 3:2, a:1, b:1, c:1}, t1_i2[_time(-60)] )
t3_i3 = self.series.get('test3', 'minute', timestamp=_time(-120))
assert_equals( {7:1, 8:1, 9:1, d:1, e:1, f:1}, t3_i3[_time(-120)] )
t3_i4 = self.series.get('test3', 'minute', timestamp=_time(-180))
assert_equals( {7:1, 8:1, 9:1}, t3_i4[_time(-180)] )
def test_series(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert( 'test', t/2, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( 'test', 'minute', end=_time(250) )
assert_equals( map(_time, [0,60,120,180,240]), interval.keys() )
assert_equals( list(range(0,30)), sorted(interval[_time(0)].keys()) )
assert_equals( 1, interval[_time(0)][0] )
for k in xrange(1,30):
assert_equals(2, interval[_time(0)][k])
assert_equals( list(range(120,150)), sorted(interval[_time(240)].keys()) )
for k in xrange(120,150):
assert_equals(2, interval[_time(240)][k])
interval = self.series.series( 'test', 'minute', steps=2, end=_time(250) )
assert_equals( map(_time, [180,240]), interval.keys() )
assert_equals( list(range(120,150)), sorted(interval[_time(240)].keys()) )
# with collapsed
interval = self.series.series( 'test', 'minute', end=_time(250), collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( list(range(0,150)), sorted(interval[_time(0)].keys()) )
for k in xrange(1,150):
assert_equals(2, interval[_time(0)][k])
###
### with resolution
###
interval = self.series.series( 'test', 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( 60, len(interval[_time(0)]) )
assert_equals( list(range(0,30)), sorted(interval[_time(0)][_time(0)].keys()) )
# single step, last one
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200) )
assert_equals( 1, len(interval) )
assert_equals( 1800, len(interval[_time(3600)]) )
assert_equals( list(range(1800,3600)), sorted(interval[_time(3600)].keys()) )
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2 )
assert_equals( map(_time, [0,3600]), interval.keys() )
assert_equals( 1800, len(interval[_time(0)]) )
assert_equals( 1800, len(interval[_time(3600)]) )
assert_equals( list(range(1800,3600)), sorted(interval[_time(3600)].keys()) )
# with collapsed
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( 3600, len(interval[_time(0)]) )
assert_equals( list(range(0,3600)), sorted(interval[_time(0)].keys()) )
def test_series_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
for t in xrange(1, 120):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
self.series.insert( 'test2', t/15, timestamp=_time(t) )
for t in xrange(3600, 3720):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
self.series.insert( 'test2', t/15, timestamp=_time(t) )
for t in xrange(120, 240):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
for t in xrange(3720, 3840):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250) )
assert_equals( map(_time,[0,60,120,180,240]), interval.keys() )
assert_equals( set([0,1,2,3]), interval[_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
assert_equals( set([8,9,10,11]), interval[_time(120)] )
assert_equals( set([12,13,14,15]), interval[_time(180)] )
assert_equals( set(), interval[_time(240)] )
# no matching interval, returns no with empty value list
interval = self.series.series( ['test1','test2'], 'minute', start=time.time(), steps=2 )
assert_equals( 2, len(interval) )
assert_equals( set(), interval.values()[0] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250), collapse=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( set(range(0,16)), interval[_time(0)] )
###
### with resolution, optionally condensed
###
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( map(_time,[0,60,120,180]), interval[_time(0)].keys() )
assert_equals( 4, len(interval[_time(0)]) )
assert_equals( set([0,1,2,3]), interval[_time(0)][_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(0)][_time(60)] )
assert_equals( set([8,9,10,11]), interval[_time(0)][_time(120)] )
assert_equals( set([12,13,14,15]), interval[_time(0)][_time(180)] )
# condensed
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250), condensed=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( set(range(0,16)), interval[_time(0)] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( set(range(0,16)) | set(range(240,256)), interval[_time(0)] )
def test_series(self):
# 2 hours worth of data. Trim some bits from data resolution to assert
# proper set behavior
for t in xrange(1, 7200):
self.series.insert( 'test', t/15, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( 'test', 'minute', end=_time(250) )
assert_equals( map(_time, [0,60,120,180,240]), interval.keys() )
assert_equals( set([0,1,2,3]), interval[_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
interval = self.series.series( 'test', 'minute', steps=2, end=_time(250) )
assert_equals( map(_time, [180,240]), interval.keys() )
assert_equals( set([16,17,18,19]), interval[_time(240)] )
# with collapse
interval = self.series.series( 'test', 'minute', end=_time(250), collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( set(range(0,20)), interval[_time(0)] )
###
### with resolution
###
interval = self.series.series( 'test', 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( 60, len(interval[_time(0)]) )
assert_equals( set([0,1,2,3]), interval[_time(0)][_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(0)][_time(60)] )
# single step, last one
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200) )
assert_equals( 1, len(interval) )
assert_equals( set(range(240,480)), interval[_time(3600)] )
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2 )
assert_equals( map(_time, [0,3600]), interval.keys() )
assert_equals( set(range(0,240)), interval[_time(0)] )
assert_equals( set(range(240,480)), interval[_time(3600)] )
# with collapse
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( set(range(0,480)), interval[_time(0)] )
def test_get_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
for t in xrange(1, 120):
self.series.insert('test1', t, timestamp=_time(t))
self.series.insert('test2', t, timestamp=_time(t))
for t in xrange(3600, 3720):
self.series.insert('test1', t, timestamp=_time(t))
self.series.insert('test2', t, timestamp=_time(t))
for t in xrange(120, 240):
self.series.insert('test1', t, timestamp=_time(t))
for t in xrange(3721, 3840):
self.series.insert('test1', t, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
# interval with 2 series worth of data
interval = self.series.get(['test1', 'test2'],
'minute',
timestamp=_time(100))
assert_equals([_time(60)], interval.keys())
assert_equals(119, interval[_time(60)])
# interval with 1 series worth of data
interval = self.series.get(['test1', 'test2'],
'minute',
timestamp=_time(122))
assert_equals([_time(120)], interval.keys())
assert_equals(179, interval[_time(120)])
# no matching interval, returns no with empty value list
interval = self.series.get(['test1', 'test2'], 'minute')
assert_equals(1, len(interval))
assert_equals(None, interval.values()[0])
###
### with resolution, optionally condensed
###
interval = self.series.get(['test1', 'test2'],
'hour',
timestamp=_time(100))
assert_equals(map(_time, [0, 60, 120, 180]), interval.keys())
assert_equals(59, interval[_time(0)])
assert_equals(119, interval[_time(60)])
assert_equals(179, interval[_time(120)])
assert_equals(239, interval[_time(180)])
interval = self.series.get(['test1', 'test2'],
'hour',
timestamp=_time(100),
condensed=True)
assert_equals([_time(0)], interval.keys())
assert_equals(239, interval[_time(0)])
def test_series(self):
# 2 hours worth of data
for t in xrange(1, 7200):
self.series.insert('test', 1, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
interval = self.series.series('test', 'minute', end=_time(250))
assert_equals(map(_time, [0, 60, 120, 180, 240]), interval.keys())
assert_equals(59, interval[_time(0)])
assert_equals(60, interval[_time(60)])
interval = self.series.series('test',
'minute',
steps=2,
end=_time(250))
assert_equals(map(_time, [180, 240]), interval.keys())
assert_equals(60, interval[_time(240)])
# with collapse
interval = self.series.series('test',
'minute',
end=_time(250),
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals(299, interval[_time(0)])
###
### with resolution
###
interval = self.series.series('test', 'hour', end=_time(250))
assert_equals(1, len(interval))
assert_equals(60, len(interval[_time(0)]))
assert_equals(59, interval[_time(0)][_time(0)])
assert_equals(60, interval[_time(0)][_time(60)])
# single step, last one
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200))
assert_equals(1, len(interval))
assert_equals(3600, interval[_time(3600)])
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
steps=2)
assert_equals(map(_time, [0, 3600]), interval.keys())
assert_equals(3599, interval[_time(0)])
assert_equals(3600, interval[_time(3600)])
# with collapse
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
steps=2,
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals(7199, interval[_time(0)])
def test_series(self):
# 2 hours worth of data
for t in xrange(1, 7200):
self.series.insert( 'test', t, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( 'test', 'minute', end=_time(250) )
assert_equals( map(_time, [0,60,120,180,240]), interval.keys() )
assert_equals( 59, interval[_time(0)] )
assert_equals( 119, interval[_time(60)] )
interval = self.series.series( 'test', 'minute', steps=2, end=_time(250) )
assert_equals( map(_time, [180,240]), interval.keys() )
assert_equals( 299, interval[_time(240)] )
# with collapse
interval = self.series.series( 'test', 'minute', end=_time(250), collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( 299, interval[_time(0)] )
###
### with resolution
###
interval = self.series.series( 'test', 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( 60, len(interval[_time(0)]) )
assert_equals( 59, interval[_time(0)][_time(0)] )
assert_equals( 119, interval[_time(0)][_time(60)] )
# single step, last one
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200) )
assert_equals( 1, len(interval) )
assert_equals( 7199, interval[_time(3600)] )
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2 )
assert_equals( map(_time, [0,3600]), interval.keys() )
assert_equals( 3599, interval[_time(0)] )
assert_equals( 7199, interval[_time(3600)] )
# with collapse
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( 7199, interval[_time(0)] )
def test_series_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
self.series.delete('test1')
self.series.delete('test2')
for t in xrange(1, 120):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
self.series.insert( 'test2', t/15, timestamp=_time(t) )
for t in xrange(3600, 3720):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
self.series.insert( 'test2', t/15, timestamp=_time(t) )
for t in xrange(120, 240):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
for t in xrange(3720, 3840):
self.series.insert( 'test1', t/15, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250) )
assert_equals( map(_time,[0,60,120,180,240]), interval.keys() )
assert_equals( set([1,2,3]), interval[_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
assert_equals( set([8,9,10,11]), interval[_time(120)] )
assert_equals( set([12,13,14,15]), interval[_time(180)] )
assert_equals( set(), interval[_time(240)] )
# no matching interval, returns no with empty value list
interval = self.series.series( ['test1','test2'], 'minute', start=time.time(), steps=2 )
assert_equals( 2, len(interval) )
assert_equals( set(), interval.values()[0] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250), collapse=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( set(range(1,16)), interval[_time(0)] )
###
### with resolution, optionally condensed
###
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( map(_time,[0,60,120,180]), interval[_time(0)].keys() )
assert_equals( 4, len(interval[_time(0)]) )
assert_equals( set([1,2,3]), interval[_time(0)][_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(0)][_time(60)] )
assert_equals( set([8,9,10,11]), interval[_time(0)][_time(120)] )
assert_equals( set([12,13,14,15]), interval[_time(0)][_time(180)] )
# condensed
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250), condensed=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( set(range(1,16)), interval[_time(0)] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( set(range(1,16)) | set(range(240,256)), interval[_time(0)] )
def test_get(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert('test', t, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get('test', 'minute', timestamp=_time(100))
assert_equals([_time(60)], interval.keys())
assert_equals(list(range(60, 120)), interval[_time(60)])
# end of an interval
interval = self.series.get('test', 'minute', timestamp=_time(59))
assert_equals([_time(0)], interval.keys())
assert_equals(list(range(1, 60)), interval[_time(0)])
# no matching interval, returns no with empty value list
interval = self.series.get('test', 'minute')
assert_equals(1, len(interval))
assert_equals(0, len(interval.values()[0]))
# with transforms
interval = self.series.get('test',
'minute',
timestamp=_time(100),
transform='count')
assert_equals(60, interval[_time(60)])
interval = self.series.get('test',
'minute',
timestamp=_time(100),
transform=['min', 'max'])
assert_equals({'min': 60, 'max': 119}, interval[_time(60)])
###
### with resolution, optionally condensed
###
interval = self.series.get('test', 'hour', timestamp=_time(100))
assert_equals(60, len(interval))
assert_equals(list(range(60, 120)), interval[_time(60)])
interval = self.series.get('test',
'hour',
timestamp=_time(100),
condensed=True)
assert_equals(1, len(interval))
assert_equals(list(range(1, 3600)), interval[_time(0)])
# with transforms
interval = self.series.get('test',
'hour',
timestamp=_time(100),
transform='count')
assert_equals(60, interval[_time(60)])
interval = self.series.get('test',
'hour',
timestamp=_time(100),
transform=['min', 'max'],
condensed=True)
assert_equals({'min': 1, 'max': 3599}, interval[_time(0)])
def test_series(self):
# 2 hours worth of data. Trim some bits from data resolution to assert
# proper set behavior
for t in xrange(1, 7200):
self.series.insert( 'test', t/15, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( 'test', 'minute', end=_time(250) )
assert_equals( map(_time, [0,60,120,180,240]), interval.keys() )
assert_equals( set([1,2,3]), interval[_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(60)] )
interval = self.series.series( 'test', 'minute', steps=2, end=_time(250) )
assert_equals( map(_time, [180,240]), interval.keys() )
assert_equals( set([16,17,18,19]), interval[_time(240)] )
# with collapse
interval = self.series.series( 'test', 'minute', end=_time(250), collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( set(range(1,20)), interval[_time(0)] )
###
### with resolution
###
interval = self.series.series( 'test', 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( 60, len(interval[_time(0)]) )
assert_equals( set([1,2,3]), interval[_time(0)][_time(0)] )
assert_equals( set([4,5,6,7]), interval[_time(0)][_time(60)] )
# single step, last one
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200) )
assert_equals( 1, len(interval) )
assert_equals( set(range(240,480)), interval[_time(3600)] )
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2 )
assert_equals( map(_time, [0,3600]), interval.keys() )
assert_equals( set(range(1,240)), interval[_time(0)] )
assert_equals( set(range(240,480)), interval[_time(3600)] )
# with collapse
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( set(range(1,480)), interval[_time(0)] )
def test_bulk_insert(self):
inserts = {
None: {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
},
_time(0): {
'test1': [1, 2, 3],
'test2': [4, 5, 6],
'test3': [7, 8, 9]
},
_time(30): {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
},
_time(60): {
'test1': [1, 2, 3],
'test3': [7, 8, 9]
}
}
self.series.bulk_insert(inserts)
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals([1, 2, 3, 1, 2, 3], t1_i1[_time(0)])
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals([4, 5, 6, 4, 5, 6], t2_i1[_time(0)])
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals([7, 8, 9], t3_i1[_time(0)])
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(60))
assert_equals([1, 2, 3], t1_i2[_time(60)])
def test_series(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert( 'test', t, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( 'test', 'minute', end=_time(250) )
assert_equals( map(_time,[0,60,120,180,240]), interval.keys() )
assert_equals( list(range(1,60)), interval[_time(0)] )
assert_equals( list(range(240,300)), interval[_time(240)] )
interval = self.series.series( 'test', 'minute', steps=2, end=_time(250) )
assert_equals( map(_time,[180,240]), interval.keys() )
assert_equals( list(range(240,300)), interval[_time(240)] )
# with transforms
interval = self.series.series( 'test', 'minute', end=_time(250), transform=['min','count'] )
assert_equals( map(_time,[0,60,120,180,240]), interval.keys() )
assert_equals( {'min':1, 'count':59}, interval[_time(0)] )
assert_equals( {'min':240, 'count':60}, interval[_time(240)] )
# with collapsed
interval = self.series.series( 'test', 'minute', end=_time(250), collapse=True )
assert_equals( map(_time,[0]), interval.keys() )
assert_equals( list(range(1,300)), interval[_time(0)] )
# with transforms and collapsed
interval = self.series.series( 'test', 'minute', end=_time(250), transform=['min','count'], collapse=True )
assert_equals( map(_time,[0]), interval.keys() )
assert_equals( {'min':1, 'count':299}, interval[_time(0)] )
###
### with resolution
###
interval = self.series.series( 'test', 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( 60, len(interval[_time(0)]) )
assert_equals( list(range(1,60)), interval[_time(0)][_time(0)] )
interval = self.series.series( 'test', 'hour', end=_time(250), transform=['count','max'] )
assert_equals( 1, len(interval) )
assert_equals( 60, len(interval[_time(0)]) )
assert_equals( {'max':59, 'count':59}, interval[_time(0)][_time(0)] )
# single step, last one
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200) )
assert_equals( 1, len(interval) )
assert_equals( 3600, len(interval[_time(3600)]) )
assert_equals( list(range(3600,7200)), interval[_time(3600)] )
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2 )
assert_equals( map(_time, [0,3600]), interval.keys() )
assert_equals( 3599, len(interval[_time(0)]) )
assert_equals( 3600, len(interval[_time(3600)]) )
assert_equals( list(range(3600,7200)), interval[_time(3600)] )
# with transforms
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), transform=['min','max'] )
assert_equals( 1, len(interval) )
assert_equals( {'min':3600, 'max':7199}, interval[_time(3600)] )
# with collapsed
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( 7199, len(interval[_time(0)]) )
assert_equals( list(range(1,7200)), interval[_time(0)] )
# with transforms and collapsed
interval = self.series.series( 'test', 'hour', condensed=True, end=_time(4200), steps=2, collapse=True, transform=['min','count','max'] )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals( {'min':1, 'max':7199, 'count':7199}, interval[_time(0)] )
def test_get(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert( 'test', t, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
# middle of an interval
interval = self.series.get( 'test', 'minute', timestamp=_time(100) )
assert_equals( [_time(60)], interval.keys() )
assert_equals( list(range(60,120)), interval[_time(60)] )
# end of an interval
interval = self.series.get( 'test', 'minute', timestamp=_time(59) )
assert_equals( [_time(0)], interval.keys() )
assert_equals( list(range(1,60)), interval[_time(0)] )
# no matching interval, returns no with empty value list
interval = self.series.get( 'test', 'minute' )
assert_equals( 1, len(interval) )
assert_equals( 0, len(interval.values()[0]) )
# with transforms
interval = self.series.get( 'test', 'minute', timestamp=_time(100), transform='count' )
assert_equals( 60, interval[_time(60)] )
interval = self.series.get( 'test', 'minute', timestamp=_time(100), transform=['min','max'] )
assert_equals( {'min':60, 'max':119}, interval[_time(60)] )
###
### with resolution, optionally condensed
###
interval = self.series.get( 'test', 'hour', timestamp=_time(100) )
assert_equals( 60, len(interval) )
assert_equals( list(range(60,120)), interval[_time(60)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(100), condensed=True )
assert_equals( 1, len(interval) )
assert_equals( list(range(1,3600)), interval[_time(0)] )
# with transforms
interval = self.series.get( 'test', 'hour', timestamp=_time(100), transform='count' )
assert_equals( 60, interval[_time(60)] )
interval = self.series.get( 'test', 'hour', timestamp=_time(100), transform=['min','max'], condensed=True )
assert_equals( {'min':1, 'max':3599}, interval[_time(0)] )
def test_series_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
self.series.delete('test1')
self.series.delete('test2')
for t in xrange(1, 120):
self.series.insert('test1', t, timestamp=_time(t))
self.series.insert('test2', t, timestamp=_time(t))
for t in xrange(3600, 3720):
self.series.insert('test1', t, timestamp=_time(t))
self.series.insert('test2', t, timestamp=_time(t))
for t in xrange(120, 240):
self.series.insert('test1', t, timestamp=_time(t))
for t in xrange(3720, 3840):
self.series.insert('test1', t, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
interval = self.series.series(['test1', 'test2'],
'minute',
end=_time(250))
assert_equals(map(_time, [0, 60, 120, 180, 240]), interval.keys())
assert_equals(
list(range(1, 60)) + list(range(1, 60)), interval[_time(0)])
assert_equals(
list(range(60, 120)) + list(range(60, 120)), interval[_time(60)])
assert_equals(list(range(120, 180)), interval[_time(120)])
assert_equals(list(range(180, 240)), interval[_time(180)])
assert_equals([], interval[_time(240)])
# no matching interval, returns no with empty value list
interval = self.series.series(['test1', 'test2'],
'minute',
start=time.time(),
steps=2)
assert_equals(2, len(interval))
assert_equals([], interval.values()[0])
# with transforms
interval = self.series.series(['test1', 'test2'],
'minute',
end=_time(250),
transform=['min', 'count'])
assert_equals(map(_time, [0, 60, 120, 180, 240]), interval.keys())
assert_equals({'min': 1, 'count': 118}, interval[_time(0)])
assert_equals({'min': 60, 'count': 120}, interval[_time(60)])
assert_equals({'min': 120, 'count': 60}, interval[_time(120)])
assert_equals({'min': 180, 'count': 60}, interval[_time(180)])
assert_equals({'min': 0, 'count': 0}, interval[_time(240)])
# with collapsed
interval = self.series.series(['test1', 'test2'],
'minute',
end=_time(250),
collapse=True)
assert_equals([_time(0)], interval.keys())
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240)),
interval[_time(0)] )
# with tranforms and collapsed
interval = self.series.series(['test1', 'test2'],
'minute',
end=_time(250),
transform=['min', 'max', 'count'],
collapse=True)
assert_equals([_time(0)], interval.keys())
assert_equals({'min': 1, 'max': 239, 'count': 358}, interval[_time(0)])
###
### with resolution, optionally condensed
###
interval = self.series.series(['test1', 'test2'],
'hour',
end=_time(250))
assert_equals(1, len(interval))
assert_equals(map(_time, [0, 60, 120, 180]), interval[_time(0)].keys())
assert_equals(4, len(interval[_time(0)]))
assert_equals(
list(range(1, 60)) + list(range(1, 60)),
interval[_time(0)][_time(0)])
assert_equals(
list(range(60, 120)) + list(range(60, 120)),
interval[_time(0)][_time(60)])
assert_equals(list(range(120, 180)), interval[_time(0)][_time(120)])
assert_equals(list(range(180, 240)), interval[_time(0)][_time(180)])
# condensed
interval = self.series.series(['test1', 'test2'],
'hour',
end=_time(250),
condensed=True)
assert_equals([_time(0)], interval.keys())
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240)),
interval[_time(0)] )
# with collapsed
interval = self.series.series(['test1', 'test2'],
'hour',
condensed=True,
end=_time(4200),
steps=2,
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240))+\
list(range(3600,3660))+list(range(3600,3660))+list(range(3660,3720))+list(range(3660,3720))+\
list(range(3720,3780))+list(range(3780,3840)),
interval[_time(0)] )
# with transforms collapsed
interval = self.series.series(['test1', 'test2'],
'hour',
condensed=True,
end=_time(4200),
steps=2,
collapse=True,
transform=['min', 'max', 'count'])
assert_equals(map(_time, [0]), interval.keys())
assert_equals({
'min': 1,
'max': 3839,
'count': 718
}, interval[_time(0)])
def test_bulk_insert_intervals_before(self):
a, b, c, d, e, f = 10, 11, 12, 13, 14, 15
inserts = OrderedDict(((None, {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
}), (_time(0), {
'test1': [1, 2, 3],
'test2': [4, 5, 6],
'test3': [7, 8, 9]
}), (_time(30), {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
}), (_time(60), {
'test1': [a, b, c],
'test3': [d, e, f]
})))
self.series.bulk_insert(inserts, intervals=-3)
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals(1 + 2 + 3 + 1 + 2 + 3 + a + b + c, t1_i1[_time(0)])
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals(4 + 5 + 6 + 4 + 5 + 6, t2_i1[_time(0)])
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals(7 + 8 + 9 + d + e + f, t3_i1[_time(0)])
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(-60))
assert_equals(1 + 2 + 3 + 1 + 2 + 3 + a + b + c, t1_i2[_time(-60)])
t3_i3 = self.series.get('test3', 'minute', timestamp=_time(-120))
assert_equals(7 + 8 + 9 + d + e + f, t3_i3[_time(-120)])
t3_i4 = self.series.get('test3', 'minute', timestamp=_time(-180))
assert_equals(7 + 8 + 9, t3_i4[_time(-180)])
def test_series(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert('test', t / 2, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
interval = self.series.series('test', 'minute', end=_time(250))
assert_equals(map(_time, [0, 60, 120, 180, 240]), interval.keys())
assert_equals(list(range(0, 30)), sorted(interval[_time(0)].keys()))
assert_equals(1, interval[_time(0)][0])
for k in xrange(1, 30):
assert_equals(2, interval[_time(0)][k])
assert_equals(list(range(120, 150)),
sorted(interval[_time(240)].keys()))
for k in xrange(120, 150):
assert_equals(2, interval[_time(240)][k])
interval = self.series.series('test',
'minute',
steps=2,
end=_time(250))
assert_equals(map(_time, [180, 240]), interval.keys())
assert_equals(list(range(120, 150)),
sorted(interval[_time(240)].keys()))
# with collapsed
interval = self.series.series('test',
'minute',
end=_time(250),
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals(list(range(0, 150)), sorted(interval[_time(0)].keys()))
for k in xrange(1, 150):
assert_equals(2, interval[_time(0)][k])
###
### with resolution
###
interval = self.series.series('test', 'hour', end=_time(250))
assert_equals(1, len(interval))
assert_equals(60, len(interval[_time(0)]))
assert_equals(list(range(0, 30)),
sorted(interval[_time(0)][_time(0)].keys()))
# single step, last one
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200))
assert_equals(1, len(interval))
assert_equals(1800, len(interval[_time(3600)]))
assert_equals(list(range(1800, 3600)),
sorted(interval[_time(3600)].keys()))
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
steps=2)
assert_equals(map(_time, [0, 3600]), interval.keys())
assert_equals(1800, len(interval[_time(0)]))
assert_equals(1800, len(interval[_time(3600)]))
assert_equals(list(range(1800, 3600)),
sorted(interval[_time(3600)].keys()))
# with collapsed
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
steps=2,
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals(3600, len(interval[_time(0)]))
assert_equals(list(range(0, 3600)), sorted(interval[_time(0)].keys()))
def test_iterate(self):
self.series.insert( 'test', 32, timestamp=_time(0) )
self.series.insert( 'test', 42, timestamp=_time(60) )
self.series.insert( 'test', 52, timestamp=_time(600) )
# There should be a result for every possible step between first and last
res = list(self.series.iterate('test','minute'))
assert_equals( 11, len(res) )
assert_equals( (_time(0),[32]), res[0] )
assert_equals( (_time(60),[42]), res[1] )
assert_equals( (_time(120),[]), res[2] )
assert_equals( (_time(600),[52]), res[-1] )
# With resolutions, there should be a result only for where there's data
res = list(self.series.iterate('test','hour'))
assert_equals( 3, len(res) )
assert_equals( (_time(0),[32]), res[0] )
assert_equals( (_time(60),[42]), res[1] )
assert_equals( (_time(600),[52]), res[2] )
# Without resolutions, there should be a single result
res = list(self.series.iterate('test','bulk-hour'))
assert_equals( 1, len(res) )
assert_equals( (_time(0),[32,42,52]), res[0] )
self.series.delete('test')
def test_get_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
self.series.delete('test1')
self.series.delete('test2')
for t in xrange(1, 120):
self.series.insert('test1', t, timestamp=_time(t))
self.series.insert('test2', t, timestamp=_time(t))
for t in xrange(3600, 3720):
self.series.insert('test1', t, timestamp=_time(t))
self.series.insert('test2', t, timestamp=_time(t))
for t in xrange(120, 240):
self.series.insert('test1', t, timestamp=_time(t))
for t in xrange(3721, 3840):
self.series.insert('test1', t, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
# interval with 2 series worth of data
interval = self.series.get(['test1', 'test2'],
'minute',
timestamp=_time(100))
assert_equals([_time(60)], interval.keys())
assert_equals(
list(range(60, 120)) + list(range(60, 120)), interval[_time(60)])
# interval with 1 series worth of data
interval = self.series.get(['test1', 'test2'],
'minute',
timestamp=_time(122))
assert_equals([_time(120)], interval.keys())
assert_equals(list(range(120, 180)), interval[_time(120)])
# no matching interval, returns no with empty value list
interval = self.series.get(['test1', 'test2'], 'minute')
assert_equals(1, len(interval))
assert_equals(0, len(interval.values()[0]))
###
### with resolution, optionally condensed
###
interval = self.series.get(['test1', 'test2'],
'hour',
timestamp=_time(100))
assert_equals(map(_time, [0, 60, 120, 180]), interval.keys())
assert_equals(
list(range(1, 60)) + list(range(1, 60)), interval[_time(0)])
assert_equals(
list(range(60, 120)) + list(range(60, 120)), interval[_time(60)])
assert_equals(list(range(120, 180)), interval[_time(120)])
assert_equals(list(range(180, 240)), interval[_time(180)])
interval = self.series.get(['test1', 'test2'],
'hour',
timestamp=_time(100),
condensed=True)
assert_equals([_time(0)], interval.keys())
assert_equals(
list(range(1,60))+list(range(1,60))+list(range(60,120))+list(range(60,120))+\
list(range(120,180))+list(range(180,240)),
interval[_time(0)] )
# with transforms
interval = self.series.get(['test1', 'test2'],
'hour',
timestamp=_time(100),
transform='count')
assert_equals(120, interval[_time(60)])
interval = self.series.get(['test1', 'test2'],
'hour',
timestamp=_time(100),
transform=['min', 'max', 'count'],
condensed=True)
assert_equals({'min': 1, 'max': 239, 'count': 358}, interval[_time(0)])
def test_bulk_insert(self):
inserts = {
None: {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
},
_time(0): {
'test1': [1, 2, 3],
'test2': [4, 5, 6],
'test3': [7, 8, 9]
},
_time(30): {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
},
_time(60): {
'test1': [1, 2, 3],
'test3': [7, 8, 9]
}
}
self.series.bulk_insert(inserts)
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals({1: 2, 2: 2, 3: 2}, t1_i1[_time(0)])
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals({4: 2, 5: 2, 6: 2}, t2_i1[_time(0)])
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals({7: 1, 8: 1, 9: 1}, t3_i1[_time(0)])
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(60))
assert_equals({1: 1, 2: 1, 3: 1}, t1_i2[_time(60)])
def test_series(self):
# 2 hours worth of data, value is same asV timestamp
for t in xrange(1, 7200):
self.series.insert('test', t, timestamp=_time(t))
###
### no resolution, condensed has no impact
###
interval = self.series.series('test', 'minute', end=_time(250))
assert_equals(map(_time, [0, 60, 120, 180, 240]), interval.keys())
assert_equals(list(range(1, 60)), interval[_time(0)])
assert_equals(list(range(240, 300)), interval[_time(240)])
interval = self.series.series('test',
'minute',
steps=2,
end=_time(250))
assert_equals(map(_time, [180, 240]), interval.keys())
assert_equals(list(range(240, 300)), interval[_time(240)])
# with transforms
interval = self.series.series('test',
'minute',
end=_time(250),
transform=['min', 'count'])
assert_equals(map(_time, [0, 60, 120, 180, 240]), interval.keys())
assert_equals({'min': 1, 'count': 59}, interval[_time(0)])
assert_equals({'min': 240, 'count': 60}, interval[_time(240)])
# with collapsed
interval = self.series.series('test',
'minute',
end=_time(250),
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals(list(range(1, 300)), interval[_time(0)])
# with transforms and collapsed
interval = self.series.series('test',
'minute',
end=_time(250),
transform=['min', 'count'],
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals({'min': 1, 'count': 299}, interval[_time(0)])
###
### with resolution
###
interval = self.series.series('test', 'hour', end=_time(250))
assert_equals(1, len(interval))
assert_equals(60, len(interval[_time(0)]))
assert_equals(list(range(1, 60)), interval[_time(0)][_time(0)])
interval = self.series.series('test',
'hour',
end=_time(250),
transform=['count', 'max'])
assert_equals(1, len(interval))
assert_equals(60, len(interval[_time(0)]))
assert_equals({'max': 59, 'count': 59}, interval[_time(0)][_time(0)])
# single step, last one
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200))
assert_equals(1, len(interval))
assert_equals(3600, len(interval[_time(3600)]))
assert_equals(list(range(3600, 7200)), interval[_time(3600)])
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
steps=2)
assert_equals(map(_time, [0, 3600]), interval.keys())
assert_equals(3599, len(interval[_time(0)]))
assert_equals(3600, len(interval[_time(3600)]))
assert_equals(list(range(3600, 7200)), interval[_time(3600)])
# with transforms
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
transform=['min', 'max'])
assert_equals(1, len(interval))
assert_equals({'min': 3600, 'max': 7199}, interval[_time(3600)])
# with collapsed
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
steps=2,
collapse=True)
assert_equals(map(_time, [0]), interval.keys())
assert_equals(7199, len(interval[_time(0)]))
assert_equals(list(range(1, 7200)), interval[_time(0)])
# with transforms and collapsed
interval = self.series.series('test',
'hour',
condensed=True,
end=_time(4200),
steps=2,
collapse=True,
transform=['min', 'count', 'max'])
assert_equals(map(_time, [0]), interval.keys())
assert_equals({
'min': 1,
'max': 7199,
'count': 7199
}, interval[_time(0)])
def test_bulk_insert_intervals_after(self):
a, b, c, d, e, f = 10, 11, 12, 13, 14, 15
inserts = OrderedDict(((None, {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
}), (_time(0), {
'test1': [1, 2, 3],
'test2': [4, 5, 6],
'test3': [7, 8, 9]
}), (_time(30), {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
}), (_time(60), {
'test1': [a, b, c],
'test3': [d, e, f]
})))
self.series.bulk_insert(inserts, intervals=3)
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals({1: 2, 2: 2, 3: 2}, t1_i1[_time(0)])
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals({4: 2, 5: 2, 6: 2}, t2_i1[_time(0)])
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals({7: 1, 8: 1, 9: 1}, t3_i1[_time(0)])
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(60))
assert_equals({1: 2, 2: 2, 3: 2, a: 1, b: 1, c: 1}, t1_i2[_time(60)])
t3_i3 = self.series.get('test3', 'minute', timestamp=_time(120))
assert_equals({7: 1, 8: 1, 9: 1, d: 1, e: 1, f: 1}, t3_i3[_time(120)])
t3_i4 = self.series.get('test3', 'minute', timestamp=_time(180))
assert_equals({7: 1, 8: 1, 9: 1, d: 1, e: 1, f: 1}, t3_i4[_time(180)])
def test_bulk_insert_intervals_after(self):
a, b, c, d, e, f = 10, 11, 12, 13, 14, 15
inserts = OrderedDict(((None, {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
}), (_time(0), {
'test1': [1, 2, 3],
'test2': [4, 5, 6],
'test3': [7, 8, 9]
}), (_time(30), {
'test1': [1, 2, 3],
'test2': [4, 5, 6]
}), (_time(60), {
'test1': [a, b, c],
'test3': [d, e, f]
})))
self.series.bulk_insert(inserts, intervals=3)
t1_i1 = self.series.get('test1', 'minute', timestamp=_time(0))
assert_equals([1, 2, 3, 1, 2, 3], t1_i1[_time(0)])
t2_i1 = self.series.get('test2', 'minute', timestamp=_time(0))
assert_equals([4, 5, 6, 4, 5, 6], t2_i1[_time(0)])
t3_i1 = self.series.get('test3', 'minute', timestamp=_time(0))
assert_equals([7, 8, 9], t3_i1[_time(0)])
t1_i2 = self.series.get('test1', 'minute', timestamp=_time(60))
assert_equals([1, 2, 3, 1, 2, 3, a, b, c], t1_i2[_time(60)])
t3_i3 = self.series.get('test3', 'minute', timestamp=_time(120))
assert_equals([7, 8, 9, d, e, f], t3_i3[_time(120)])
t3_i4 = self.series.get('test3', 'minute', timestamp=_time(180))
assert_equals([7, 8, 9, d, e, f], t3_i4[_time(180)])
def test_series_joined(self):
# put some data in the first minutes of each hour for test1, and then for
# a few more minutes in test2
for t in xrange(1, 120):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(3600, 3720):
self.series.insert( 'test1', t, timestamp=_time(t) )
self.series.insert( 'test2', t, timestamp=_time(t) )
for t in xrange(120, 240):
self.series.insert( 'test1', t, timestamp=_time(t) )
for t in xrange(3720, 3840):
self.series.insert( 'test1', t, timestamp=_time(t) )
###
### no resolution, condensed has no impact
###
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250) )
assert_equals( map(_time,[0,60,120,180,240]), interval.keys() )
assert_equals( 2*sum(range(1,60)), interval[_time(0)] )
assert_equals( 2*sum(range(60,120)), interval[_time(60)] )
assert_equals( sum(range(120,180)), interval[_time(120)] )
assert_equals( sum(range(180,240)), interval[_time(180)] )
assert_equals( 0, interval[_time(240)] )
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250), transform='rate' )
assert_equals( sum(range(120,180))/60.0, interval[_time(120)] )
# no matching interval, returns no with empty value list
interval = self.series.series( ['test1','test2'], 'minute', start=time.time(), steps=2 )
assert_equals( 2, len(interval) )
assert_equals( 0, interval.values()[0] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'minute', end=_time(250), collapse=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( 2*sum(range(1,120))+sum(range(120,240)), interval[_time(0)] )
###
### with resolution, optionally condensed
###
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250) )
assert_equals( 1, len(interval) )
assert_equals( map(_time,[0,60,120,180]), interval[_time(0)].keys() )
assert_equals( 4, len(interval[_time(0)]) )
assert_equals( 2*sum(range(1,60)), interval[_time(0)][_time(0)] )
assert_equals( 2*sum(range(60,120)), interval[_time(0)][_time(60)] )
assert_equals( sum(range(120,180)), interval[_time(0)][_time(120)] )
assert_equals( sum(range(180,240)), interval[_time(0)][_time(180)] )
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250), transform='rate' )
assert_equals( sum(range(180,240)) / 60.0, interval[_time(0)][_time(180)] )
# condensed
interval = self.series.series( ['test1','test2'], 'hour', end=_time(250), condensed=True )
assert_equals( [_time(0)], interval.keys() )
assert_equals( 2*sum(range(1,120))+sum(range(120,240)), interval[_time(0)] )
# with collapsed
interval = self.series.series( ['test1','test2'], 'hour', condensed=True, end=_time(4200), steps=2, collapse=True )
assert_equals( map(_time, [0]), interval.keys() )
assert_equals(
2*sum(range(1,120))+sum(range(120,240))+2*sum(range(3600,3720))+sum(range(3720,3840)),
interval[_time(0)] )
