def test_series_values_after_report_instance_deletion_multiple_days(self):
owner_id = uuid.uuid1()
r = reports.Report.insert(owner_id, 'rname')
sd_id = dataseries.SeriesDef.select_id_or_insert(
r.report_id, [],
dataseries.SeriesSpec(0, -1, {
'op': 'eq',
'args': ['0']
}))
sd = dataseries.SeriesDef.select(r.report_id, [], sd_id)
r.process_input('1', created=utcnow() - timedelta(days=10))
r.process_input('2', created=utcnow() - timedelta(days=5))
values = dataseries.get_series_values(sd, r,
utcnow() - timedelta(days=11),
utcnow())
self.assertEqual(2, len(values))
r.delete_single_instance(r.fetch_instances()[1].report_instance_id)
inst = r.fetch_instances()
self.assertEqual(1, len(inst))
self.assertEqual('1', inst[0].input_string)
sd = dataseries.SeriesDef.select(r.report_id, [], sd_id)
values = dataseries.get_series_values(sd, r,
utcnow() - timedelta(days=11),
utcnow())
self.assertEqual(1, len(values))
self.assertEqual(1, values[0].value)
def test_creating_ri_reversed_and_fetching_series_values_in_the_middle(
self):
owner_id = uuid.uuid1()
r = reports.Report.insert(owner_id, 'nums')
sd_id = dataseries.SeriesDef.insert(
r.report_id, [],
dataseries.SeriesSpec(0, -1, {
'op': 'eq',
'args': ['0']
}))
sd = dataseries.SeriesDef.select(r.report_id, [], sd_id)
for i in reversed(xrange(10, 20)):
r.process_input(str(i), created=utcnow() - timedelta(days=i))
expected = list(reversed(range(10, 20)))
values = [
sv.value for sv in dataseries.get_series_values(
sd, r,
utcnow() - timedelta(days=100), utcnow())
]
self.assertEqual(expected, values)
for i in reversed(xrange(0, 10)):
r.process_input(str(i), created=utcnow() - timedelta(days=i))
sd = dataseries.SeriesDef.select(r.report_id, [], sd_id)
expected = list(reversed(range(0, 20)))
values = [
sv.value for sv in dataseries.get_series_values(
sd, r,
utcnow() - timedelta(days=100), utcnow())
]
self.assertEqual(expected, values)
def _set_series_data(self,
data,
from_dt=None,
to_dt=None,
after=None,
limit=None):
data['series_data'] = []
series_def_list = dataseries.SeriesDef.select_multi(
self.tile.report_id,
[(self.tile.tags, sc['series_id'])
for sc in self.tile_options['series_configs']])
latest_instance_id = self.tile.report.fetch_latest_instance_id(
self.tile.tags)
for series_def, series_config in zip(
series_def_list, self.tile_options['series_configs']):
if not series_def:
log.warn(
'tile_data: series_def does not exist for report_id=%s series_config=%s',
self.tile.report_id, series_config)
continue
if from_dt is not None or to_dt is not None:
rows = dataseries.get_series_values(
series_def,
self.tile.report,
data['fetched_from_dt'],
data['fetched_to_dt'],
limit=limit or mqeconfig.MAX_SERIES_POINTS_IN_TILE,
latest_instance_id=latest_instance_id)
else:
assert after is not None
rows = dataseries.get_series_values_after(
series_def,
self.tile.report,
after,
limit or mqeconfig.MAX_SERIES_POINTS_IN_TILE,
latest_instance_id=latest_instance_id)
value_list = []
common_header = CommonValue()
for row in rows:
value_list.append(DataPoint.from_series_value(row))
if row.header:
common_header.present(row.header)
data['series_data'].append({
'series_id':
series_def.series_id,
'name':
series_def.series_spec.name(True),
'data_points':
value_list,
'common_header':
common_header.value,
})
def values(tags):
sd_id = dataseries.SeriesDef.select_id_or_insert(
cd.report.report_id, tags,
dataseries.guess_series_spec(cd.report, cd.instances[0], 0, 0))
sd = dataseries.SeriesDef.select(cd.report.report_id, tags, sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
return [sv.value for sv in res]
def test_same_dt(self):
owner_id = uuid.uuid1()
r = reports.Report.insert(owner_id, 'rname')
sd_id = dataseries.SeriesDef.select_id_or_insert(
r.report_id, [],
dataseries.SeriesSpec(0, -1, {
'op': 'eq',
'args': ['0']
}))
sd = dataseries.SeriesDef.select(r.report_id, [], sd_id)
for i in range(10):
r.process_input(str(i), created=datetime.datetime(2017, 5, 5))
values = dataseries.get_series_values(sd, r,
datetime.datetime(2017, 5, 1),
utcnow())
self.assertEqual(10, len(values))
self.assertEqual(set(range(10)), set([v.value for v in values]))
values = dataseries.get_series_values(sd, r,
datetime.datetime(2017, 5, 5),
utcnow())
self.assertEqual(10, len(values))
self.assertEqual(set(range(10)), set([v.value for v in values]))
values = dataseries.get_series_values(sd, r,
datetime.datetime(2017, 5, 5),
datetime.datetime(2017, 5, 5))
self.assertEqual(10, len(values))
self.assertEqual(set(range(10)), set([v.value for v in values]))
values = dataseries.get_series_values(
sd, r, datetime.datetime(2017, 5, 5, 0, 0, 0, 1),
datetime.datetime(2017, 5, 5, 0, 0, 0, 1))
self.assertEqual(0, len(values))
def test_get_series_values(self):
sd = self.test_series_def_select_or_insert()
res = dataseries.get_series_values(
sd,
report_data('points').report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual([210, 220, 265], [sv.value for sv in res])
self.assertEqual(['points', 'points', 'points'],
[sv.header for sv in res])
res = dataseries.get_series_values(
sd,
report_data('points').report, datetime.datetime.utcnow(),
datetime.datetime.utcnow() + datetime.timedelta(seconds=1), 1000)
self.assertEqual([], res)
res = dataseries.get_series_values(
sd,
report_data('points').report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 2)
self.assertEqual([220, 265], [sv.value for sv in res])
self.assertEqual(['points', 'points'], [sv.header for sv in res])
def test_get_series_values_multiple_inserts(self):
cd = CustomData(range(20))
sd_id = dataseries.SeriesDef.select_id_or_insert(
cd.report.report_id, [],
dataseries.guess_series_spec(cd.report, cd.instances[0], 0, 0))
sd = dataseries.SeriesDef.select(cd.report.report_id, [], sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual(range(20), [sv.value for sv in res])
cd.report.process_input('200')
sd = dataseries.SeriesDef.select(cd.report.report_id, [], sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual(range(20) + [200], [sv.value for sv in res])
cd.report.process_input('200')
sd = dataseries.SeriesDef.select(cd.report.report_id, [], sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual(range(20) + [200, 200], [sv.value for sv in res])
cd.report.process_input('80',
created=datetime.datetime.utcnow() -
datetime.timedelta(seconds=10))
sd = dataseries.SeriesDef.select(cd.report.report_id, [], sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual([80] + range(20) + [200, 200],
[sv.value for sv in res])
ri = cd.report.process_input('200').report_instance
sd = dataseries.SeriesDef.select(cd.report.report_id, [], sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual([80] + range(20) + [200, 200, 200],
[sv.value for sv in res])
cd.report.process_input('300',
created=ri.created -
datetime.timedelta(milliseconds=1))
sd = dataseries.SeriesDef.select(cd.report.report_id, [], sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual([80] + range(20) + [200, 200, 300, 200],
[sv.value for sv in res])
# tags
cd.report.process_input('400',
created=ri.created -
datetime.timedelta(milliseconds=2),
tags=['aaa'])
sd = dataseries.SeriesDef.select(cd.report.report_id, [], sd_id)
res = dataseries.get_series_values(
sd, cd.report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual([80] + range(20) + [200, 200, 400, 300, 200],
[sv.value for sv in res])
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
points_report = vars['points_report']
SECTION('Label-less report instances')
numbers = Report.select_or_insert(owner_id, 'numbers')
input = """\
10 20 30
40 50 60
"""
res = numbers.process_input(input)
series_spec = SeriesSpec(1, -1, {'op': 'eq', 'args': ['1']})
print series_spec.get_cell(res.report_instance)
metric = Report.select_or_insert(owner_id, 'metric')
res = metric.process_input('32.4')
series_spec = SeriesSpec(0, -1, {'op': 'eq', 'args': ['0']})
print series_spec.get_cell(res.report_instance)
SECTION('Handling reordering of columns')
input = """\
user_name is_active points
john true 128
monique true 210
"""
res = points_report.process_input(input, force_header=[0])
series_spec = SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']})
print series_spec.get_cell(res.report_instance)
input_2 = """\
user_name points is_active
john 128 true
monique 210 true
"""
res_2 = points_report.process_input(input_2, force_header=[0])
print series_spec.get_cell(res_2.report_instance)
series_spec.promote_colnos_to_headers(res.report_instance)
print series_spec.get_cell(res_2.report_instance)
SECTION('A lower-level interface to data series')
from mqe.dataseries import SeriesDef, get_series_values
from datetime import datetime
series_spec = SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']})
series_id = SeriesDef.insert(points_report.report_id, [], series_spec)
series_def = SeriesDef.select(points_report.report_id, [], series_id)
series_values = get_series_values(series_def,
points_report,
from_dt=datetime(2017, 1, 1),
to_dt=datetime(2018, 1, 1))
point_values = [sv.value for sv in series_values]
